You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@plc4x.apache.org by cd...@apache.org on 2020/10/07 22:05:03 UTC
[plc4x] branch feature/plc4go updated: Continued working on the
templates for the parsers
This is an automated email from the ASF dual-hosted git repository.
cdutz pushed a commit to branch feature/plc4go
in repository https://gitbox.apache.org/repos/asf/plc4x.git
The following commit(s) were added to refs/heads/feature/plc4go by this push:
new 9bee54d Continued working on the templates for the parsers
9bee54d is described below
commit 9bee54dd598fc5700862724de2ac7b107bc3d175
Author: Christofer Dutz <ch...@c-ware.de>
AuthorDate: Thu Oct 8 00:04:55 2020 +0200
Continued working on the templates for the parsers
---
.../language/go/GoLanguageTemplateHelper.java | 30 +-
.../main/resources/templates/go/enum-template.ftlh | 2 +-
.../resources/templates/go/model-template.ftlh | 426 ++++++++++++++++++++-
.../plc4go/go/modbus/readwrite/ModbusConstants.go | 38 +-
.../plc4go/go/modbus/readwrite/ModbusDataType.go | 2 +-
.../plc4go/go/modbus/readwrite/ModbusPDU.go | 102 ++++-
.../modbus/readwrite/ModbusPDUDiagnosticRequest.go | 29 +-
.../plc4go/go/modbus/readwrite/ModbusPDUError.go | 26 +-
.../readwrite/ModbusPDUGetComEventLogRequest.go | 23 +-
.../readwrite/ModbusPDUGetComEventLogResponse.go | 91 +++--
.../ModbusPDUMaskWriteHoldingRegisterRequest.go | 32 +-
.../ModbusPDUMaskWriteHoldingRegisterResponse.go | 32 +-
.../modbus/readwrite/ModbusPDUReadCoilsRequest.go | 29 +-
.../modbus/readwrite/ModbusPDUReadCoilsResponse.go | 64 +++-
.../ModbusPDUReadDeviceIdentificationRequest.go | 23 +-
.../ModbusPDUReadDeviceIdentificationResponse.go | 23 +-
.../ModbusPDUReadDiscreteInputsRequest.go | 29 +-
.../ModbusPDUReadDiscreteInputsResponse.go | 64 +++-
.../ModbusPDUReadExceptionStatusRequest.go | 23 +-
.../ModbusPDUReadExceptionStatusResponse.go | 26 +-
.../readwrite/ModbusPDUReadFifoQueueRequest.go | 26 +-
.../readwrite/ModbusPDUReadFifoQueueResponse.go | 71 +++-
.../readwrite/ModbusPDUReadFileRecordRequest.go | 63 ++-
.../ModbusPDUReadFileRecordRequestItem.go | 31 +-
.../readwrite/ModbusPDUReadFileRecordResponse.go | 63 ++-
.../ModbusPDUReadFileRecordResponseItem.go | 67 +++-
.../ModbusPDUReadHoldingRegistersRequest.go | 29 +-
.../ModbusPDUReadHoldingRegistersResponse.go | 64 +++-
.../ModbusPDUReadInputRegistersRequest.go | 29 +-
.../ModbusPDUReadInputRegistersResponse.go | 64 +++-
...sPDUReadWriteMultipleHoldingRegistersRequest.go | 100 +++--
...PDUReadWriteMultipleHoldingRegistersResponse.go | 64 +++-
.../readwrite/ModbusPDUReportServerIdRequest.go | 23 +-
.../readwrite/ModbusPDUReportServerIdResponse.go | 64 +++-
.../readwrite/ModbusPDUWriteFileRecordRequest.go | 63 ++-
.../ModbusPDUWriteFileRecordRequestItem.go | 85 ++--
.../readwrite/ModbusPDUWriteFileRecordResponse.go | 63 ++-
.../ModbusPDUWriteFileRecordResponseItem.go | 85 ++--
.../ModbusPDUWriteMultipleCoilsRequest.go | 82 ++--
.../ModbusPDUWriteMultipleCoilsResponse.go | 29 +-
...odbusPDUWriteMultipleHoldingRegistersRequest.go | 82 ++--
...dbusPDUWriteMultipleHoldingRegistersResponse.go | 29 +-
.../readwrite/ModbusPDUWriteSingleCoilRequest.go | 29 +-
.../readwrite/ModbusPDUWriteSingleCoilResponse.go | 29 +-
.../ModbusPDUWriteSingleRegisterRequest.go | 29 +-
.../ModbusPDUWriteSingleRegisterResponse.go | 29 +-
.../plc4go/go/modbus/readwrite/ModbusSerialADU.go | 76 ++--
.../plc4go/go/modbus/readwrite/ModbusTcpADU.go | 72 ++--
sandbox/pom.xml | 1 -
49 files changed, 2071 insertions(+), 584 deletions(-)
diff --git a/build-utils/language-go/src/main/java/org/apache/plc4x/language/go/GoLanguageTemplateHelper.java b/build-utils/language-go/src/main/java/org/apache/plc4x/language/go/GoLanguageTemplateHelper.java
index 5ff1a03..eae61b6 100644
--- a/build-utils/language-go/src/main/java/org/apache/plc4x/language/go/GoLanguageTemplateHelper.java
+++ b/build-utils/language-go/src/main/java/org/apache/plc4x/language/go/GoLanguageTemplateHelper.java
@@ -214,44 +214,42 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp
public String getReadBufferReadMethodCall(SimpleTypeReference simpleTypeReference, String valueString) {
switch (simpleTypeReference.getBaseType()) {
case BIT: {
- return "io.readBit()";
+ return "io.ReadBit()";
}
case UINT: {
IntegerTypeReference integerTypeReference = (IntegerTypeReference) simpleTypeReference;
- if (integerTypeReference.getSizeInBits() <= 4) {
- return "io.readUnsignedByte(" + integerTypeReference.getSizeInBits() + ")";
- }
if (integerTypeReference.getSizeInBits() <= 8) {
- return "io.readUnsignedShort(" + integerTypeReference.getSizeInBits() + ")";
+ return "io.ReadUint8(" + integerTypeReference.getSizeInBits() + ")";
}
if (integerTypeReference.getSizeInBits() <= 16) {
- return "io.readUnsignedInt(" + integerTypeReference.getSizeInBits() + ")";
+ return "io.ReadUint16(" + integerTypeReference.getSizeInBits() + ")";
}
if (integerTypeReference.getSizeInBits() <= 32) {
- return "io.readUnsignedLong(" + integerTypeReference.getSizeInBits() + ")";
+ return "io.ReadUint32(" + integerTypeReference.getSizeInBits() + ")";
+ }
+ if (integerTypeReference.getSizeInBits() <= 64) {
+ return "io.ReadUint64(" + integerTypeReference.getSizeInBits() + ")";
}
- return "io.readUnsignedBigInteger(" + integerTypeReference.getSizeInBits() + ")";
}
case INT: {
IntegerTypeReference integerTypeReference = (IntegerTypeReference) simpleTypeReference;
if (integerTypeReference.getSizeInBits() <= 8) {
- return "io.readByte(" + integerTypeReference.getSizeInBits() + ")";
+ return "io.ReadInt8(" + integerTypeReference.getSizeInBits() + ")";
}
if (integerTypeReference.getSizeInBits() <= 16) {
- return "io.readShort(" + integerTypeReference.getSizeInBits() + ")";
+ return "io.ReadInt16(" + integerTypeReference.getSizeInBits() + ")";
}
if (integerTypeReference.getSizeInBits() <= 32) {
- return "io.readInt(" + integerTypeReference.getSizeInBits() + ")";
+ return "io.ReadInt32(" + integerTypeReference.getSizeInBits() + ")";
}
if (integerTypeReference.getSizeInBits() <= 64) {
- return "io.readLong(" + integerTypeReference.getSizeInBits() + ")";
+ return "io.ReadInt64(" + integerTypeReference.getSizeInBits() + ")";
}
- return "io.readBigInteger(" + integerTypeReference.getSizeInBits() + ")";
}
case FLOAT: {
FloatTypeReference floatTypeReference = (FloatTypeReference) simpleTypeReference;
- String type = (floatTypeReference.getSizeInBits() <= 32) ? "Float" : "Double";
- String typeCast = (floatTypeReference.getSizeInBits() <= 32) ? "float" : "double";
+ String type = (floatTypeReference.getSizeInBits() <= 32)? "ReadFloat32" : "ReadFloat64";
+ String typeCast = (floatTypeReference.getSizeInBits() <= 32) ? "float32" : "float64";
String defaultNull = (floatTypeReference.getSizeInBits() <= 32) ? "0.0f" : "0.0";
StringBuilder sb = new StringBuilder("((Supplier<").append(type).append(">) (() -> {");
sb.append("\n return (").append(typeCast).append(") toFloat(io, ").append(
@@ -263,7 +261,7 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp
}
case STRING: {
StringTypeReference stringTypeReference = (StringTypeReference) simpleTypeReference;
- return "io.readString(" + stringTypeReference.getSizeInBits() + ", \"" +
+ return "io.ReadString(" + stringTypeReference.getSizeInBits() + ", \"" +
stringTypeReference.getEncoding() + "\")";
}
}
diff --git a/build-utils/language-go/src/main/resources/templates/go/enum-template.ftlh b/build-utils/language-go/src/main/resources/templates/go/enum-template.ftlh
index 6e6733e..3db4ae8 100644
--- a/build-utils/language-go/src/main/resources/templates/go/enum-template.ftlh
+++ b/build-utils/language-go/src/main/resources/templates/go/enum-template.ftlh
@@ -80,7 +80,7 @@ func (e ${type.name}) Get${constantName?cap_first}() ${helper.getLanguageTypeNam
</#if>
<#if type.type?has_content>
-func (e ${type.name}) Parse(io spi.ReadBuffer) {
+func (e *${type.name}) Parse(io spi.ReadBuffer) {
// TODO: Implement ...
}
diff --git a/build-utils/language-go/src/main/resources/templates/go/model-template.ftlh b/build-utils/language-go/src/main/resources/templates/go/model-template.ftlh
index 73af1a4..dd7c5d8 100644
--- a/build-utils/language-go/src/main/resources/templates/go/model-template.ftlh
+++ b/build-utils/language-go/src/main/resources/templates/go/model-template.ftlh
@@ -62,7 +62,10 @@ ${helper.fileName(protocolName, languageName, outputFlavor)?replace(".", "/")}/$
//
package ${helper.packageName(outputFlavor)}
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ${type.name} struct {
<#-- Prpoerty fields are fields that require a property in the pojo -->
@@ -78,6 +81,21 @@ type ${type.name} struct {
<#if type.parentType??> ${type.parentType.name}</#if>
}
+<#if helper.isDiscriminatedParentTypeDefinition()>
+type ${type.name}Initializer interface {
+ initialize(<#list type.getAllPropertyFields() as field>${field.name}: ${field.name}<#sep>, </#sep></#list>) ${type.name}
+}
+<#else>
+<#if type.parentType??>func (m ${type.name}) initialize(<#list type.parentType.getAllPropertyFields() as field>${field.name}: ${field.name}<#sep>, </#sep></#list>) ${type.parentType.name} {
+ return m.${type.parentType.name}
+}
+</#if>
+
+func New${type.name}(<#list type.getAllPropertyFields() as field>${field.name} <#if field.loopType??>[]</#if>${helper.getLanguageTypeNameForField(field)}<#sep>, </#sep></#list>) <#if type.parentType??>${type.parentType.name}Initializer<#else>${type.name}</#if> {
+ return &${type.name}{<#list type.getAllPropertyFields() as field>${field.name}: ${field.name}<#sep>, </#sep></#list>}
+}
+</#if>
+
func (m ${type.name}) LengthInBits() uint16 {
var lengthInBits uint16 = <#if type.parentType??>m.${type.parentType.name}.LengthInBits()<#else>0</#if>
<#list type.fields as field>
@@ -205,11 +223,411 @@ func (m ${type.name}) LengthInBytes() uint16 {
return m.LengthInBits() / 8
}
-func (m ${type.name}) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
+func ${type.name}Parse(io spi.ReadBuffer<#if type.parserArguments?has_content>, <#list type.parserArguments as parserArgument>${parserArgument.name} ${helper.getLanguageTypeNameForTypeReference(parserArgument.type)}<#sep>, </#sep></#list></#if>) <#if type.parentType??>${type.parentType.name}Initializer<#else>${type.name}</#if> {
+ var startPos = io.GetPos()
+ var curPos uint16
+ <#list type.fields as field>
+ <#switch field.typeName>
+ <#case "array">
+ <#assign arrayField = field>
+
+ // Array field (${arrayField.name})
+ <#-- Only update curPos if the length expression uses it -->
+ <#if arrayField.loopExpression.contains("curPos")>
+ curPos = io.GetPos() - startPos
+ </#if>
+ <#-- If this is a count array, we can directly initialize an array with the given size -->
+ <#if helper.isCountArrayField(field)>
+ // Count array
+ if ${helper.toParseExpression(arrayField, arrayField.loopExpression, type.parserArguments)} > math.MaxUint8 {
+ throw new ParseException("Array count of " + (${helper.toParseExpression(arrayField, arrayField.loopExpression, type.parserArguments)}) + " exceeds the maximum allowed count of " + math.MaxUint8);
+ }
+ ${helper.getLanguageTypeNameForField(field)}[] ${arrayField.name};
+ {
+ var itemCount := ${helper.toParseExpression(arrayField, arrayField.loopExpression, type.parserArguments)}
+ ${arrayField.name} = new ${helper.getLanguageTypeNameForField(field)}[itemCount]
+ for curItem := 0; curItem < itemCount; curItem++ {
+ <#-- When parsing simple types, there is nothing that could require the "lastItem" -->
+ <#if !helper.isSimpleTypeReference(arrayField.type)>boolean lastItem = curItem == (itemCount - 1);</#if>
+ ${arrayField.name}[curItem] = <#if helper.isSimpleTypeReference(arrayField.type)><#assign simpleTypeReference = arrayField.type>${helper.getReadBufferReadMethodCall(simpleTypeReference)}<#else>${arrayField.type.name}IO.staticParse(io<#if field.params?has_content>, <#list field.params as parserArgument>(${helper.getLanguageTypeNameForTypeReference(helper.getArgumentType(arrayField.type, parserArgument?index))}) (${helper.toParseExpression(arrayField, parserArgument, type.parse [...]
+ }
+ }
+ <#-- In all other cases do we have to work with a list, that is later converted to an array -->
+ <#else>
+ <#-- For a length array, we read data till the read position of the buffer reaches a given position -->
+ <#if helper.isLengthArrayField(field)>
+ // Length array
+ var _${arrayField.name}Length := ${helper.toParseExpression(arrayField, arrayField.loopExpression, type.parserArguments)}
+ List<${helper.getLanguageTypeNameForField(arrayField)}> _${arrayField.name}List = new LinkedList<>();
+ ${arrayField.name}EndPos := io.GetPos() + _${arrayField.name}Length;
+ for ;io.getPos() < ${arrayField.name}EndPos; {
+ _${arrayField.name}List.add(<#if helper.isSimpleTypeReference(arrayField.type)><#assign simpleTypeReference = arrayField.type>${helper.getReadBufferReadMethodCall(simpleTypeReference)}<#else>${arrayField.type.name}IO.staticParse(io<#if field.params?has_content>, <#list field.params as parserArgument>(${helper.getLanguageTypeNameForTypeReference(helper.getArgumentType(arrayField.type, parserArgument?index))}) (${helper.toParseExpression(arrayField, parserArgument, type.parserArgum [...]
+ <#-- After parsing, update the current position, but only if it's needed -->
+ <#if arrayField.loopExpression.contains("curPos")>
+ curPos = io.getPos() - startPos;
+ </#if>
+ }
+ <#-- A terminated array keeps on reading data as long as the termination expression evaluates to false -->
+ <#elseif helper.isTerminatedArrayField(field)>
+ // Terminated array
+ List<${helper.getLanguageTypeNameForField(arrayField)}> _${arrayField.name}List = new LinkedList<>();
+ for ;!((boolean) (${helper.toParseExpression(arrayField, arrayField.loopExpression, type.parserArguments)})); {
+ _${arrayField.name}List.add(<#if helper.isSimpleTypeReference(arrayField.type)><#assign simpleTypeReference = arrayField.type>${helper.getReadBufferReadMethodCall(simpleTypeReference)}<#else>${arrayField.type.name}IO.staticParse(io<#if field.params?has_content>, <#list field.params as parserArgument>(${helper.getLanguageTypeNameForTypeReference(helper.getArgumentType(arrayField.type, parserArgument?index))}) (${helper.toParseExpression(arrayField, parserArgument, type.parserArgum [...]
+
+ <#-- After parsing, update the current position, but only if it's needed -->
+ <#if arrayField.loopExpression.contains("curPos")>
+ curPos = io.getPos() - startPos
+ </#if>
+ }
+ </#if>
+ <#--
+ Convert the list into an array. However if the array is of a primitive
+ type we have to iterate over it's elements and explicitly cast them.
+ Otherwise a simple toArray call is fine.
+ -->
+ <#if helper.isSimpleTypeReference(arrayField.type)>
+ ${helper.getLanguageTypeNameForField(field)}[] ${arrayField.name} = new ${helper.getLanguageTypeNameForField(field)}[_${arrayField.name}List.size()]
+ for i := 0; i < _${arrayField.name}List.size(); i++ {
+ ${arrayField.name}[i] = (${helper.getLanguageTypeNameForField(field)}) _${arrayField.name}List.get(i)
+ }
+ <#else>
+ ${helper.getLanguageTypeNameForField(field)}[] ${arrayField.name} = _${arrayField.name}List.toArray(new ${helper.getLanguageTypeNameForField(arrayField)}[0])
+ </#if>
+ </#if>
+ <#break>
+ <#case "checksum">
+ <#assign checksumField = field>
+ <#assign simpleTypeReference = checksumField.type>
+
+ // Checksum Field (checksum)
+ {
+ checksum = ${helper.getNullValueForTypeReference(checksumField.type)}
+ // Create an array of all the bytes read in this message element so far.
+ byte[] checksumRawData = io.getBytes(startPos, io.getPos())
+ ${helper.getLanguageTypeNameForField(field)} checksumRef = ${helper.getReadBufferReadMethodCall(simpleTypeReference)}
+ checksum = (${helper.getLanguageTypeNameForField(field)}) (${helper.toParseExpression(checksumField, checksumField.checksumExpression, type.parserArguments)})
+ if checksum != checksumRef {
+ throw new ParseException(String.format("Checksum verification failed. Expected %04X but got %04X", checksumRef & 0xFFFF, checksum & 0xFFFF));
+ }
+ }
+ <#break>
+ <#case "const">
+ <#assign constField = field>
+ <#assign simpleTypeReference = constField.type>
+
+ // Const Field (${constField.name})
+ ${helper.getLanguageTypeNameForField(field)} ${constField.name} = ${helper.getReadBufferReadMethodCall(simpleTypeReference)}
+ if ${constField.name} != ${type.name}.${constField.name?upper_case} {
+ throw new ParseException("Expected constant value " + ${type.name}.${constField.name?upper_case} + " but got " + ${constField.name})
+ }
+ <#break>
+ <#case "discriminator">
+ <#assign discriminatorField = field>
+ <#assign simpleTypeReference = discriminatorField.type>
+
+ // Discriminator Field (${discriminatorField.name}) (Used as input to a switch field)
+ var ${discriminatorField.name} ${helper.getLanguageTypeNameForField(field)} = ${helper.getReadBufferReadMethodCall(simpleTypeReference)}
+ <#break>
+ <#case "enum">
+ <#assign enumField = field>
+
+ // Enum field (${enumField.name})
+ var ${enumField.name} ${helper.getLanguageTypeNameForField(field)} = ${helper.getLanguageTypeNameForField(field)}.valueOf(${helper.getReadBufferReadMethodCall(helper.getEnumBaseTypeReference(enumField.type))})
+ <#break>
+ <#case "implicit">
+ <#assign implicitField = field>
+ <#assign simpleTypeReference = implicitField.type>
+
+ // Implicit Field (${implicitField.name}) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ var ${implicitField.name} ${helper.getLanguageTypeNameForField(field)} = ${helper.getReadBufferReadMethodCall(simpleTypeReference)}
+ <#break>
+ <#case "manualArray">
+ <#assign manualArrayField = field>
+
+ // Manual Array Field (${manualArrayField.name})
+ <#-- Only update curPos if the length expression uses it -->
+ <#if manualArrayField.loopExpression.contains("curPos")>
+ curPos = io.getPos() - startPos
+ </#if>
+ <#-- If this is a count array, we can directly initialize an array with the given size -->
+ <#if helper.isCountArrayField(field)>
+ // Count array
+ _${manualArrayField.name}Count := ${helper.toParseExpression(manualArrayField, manualArrayField.loopExpression, type.parserArguments)}
+ ${helper.getLanguageTypeNameForField(field)}[] ${manualArrayField.name} = new ${helper.getLanguageTypeNameForField(field)}[_${manualArrayField.name}Count]
+ for i := 0; i < _${manualArrayField.name}Count; i++ {
+ ${manualArrayField.name}[i] = (${helper.getLanguageTypeNameForField(field)}) (${helper.toParseExpression(manualArrayField, manualArrayField.parseExpression, type.parserArguments)})
+ }
+ <#-- In all other cases do we have to work with a list, that is later converted to an array -->
+ <#else>
+ <#-- For a length array, we read data till the read position of the buffer reaches a given position -->
+ <#if helper.isLengthArrayField(field)>
+ // Length array
+ _${manualArrayField.name}Length := ${helper.toParseExpression(manualArrayField, manualArrayField.loopExpression, type.parserArguments)}
+ List<${helper.getLanguageTypeNameForField(manualArrayField)}> _${manualArrayField.name}List = new LinkedList<>()
+ ${manualArrayField.name}EndPos := io.getPos() + _${manualArrayField.name}Length
+ for ;io.getPos() < ${manualArrayField.name}EndPos; {
+ _${manualArrayField.name}List.add((${helper.getLanguageTypeNameForField(field)}) (${helper.toParseExpression(manualArrayField, manualArrayField.parseExpression, type.parserArguments)}))
+ <#-- After parsing, update the current position, but only if it's needed -->
+ <#if manualArrayField.loopExpression.contains("curPos")>
+ curPos = io.getPos() - startPos
+ </#if>
+ }
+ <#-- A terminated array keeps on reading data as long as the termination expression evaluates to false -->
+ <#elseif helper.isTerminatedArrayField(field)>
+ // Terminated array
+ List<${helper.getLanguageTypeNameForField(manualArrayField)}> _${manualArrayField.name}List = new LinkedList<>()
+ for ;!((boolean) (${helper.toParseExpression(manualArrayField, manualArrayField.loopExpression, type.parserArguments)})); {
+ _${manualArrayField.name}List.add((${helper.getLanguageTypeNameForField(field)}) (${helper.toParseExpression(manualArrayField, manualArrayField.parseExpression, type.parserArguments)}))
+
+ <#-- After parsing, update the current position, but only if it's needed -->
+ <#if manualArrayField.loopExpression.contains("curPos")>
+ curPos = io.getPos() - startPos
+ </#if>
+ }
+ </#if>
+ <#--
+ Convert the list into an array. However if the array is of a primitive
+ type we have to iterate over it's elements and explicitly cast them.
+ Otherwise a simple toArray call is fine.
+ -->
+ <#if helper.isSimpleTypeReference(field.type)>
+ ${helper.getLanguageTypeNameForField(field)}[] ${manualArrayField.name} = new ${helper.getLanguageTypeNameForField(field)}[_${manualArrayField.name}List.size()]
+ for i := 0; i < _${manualArrayField.name}List.size(); i++ {
+ ${manualArrayField.name}[i] = (${helper.getLanguageTypeNameForField(field)}) _${manualArrayField.name}List.get(i)
+ }
+ <#else>
+ ${helper.getLanguageTypeNameForField(field)}[] ${manualArrayField.name} = _${manualArrayField.name}List.toArray(new ${helper.getLanguageTypeNameForField(manualArrayField)}[0])
+ </#if>
+ </#if>
+ <#break>
+ <#case "manual">
+ <#assign manualField = field>
+
+ // Manual Field (${manualField.name})
+ var ${manualField.name} ${helper.getLanguageTypeNameForField(field)} = (${helper.getLanguageTypeNameForField(field)}) (${helper.toParseExpression(manualField, manualField.parseExpression, type.parserArguments)})
+ <#break>
+ <#case "optional">
+ <#assign optionalField = field>
+
+ // Optional Field (${optionalField.name}) (Can be skipped, if a given expression evaluates to false)
+ <#if optionalField.conditionExpression.contains("curPos")>
+ curPos = io.getPos() - startPos
+ </#if>
+ var ${optionalField.name} ${helper.getLanguageTypeNameForField(field)} = null
+ if ${helper.toParseExpression(optionalField, optionalField.conditionExpression, type.parserArguments)} {
+ ${optionalField.name} = <#if helper.isSimpleTypeReference(optionalField.type)>${helper.getReadBufferReadMethodCall(optionalField.type)}<#else>${optionalField.type.name}IO.staticParse(io<#if field.params?has_content>, <#list field.params as parserArgument>(${helper.getLanguageTypeNameForTypeReference(helper.getArgumentType(optionalField.type, parserArgument?index))}) (${helper.toParseExpression(optionalField, parserArgument, type.parserArguments)})<#sep>, </#sep></#list></#if>)</#if>
+ }
+ <#break>
+ <#case "padding">
+ <#assign paddingField = field>
+ <#assign simpleTypeReference = paddingField.type>
+
+ // Padding Field (padding)
+ {
+ _timesPadding := (${helper.toParseExpression(paddingField, paddingField.paddingCondition, type.parserArguments)})
+ for ;(io.hasMore(${helper.getNumBits(simpleTypeReference)})) && (_timesPadding-- > 0); {
+ // Just read the padding data and ignore it
+ ${helper.getReadBufferReadMethodCall(simpleTypeReference)}
+ }
+ }
+ <#break>
+ <#case "reserved">
+ <#assign reservedField = field>
+ <#assign simpleTypeReference = reservedField.type>
+
+ // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
+ {
+ var reserved ${helper.getLanguageTypeNameForField(field)} = ${helper.getReadBufferReadMethodCall(simpleTypeReference)}
+ if reserved != ${helper.getReservedValue(reservedField)} {
+ LOGGER.info("Expected constant value " + ${reservedField.referenceValue} + " but got " + reserved + " for reserved field.")
+ }
+ }
+ <#break>
+ <#case "simple">
+ <#assign simpleField = field>
+
+ // Simple Field (${simpleField.name})
+ var ${simpleField.name} ${helper.getLanguageTypeNameForField(field)} = <#if helper.isSimpleTypeReference(simpleField.type)><#assign simpleTypeReference = simpleField.type>${helper.getReadBufferReadMethodCall(simpleTypeReference)}<#else><#assign complexTypeReference = simpleField.type>${complexTypeReference.name}IO.staticParse(io<#if field.params?has_content>, <#list field.params as parserArgument>(${helper.getLanguageTypeNameForTypeReference(helper.getArgumentType(simpleField.type, p [...]
+ <#break>
+ <#case "switch">
+ <#assign switchField = field>
+
+ // Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type)
+ var initializer ${type.name}Initializer
+ switch {
+ <#list switchField.cases as case>
+ <#if case.discriminatorValues?has_content>case <#list case.discriminatorValues as discriminatorValue>${helper.toParseExpression(null, switchField.discriminatorExpressions[discriminatorValue?index], type.parserArguments)} == ${discriminatorValue}<#sep> && </#sep></#list></#if>:
+ initializer = ${case.name}Parse(io<#if case.parserArguments?has_content>, <#list case.parserArguments as parserArgument>${parserArgument.name}<#sep>, </#sep></#list></#if>)
+ </#list>
+ }
+ <#break>
+
+ <#case "virtual">
+ <#assign virtualField = field>
+
+ // Virtual field (Just declare a local variable so we can access it in the parser)
+ var ${virtualField.name} ${helper.getLanguageTypeNameForField(field)} = (${helper.getLanguageTypeNameForField(field)}) (${helper.toParseExpression(virtualField, virtualField.valueExpression, type.parserArguments)})
+ <#break>
+ </#switch>
+ </#list>
+
+ // Create the instance
+ <#if helper.isDiscriminatedParentTypeDefinition()>
+ return initializer.initialize(<#list type.propertyFields as field>${field.name}<#sep>, </#sep></#list>)
+ <#else>
+ return New${type.name}(<#list type.propertyFields as field>${field.name}<#sep>, </#sep></#list>)
+ </#if>
}
+ <#--if outputFlavor != "passive">
func (m ${type.name}) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ int startPos = io.getPos();
+
+ <#list type.fields as field>
+ <#switch field.typeName>
+ <#case "array">
+ <#assign arrayField = field>
+ <#assign simpleTypeReference = arrayField.type>
+
+ // Array Field (${arrayField.name})
+ if(_value.get${arrayField.name?cap_first}() != null) {
+ int itemCount = (int) _value.get${arrayField.name?cap_first}().length;
+ int curItem = 0;
+ for(${helper.getLanguageTypeNameForField(field)} element : _value.get${arrayField.name?cap_first}()) {
+ <#if helper.isSimpleTypeReference(arrayField.type)>
+ <#assign simpleTypeReference = arrayField.type>
+ ${helper.getWriteBufferWriteMethodCall(simpleTypeReference, "element")};
+ <#else>
+ <#assign complexTypeReference = arrayField.type>
+ boolean lastItem = curItem == (itemCount - 1);
+ ${complexTypeReference.name}IO.staticSerialize(io, element<#if helper.getSerializerTerms(field.params)?has_content>, <#list helper.getSerializerTerms(field.params) as parserArgument>${parserArgument.name}<#sep>, </#sep></#list></#if>);
+ </#if>
+ curItem++;
+ }
+ }
+ <#break>
+ <#case "checksum">
+ <#assign checksumField = field>
+ <#assign simpleTypeReference = checksumField.type>
+
+ // Checksum Field (checksum) (Calculated)
+ {
+ ${helper.getLanguageTypeNameForField(field)} _checksum = ${helper.getNullValueForTypeReference(checksumField.type)};
+ // Create an array of all the bytes written in this message element so far.
+ byte[] checksumRawData = io.getBytes(startPos, io.getPos());
+ _checksum = (${helper.getLanguageTypeNameForField(field)}) (${helper.toSerializationExpression(checksumField, checksumField.checksumExpression, type.parserArguments)});
+ ${helper.getWriteBufferWriteMethodCall(simpleTypeReference, "(_checksum)")};
+ }
+ <#break>
+ <#case "const">
+ <#assign constField = field>
+ <#assign simpleTypeReference = constField.type>
+
+ // Const Field (${constField.name})
+ ${helper.getWriteBufferWriteMethodCall(simpleTypeReference, constField.referenceValue)};
+ <#break>
+ <#case "discriminator">
+ <#assign discriminatorField = field>
+ <#assign simpleTypeReference = discriminatorField.type>
+
+ // Discriminator Field (${discriminatorField.name}) (Used as input to a switch field)
+ ${helper.getLanguageTypeNameForField(field)} ${discriminatorField.name} = (${helper.getLanguageTypeNameForField(field)}) _value.get${discriminatorField.name?cap_first}();
+ ${helper.getWriteBufferWriteMethodCall(simpleTypeReference, "(" + discriminatorField.name + ")")};
+ <#break>
+ <#case "enum">
+ <#assign enumField = field>
+
+ // Enum field (${enumField.name})
+ ${helper.getLanguageTypeNameForField(field)} ${enumField.name} = (${helper.getLanguageTypeNameForField(field)}) _value.get${enumField.name?cap_first}();
+ ${helper.getWriteBufferWriteMethodCall(helper.getEnumBaseTypeReference(enumField.type), "(" + enumField.name + ".getValue())")};
+ <#break>
+ <#case "implicit">
+ <#assign implicitField = field>
+ <#assign simpleTypeReference = implicitField.type>
+
+ // Implicit Field (${implicitField.name}) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ ${helper.getLanguageTypeNameForField(field)} ${implicitField.name} = (${helper.getLanguageTypeNameForField(field)}) (${helper.toSerializationExpression(implicitField, implicitField.serializeExpression, type.parserArguments)});
+ ${helper.getWriteBufferWriteMethodCall(simpleTypeReference, "(" + implicitField.name + ")")};
+ <#break>
+ <#case "manualArray">
+ <#assign manualArrayField = field>
+
+ // Manual Array Field (${manualArrayField.name})
+ if(_value.get${manualArrayField.name?cap_first}() != null) {
+ for(${helper.getLanguageTypeNameForField(field)} element : _value.get${manualArrayField.name?cap_first}()) {
+ ${helper.toSerializationExpression(manualArrayField, manualArrayField.serializeExpression, type.parserArguments)};
+ }
+ }
+ <#break>
+ <#case "manual">
+ <#assign manualField = field>
+
+ // Manual Field (${manualField.name})
+ ${helper.toSerializationExpression(manualField, manualField.serializeExpression, type.parserArguments)};
+ <#break>
+ <#case "optional">
+ <#assign optionalField = field>
+
+ // Optional Field (${optionalField.name}) (Can be skipped, if the value is null)
+ ${helper.getLanguageTypeNameForField(field)} ${optionalField.name} = null;
+ if(_value.get${optionalField.name?cap_first}() != null) {
+ ${optionalField.name} = (${helper.getLanguageTypeNameForField(field)}) _value.get${optionalField.name?cap_first}();
+ <#if helper.isSimpleTypeReference(optionalField.type)>
+ <#assign simpleTypeReference = optionalField.type>
+ ${helper.getWriteBufferWriteMethodCall(simpleTypeReference, "(" + optionalField.name + ")")};
+ <#else>
+ <#assign complexTypeReference = optionalField.type>
+ ${complexTypeReference.name}IO.staticSerialize(io, ${optionalField.name});
+ </#if>
+ }
+ <#break>
+ <#case "padding">
+ <#assign paddingField = field>
+ <#assign simpleTypeReference = paddingField.type>
+
+ // Padding Field (padding)
+ {
+ int _timesPadding = (int) (${helper.toSerializationExpression(paddingField, paddingField.paddingCondition, type.parserArguments)});
+ while (_timesPadding-- > 0) {
+ ${helper.getLanguageTypeNameForField(field)} _paddingValue = (${helper.getLanguageTypeNameForField(field)}) (${helper.toSerializationExpression(paddingField, paddingField.paddingValue, type.parserArguments)});
+ ${helper.getWriteBufferWriteMethodCall(simpleTypeReference, "(_paddingValue)")};
+ }
+ }
+ <#break>
+ <#case "reserved">
+ <#assign reservedField = field>
+ <#assign simpleTypeReference = reservedField.type>
+
+ // Reserved Field (reserved)
+ ${helper.getWriteBufferWriteMethodCall(simpleTypeReference, helper.getReservedValue(field))};
+ <#break>
+ <#case "simple">
+ <#assign simpleField = field>
+
+ // Simple Field (${simpleField.name})
+ ${helper.getLanguageTypeNameForField(field)} ${simpleField.name} = (${helper.getLanguageTypeNameForField(field)}) _value.get${simpleField.name?cap_first}();
+ <#if helper.isSimpleTypeReference(simpleField.type)>
+ <#assign simpleTypeReference = simpleField.type>
+ ${helper.getWriteBufferWriteMethodCall(simpleTypeReference, "(" + simpleField.name + ")")};
+ <#else>
+ <#assign complexTypeReference = simpleField.type>
+ ${complexTypeReference.name}IO.staticSerialize(io, ${simpleField.name});
+ </#if>
+ <#break>
+ <#case "switch">
+ <#assign switchField = field>
+
+ // Switch field (Depending on the discriminator values, passes the instantiation to a sub-type)
+ <#list switchField.cases as case>
+ if(_value instanceof ${case.name}) {
+ ${case.name}IO.staticSerialize(io, (${case.name}) _value);
+ }<#sep> else </#sep>
+ </#list>
+ <#break>
+ <#case "virtual">
+ <#break>
+ </#switch>
+ </#list>
}
+ </#if-->
</#outputformat>
\ No newline at end of file
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusConstants.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusConstants.go
index e703784..43594ac 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusConstants.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusConstants.go
@@ -18,28 +18,44 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusConstants struct {
+
+}
+
+
+func NewModbusConstants() ModbusConstants {
+ return &ModbusConstants{}
}
func (m ModbusConstants) LengthInBits() uint16 {
- var lengthInBits uint16 = 0
+ var lengthInBits uint16 = 0
- // Const Field (modbusTcpDefaultPort)
- lengthInBits += 16
+ // Const Field (modbusTcpDefaultPort)
+ lengthInBits += 16
- return lengthInBits
+ return lengthInBits
}
func (m ModbusConstants) LengthInBytes() uint16 {
- return m.LengthInBits() / 8
+ return m.LengthInBits() / 8
}
-func (m ModbusConstants) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusConstantsParse(io spi.ReadBuffer) ModbusConstants {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Const Field (modbusTcpDefaultPort)
+ uint16 modbusTcpDefaultPort = io.ReadUint16(16)
+ if modbusTcpDefaultPort != ModbusConstants.MODBUSTCPDEFAULTPORT {
+ throw new ParseException("Expected constant value " + ModbusConstants.MODBUSTCPDEFAULTPORT + " but got " + modbusTcpDefaultPort)
+ }
-func (m ModbusConstants) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Create the instance
+ return NewModbusConstants()
}
+
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusDataType.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusDataType.go
index 345e872..6c59b5b 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusDataType.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusDataType.go
@@ -174,7 +174,7 @@ func (e ModbusDataType) GetDataTypeSize() uint8 {
}
}
-func (e ModbusDataType) Parse(io spi.ReadBuffer) {
+func (e *ModbusDataType) Parse(io spi.ReadBuffer) {
// TODO: Implement ...
}
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDU.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDU.go
index e8545dc..3006f4c 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDU.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDU.go
@@ -18,11 +18,18 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDU struct {
}
+type ModbusPDUInitializer interface {
+ initialize() ModbusPDU
+}
+
func (m ModbusPDU) LengthInBits() uint16 {
var lengthInBits uint16 = 0
@@ -41,10 +48,93 @@ func (m ModbusPDU) LengthInBytes() uint16 {
return m.LengthInBits() / 8
}
-func (m ModbusPDU) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUParse(io spi.ReadBuffer, response bool) ModbusPDU {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Discriminator Field (error) (Used as input to a switch field)
+ var error bool = io.ReadBit()
+
+ // Discriminator Field (function) (Used as input to a switch field)
+ var function uint8 = io.ReadUint8(7)
+
+ // Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type)
+ var initializer ModbusPDUInitializer
+ switch {
+ case error == true:
+ initializer = ModbusPDUErrorParse(io)
+ case error == false && function == 0x02 && response == false:
+ initializer = ModbusPDUReadDiscreteInputsRequestParse(io)
+ case error == false && function == 0x02 && response == true:
+ initializer = ModbusPDUReadDiscreteInputsResponseParse(io)
+ case error == false && function == 0x01 && response == false:
+ initializer = ModbusPDUReadCoilsRequestParse(io)
+ case error == false && function == 0x01 && response == true:
+ initializer = ModbusPDUReadCoilsResponseParse(io)
+ case error == false && function == 0x05 && response == false:
+ initializer = ModbusPDUWriteSingleCoilRequestParse(io)
+ case error == false && function == 0x05 && response == true:
+ initializer = ModbusPDUWriteSingleCoilResponseParse(io)
+ case error == false && function == 0x0F && response == false:
+ initializer = ModbusPDUWriteMultipleCoilsRequestParse(io)
+ case error == false && function == 0x0F && response == true:
+ initializer = ModbusPDUWriteMultipleCoilsResponseParse(io)
+ case error == false && function == 0x04 && response == false:
+ initializer = ModbusPDUReadInputRegistersRequestParse(io)
+ case error == false && function == 0x04 && response == true:
+ initializer = ModbusPDUReadInputRegistersResponseParse(io)
+ case error == false && function == 0x03 && response == false:
+ initializer = ModbusPDUReadHoldingRegistersRequestParse(io)
+ case error == false && function == 0x03 && response == true:
+ initializer = ModbusPDUReadHoldingRegistersResponseParse(io)
+ case error == false && function == 0x06 && response == false:
+ initializer = ModbusPDUWriteSingleRegisterRequestParse(io)
+ case error == false && function == 0x06 && response == true:
+ initializer = ModbusPDUWriteSingleRegisterResponseParse(io)
+ case error == false && function == 0x10 && response == false:
+ initializer = ModbusPDUWriteMultipleHoldingRegistersRequestParse(io)
+ case error == false && function == 0x10 && response == true:
+ initializer = ModbusPDUWriteMultipleHoldingRegistersResponseParse(io)
+ case error == false && function == 0x17 && response == false:
+ initializer = ModbusPDUReadWriteMultipleHoldingRegistersRequestParse(io)
+ case error == false && function == 0x17 && response == true:
+ initializer = ModbusPDUReadWriteMultipleHoldingRegistersResponseParse(io)
+ case error == false && function == 0x16 && response == false:
+ initializer = ModbusPDUMaskWriteHoldingRegisterRequestParse(io)
+ case error == false && function == 0x16 && response == true:
+ initializer = ModbusPDUMaskWriteHoldingRegisterResponseParse(io)
+ case error == false && function == 0x18 && response == false:
+ initializer = ModbusPDUReadFifoQueueRequestParse(io)
+ case error == false && function == 0x18 && response == true:
+ initializer = ModbusPDUReadFifoQueueResponseParse(io)
+ case error == false && function == 0x14 && response == false:
+ initializer = ModbusPDUReadFileRecordRequestParse(io)
+ case error == false && function == 0x14 && response == true:
+ initializer = ModbusPDUReadFileRecordResponseParse(io)
+ case error == false && function == 0x15 && response == false:
+ initializer = ModbusPDUWriteFileRecordRequestParse(io)
+ case error == false && function == 0x15 && response == true:
+ initializer = ModbusPDUWriteFileRecordResponseParse(io)
+ case error == false && function == 0x07 && response == false:
+ initializer = ModbusPDUReadExceptionStatusRequestParse(io)
+ case error == false && function == 0x07 && response == true:
+ initializer = ModbusPDUReadExceptionStatusResponseParse(io)
+ case error == false && function == 0x08 && response == false:
+ initializer = ModbusPDUDiagnosticRequestParse(io)
+ case error == false && function == 0x0C && response == false:
+ initializer = ModbusPDUGetComEventLogRequestParse(io)
+ case error == false && function == 0x0C && response == true:
+ initializer = ModbusPDUGetComEventLogResponseParse(io)
+ case error == false && function == 0x11 && response == false:
+ initializer = ModbusPDUReportServerIdRequestParse(io)
+ case error == false && function == 0x11 && response == true:
+ initializer = ModbusPDUReportServerIdResponseParse(io)
+ case error == false && function == 0x2B && response == false:
+ initializer = ModbusPDUReadDeviceIdentificationRequestParse(io)
+ case error == false && function == 0x2B && response == true:
+ initializer = ModbusPDUReadDeviceIdentificationResponseParse(io)
+ }
-func (m ModbusPDU) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Create the instance
+ return initializer.initialize()
}
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUDiagnosticRequest.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUDiagnosticRequest.go
index 76a31a5..d76b222 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUDiagnosticRequest.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUDiagnosticRequest.go
@@ -18,7 +18,10 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUDiagnosticRequest struct {
status uint16
@@ -26,6 +29,14 @@ type ModbusPDUDiagnosticRequest struct {
ModbusPDU
}
+func (m ModbusPDUDiagnosticRequest) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUDiagnosticRequest(status uint16, eventCount uint16) ModbusPDUInitializer {
+ return &ModbusPDUDiagnosticRequest{status: status, eventCount: eventCount}
+}
+
func (m ModbusPDUDiagnosticRequest) LengthInBits() uint16 {
var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
@@ -42,10 +53,16 @@ func (m ModbusPDUDiagnosticRequest) LengthInBytes() uint16 {
return m.LengthInBits() / 8
}
-func (m ModbusPDUDiagnosticRequest) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUDiagnosticRequestParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Simple Field (status)
+ var status uint16 = io.ReadUint16(16)
+
+ // Simple Field (eventCount)
+ var eventCount uint16 = io.ReadUint16(16)
-func (m ModbusPDUDiagnosticRequest) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Create the instance
+ return NewModbusPDUDiagnosticRequest(status, eventCount)
}
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUError.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUError.go
index de2e847..24c00a0 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUError.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUError.go
@@ -18,13 +18,24 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUError struct {
exceptionCode uint8
ModbusPDU
}
+func (m ModbusPDUError) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUError(exceptionCode uint8) ModbusPDUInitializer {
+ return &ModbusPDUError{exceptionCode: exceptionCode}
+}
+
func (m ModbusPDUError) LengthInBits() uint16 {
var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
@@ -38,10 +49,13 @@ func (m ModbusPDUError) LengthInBytes() uint16 {
return m.LengthInBits() / 8
}
-func (m ModbusPDUError) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUErrorParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Simple Field (exceptionCode)
+ var exceptionCode uint8 = io.ReadUint8(8)
-func (m ModbusPDUError) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Create the instance
+ return NewModbusPDUError(exceptionCode)
}
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUGetComEventLogRequest.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUGetComEventLogRequest.go
index fec68b7..29c0fff 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUGetComEventLogRequest.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUGetComEventLogRequest.go
@@ -18,12 +18,23 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUGetComEventLogRequest struct {
ModbusPDU
}
+func (m ModbusPDUGetComEventLogRequest) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUGetComEventLogRequest() ModbusPDUInitializer {
+ return &ModbusPDUGetComEventLogRequest{}
+}
+
func (m ModbusPDUGetComEventLogRequest) LengthInBits() uint16 {
var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
@@ -34,10 +45,10 @@ func (m ModbusPDUGetComEventLogRequest) LengthInBytes() uint16 {
return m.LengthInBits() / 8
}
-func (m ModbusPDUGetComEventLogRequest) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUGetComEventLogRequestParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
-func (m ModbusPDUGetComEventLogRequest) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Create the instance
+ return NewModbusPDUGetComEventLogRequest()
}
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUGetComEventLogResponse.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUGetComEventLogResponse.go
index 10e1ea5..a04cc85 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUGetComEventLogResponse.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUGetComEventLogResponse.go
@@ -18,47 +18,86 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUGetComEventLogResponse struct {
- status uint16
- eventCount uint16
- messageCount uint16
- events []int8
- ModbusPDU
+ status uint16
+ eventCount uint16
+ messageCount uint16
+ events []int8
+ ModbusPDU
+}
+
+func (m ModbusPDUGetComEventLogResponse) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUGetComEventLogResponse(status uint16, eventCount uint16, messageCount uint16, events []int8) ModbusPDUInitializer {
+ return &ModbusPDUGetComEventLogResponse{status: status, eventCount: eventCount, messageCount: messageCount, events: events}
}
func (m ModbusPDUGetComEventLogResponse) LengthInBits() uint16 {
- var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
+ var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
- // Implicit Field (byteCount)
- lengthInBits += 8
+ // Implicit Field (byteCount)
+ lengthInBits += 8
- // Simple field (status)
- lengthInBits += 16
+ // Simple field (status)
+ lengthInBits += 16
- // Simple field (eventCount)
- lengthInBits += 16
+ // Simple field (eventCount)
+ lengthInBits += 16
- // Simple field (messageCount)
- lengthInBits += 16
+ // Simple field (messageCount)
+ lengthInBits += 16
- // Array field
- if len(m.events) > 0 {
- lengthInBits += 8 * uint16(len(m.events))
- }
+ // Array field
+ if len(m.events) > 0 {
+ lengthInBits += 8 * uint16(len(m.events))
+ }
- return lengthInBits
+ return lengthInBits
}
func (m ModbusPDUGetComEventLogResponse) LengthInBytes() uint16 {
- return m.LengthInBits() / 8
+ return m.LengthInBits() / 8
}
-func (m ModbusPDUGetComEventLogResponse) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUGetComEventLogResponseParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Implicit Field (byteCount) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ var byteCount uint8 = io.ReadUint8(8)
-func (m ModbusPDUGetComEventLogResponse) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Simple Field (status)
+ var status uint16 = io.ReadUint16(16)
+
+ // Simple Field (eventCount)
+ var eventCount uint16 = io.ReadUint16(16)
+
+ // Simple Field (messageCount)
+ var messageCount uint16 = io.ReadUint16(16)
+
+ // Array field (events)
+ // Count array
+ if (byteCount) - (6) > math.MaxUint8 {
+ throw new ParseException("Array count of " + ((byteCount) - (6)) + " exceeds the maximum allowed count of " + math.MaxUint8);
+ }
+ int8[] events;
+ {
+ var itemCount := (byteCount) - (6)
+ events = new int8[itemCount]
+ for curItem := 0; curItem < itemCount; curItem++ {
+
+ events[curItem] = io.ReadInt8(8)
+ }
+ }
+
+ // Create the instance
+ return NewModbusPDUGetComEventLogResponse(status, eventCount, messageCount, events)
}
+
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterRequest.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterRequest.go
index de1c680..4a8b2e3 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterRequest.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterRequest.go
@@ -18,7 +18,10 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUMaskWriteHoldingRegisterRequest struct {
referenceAddress uint16
@@ -27,6 +30,14 @@ type ModbusPDUMaskWriteHoldingRegisterRequest struct {
ModbusPDU
}
+func (m ModbusPDUMaskWriteHoldingRegisterRequest) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUMaskWriteHoldingRegisterRequest(referenceAddress uint16, andMask uint16, orMask uint16) ModbusPDUInitializer {
+ return &ModbusPDUMaskWriteHoldingRegisterRequest{referenceAddress: referenceAddress, andMask: andMask, orMask: orMask}
+}
+
func (m ModbusPDUMaskWriteHoldingRegisterRequest) LengthInBits() uint16 {
var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
@@ -46,10 +57,19 @@ func (m ModbusPDUMaskWriteHoldingRegisterRequest) LengthInBytes() uint16 {
return m.LengthInBits() / 8
}
-func (m ModbusPDUMaskWriteHoldingRegisterRequest) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUMaskWriteHoldingRegisterRequestParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Simple Field (referenceAddress)
+ var referenceAddress uint16 = io.ReadUint16(16)
+
+ // Simple Field (andMask)
+ var andMask uint16 = io.ReadUint16(16)
+
+ // Simple Field (orMask)
+ var orMask uint16 = io.ReadUint16(16)
-func (m ModbusPDUMaskWriteHoldingRegisterRequest) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Create the instance
+ return NewModbusPDUMaskWriteHoldingRegisterRequest(referenceAddress, andMask, orMask)
}
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterResponse.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterResponse.go
index 00d430a..d8d7932 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterResponse.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterResponse.go
@@ -18,7 +18,10 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUMaskWriteHoldingRegisterResponse struct {
referenceAddress uint16
@@ -27,6 +30,14 @@ type ModbusPDUMaskWriteHoldingRegisterResponse struct {
ModbusPDU
}
+func (m ModbusPDUMaskWriteHoldingRegisterResponse) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUMaskWriteHoldingRegisterResponse(referenceAddress uint16, andMask uint16, orMask uint16) ModbusPDUInitializer {
+ return &ModbusPDUMaskWriteHoldingRegisterResponse{referenceAddress: referenceAddress, andMask: andMask, orMask: orMask}
+}
+
func (m ModbusPDUMaskWriteHoldingRegisterResponse) LengthInBits() uint16 {
var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
@@ -46,10 +57,19 @@ func (m ModbusPDUMaskWriteHoldingRegisterResponse) LengthInBytes() uint16 {
return m.LengthInBits() / 8
}
-func (m ModbusPDUMaskWriteHoldingRegisterResponse) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUMaskWriteHoldingRegisterResponseParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Simple Field (referenceAddress)
+ var referenceAddress uint16 = io.ReadUint16(16)
+
+ // Simple Field (andMask)
+ var andMask uint16 = io.ReadUint16(16)
+
+ // Simple Field (orMask)
+ var orMask uint16 = io.ReadUint16(16)
-func (m ModbusPDUMaskWriteHoldingRegisterResponse) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Create the instance
+ return NewModbusPDUMaskWriteHoldingRegisterResponse(referenceAddress, andMask, orMask)
}
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadCoilsRequest.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadCoilsRequest.go
index 2e8774f..eb6ddff 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadCoilsRequest.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadCoilsRequest.go
@@ -18,7 +18,10 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUReadCoilsRequest struct {
startingAddress uint16
@@ -26,6 +29,14 @@ type ModbusPDUReadCoilsRequest struct {
ModbusPDU
}
+func (m ModbusPDUReadCoilsRequest) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUReadCoilsRequest(startingAddress uint16, quantity uint16) ModbusPDUInitializer {
+ return &ModbusPDUReadCoilsRequest{startingAddress: startingAddress, quantity: quantity}
+}
+
func (m ModbusPDUReadCoilsRequest) LengthInBits() uint16 {
var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
@@ -42,10 +53,16 @@ func (m ModbusPDUReadCoilsRequest) LengthInBytes() uint16 {
return m.LengthInBits() / 8
}
-func (m ModbusPDUReadCoilsRequest) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUReadCoilsRequestParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Simple Field (startingAddress)
+ var startingAddress uint16 = io.ReadUint16(16)
+
+ // Simple Field (quantity)
+ var quantity uint16 = io.ReadUint16(16)
-func (m ModbusPDUReadCoilsRequest) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Create the instance
+ return NewModbusPDUReadCoilsRequest(startingAddress, quantity)
}
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadCoilsResponse.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadCoilsResponse.go
index b64e022..a6ac41e 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadCoilsResponse.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadCoilsResponse.go
@@ -18,35 +18,65 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUReadCoilsResponse struct {
- value []int8
- ModbusPDU
+ value []int8
+ ModbusPDU
+}
+
+func (m ModbusPDUReadCoilsResponse) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUReadCoilsResponse(value []int8) ModbusPDUInitializer {
+ return &ModbusPDUReadCoilsResponse{value: value}
}
func (m ModbusPDUReadCoilsResponse) LengthInBits() uint16 {
- var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
+ var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
- // Implicit Field (byteCount)
- lengthInBits += 8
+ // Implicit Field (byteCount)
+ lengthInBits += 8
- // Array field
- if len(m.value) > 0 {
- lengthInBits += 8 * uint16(len(m.value))
- }
+ // Array field
+ if len(m.value) > 0 {
+ lengthInBits += 8 * uint16(len(m.value))
+ }
- return lengthInBits
+ return lengthInBits
}
func (m ModbusPDUReadCoilsResponse) LengthInBytes() uint16 {
- return m.LengthInBits() / 8
+ return m.LengthInBits() / 8
}
-func (m ModbusPDUReadCoilsResponse) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUReadCoilsResponseParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Implicit Field (byteCount) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ var byteCount uint8 = io.ReadUint8(8)
-func (m ModbusPDUReadCoilsResponse) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Array field (value)
+ // Count array
+ if byteCount > math.MaxUint8 {
+ throw new ParseException("Array count of " + (byteCount) + " exceeds the maximum allowed count of " + math.MaxUint8);
+ }
+ int8[] value;
+ {
+ var itemCount := byteCount
+ value = new int8[itemCount]
+ for curItem := 0; curItem < itemCount; curItem++ {
+
+ value[curItem] = io.ReadInt8(8)
+ }
+ }
+
+ // Create the instance
+ return NewModbusPDUReadCoilsResponse(value)
}
+
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadDeviceIdentificationRequest.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadDeviceIdentificationRequest.go
index 29d6688..9ea38e2 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadDeviceIdentificationRequest.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadDeviceIdentificationRequest.go
@@ -18,12 +18,23 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUReadDeviceIdentificationRequest struct {
ModbusPDU
}
+func (m ModbusPDUReadDeviceIdentificationRequest) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUReadDeviceIdentificationRequest() ModbusPDUInitializer {
+ return &ModbusPDUReadDeviceIdentificationRequest{}
+}
+
func (m ModbusPDUReadDeviceIdentificationRequest) LengthInBits() uint16 {
var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
@@ -34,10 +45,10 @@ func (m ModbusPDUReadDeviceIdentificationRequest) LengthInBytes() uint16 {
return m.LengthInBits() / 8
}
-func (m ModbusPDUReadDeviceIdentificationRequest) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUReadDeviceIdentificationRequestParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
-func (m ModbusPDUReadDeviceIdentificationRequest) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Create the instance
+ return NewModbusPDUReadDeviceIdentificationRequest()
}
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadDeviceIdentificationResponse.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadDeviceIdentificationResponse.go
index 9ca0873..4b3b7be 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadDeviceIdentificationResponse.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadDeviceIdentificationResponse.go
@@ -18,12 +18,23 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUReadDeviceIdentificationResponse struct {
ModbusPDU
}
+func (m ModbusPDUReadDeviceIdentificationResponse) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUReadDeviceIdentificationResponse() ModbusPDUInitializer {
+ return &ModbusPDUReadDeviceIdentificationResponse{}
+}
+
func (m ModbusPDUReadDeviceIdentificationResponse) LengthInBits() uint16 {
var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
@@ -34,10 +45,10 @@ func (m ModbusPDUReadDeviceIdentificationResponse) LengthInBytes() uint16 {
return m.LengthInBits() / 8
}
-func (m ModbusPDUReadDeviceIdentificationResponse) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUReadDeviceIdentificationResponseParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
-func (m ModbusPDUReadDeviceIdentificationResponse) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Create the instance
+ return NewModbusPDUReadDeviceIdentificationResponse()
}
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadDiscreteInputsRequest.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadDiscreteInputsRequest.go
index 20f0bd1..5755d2a 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadDiscreteInputsRequest.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadDiscreteInputsRequest.go
@@ -18,7 +18,10 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUReadDiscreteInputsRequest struct {
startingAddress uint16
@@ -26,6 +29,14 @@ type ModbusPDUReadDiscreteInputsRequest struct {
ModbusPDU
}
+func (m ModbusPDUReadDiscreteInputsRequest) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUReadDiscreteInputsRequest(startingAddress uint16, quantity uint16) ModbusPDUInitializer {
+ return &ModbusPDUReadDiscreteInputsRequest{startingAddress: startingAddress, quantity: quantity}
+}
+
func (m ModbusPDUReadDiscreteInputsRequest) LengthInBits() uint16 {
var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
@@ -42,10 +53,16 @@ func (m ModbusPDUReadDiscreteInputsRequest) LengthInBytes() uint16 {
return m.LengthInBits() / 8
}
-func (m ModbusPDUReadDiscreteInputsRequest) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUReadDiscreteInputsRequestParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Simple Field (startingAddress)
+ var startingAddress uint16 = io.ReadUint16(16)
+
+ // Simple Field (quantity)
+ var quantity uint16 = io.ReadUint16(16)
-func (m ModbusPDUReadDiscreteInputsRequest) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Create the instance
+ return NewModbusPDUReadDiscreteInputsRequest(startingAddress, quantity)
}
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadDiscreteInputsResponse.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadDiscreteInputsResponse.go
index 7714ea4..8b3eb97 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadDiscreteInputsResponse.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadDiscreteInputsResponse.go
@@ -18,35 +18,65 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUReadDiscreteInputsResponse struct {
- value []int8
- ModbusPDU
+ value []int8
+ ModbusPDU
+}
+
+func (m ModbusPDUReadDiscreteInputsResponse) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUReadDiscreteInputsResponse(value []int8) ModbusPDUInitializer {
+ return &ModbusPDUReadDiscreteInputsResponse{value: value}
}
func (m ModbusPDUReadDiscreteInputsResponse) LengthInBits() uint16 {
- var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
+ var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
- // Implicit Field (byteCount)
- lengthInBits += 8
+ // Implicit Field (byteCount)
+ lengthInBits += 8
- // Array field
- if len(m.value) > 0 {
- lengthInBits += 8 * uint16(len(m.value))
- }
+ // Array field
+ if len(m.value) > 0 {
+ lengthInBits += 8 * uint16(len(m.value))
+ }
- return lengthInBits
+ return lengthInBits
}
func (m ModbusPDUReadDiscreteInputsResponse) LengthInBytes() uint16 {
- return m.LengthInBits() / 8
+ return m.LengthInBits() / 8
}
-func (m ModbusPDUReadDiscreteInputsResponse) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUReadDiscreteInputsResponseParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Implicit Field (byteCount) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ var byteCount uint8 = io.ReadUint8(8)
-func (m ModbusPDUReadDiscreteInputsResponse) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Array field (value)
+ // Count array
+ if byteCount > math.MaxUint8 {
+ throw new ParseException("Array count of " + (byteCount) + " exceeds the maximum allowed count of " + math.MaxUint8);
+ }
+ int8[] value;
+ {
+ var itemCount := byteCount
+ value = new int8[itemCount]
+ for curItem := 0; curItem < itemCount; curItem++ {
+
+ value[curItem] = io.ReadInt8(8)
+ }
+ }
+
+ // Create the instance
+ return NewModbusPDUReadDiscreteInputsResponse(value)
}
+
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadExceptionStatusRequest.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadExceptionStatusRequest.go
index fd61079..6533e2f 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadExceptionStatusRequest.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadExceptionStatusRequest.go
@@ -18,12 +18,23 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUReadExceptionStatusRequest struct {
ModbusPDU
}
+func (m ModbusPDUReadExceptionStatusRequest) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUReadExceptionStatusRequest() ModbusPDUInitializer {
+ return &ModbusPDUReadExceptionStatusRequest{}
+}
+
func (m ModbusPDUReadExceptionStatusRequest) LengthInBits() uint16 {
var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
@@ -34,10 +45,10 @@ func (m ModbusPDUReadExceptionStatusRequest) LengthInBytes() uint16 {
return m.LengthInBits() / 8
}
-func (m ModbusPDUReadExceptionStatusRequest) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUReadExceptionStatusRequestParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
-func (m ModbusPDUReadExceptionStatusRequest) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Create the instance
+ return NewModbusPDUReadExceptionStatusRequest()
}
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadExceptionStatusResponse.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadExceptionStatusResponse.go
index 02f3c91..4bebf92 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadExceptionStatusResponse.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadExceptionStatusResponse.go
@@ -18,13 +18,24 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUReadExceptionStatusResponse struct {
value uint8
ModbusPDU
}
+func (m ModbusPDUReadExceptionStatusResponse) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUReadExceptionStatusResponse(value uint8) ModbusPDUInitializer {
+ return &ModbusPDUReadExceptionStatusResponse{value: value}
+}
+
func (m ModbusPDUReadExceptionStatusResponse) LengthInBits() uint16 {
var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
@@ -38,10 +49,13 @@ func (m ModbusPDUReadExceptionStatusResponse) LengthInBytes() uint16 {
return m.LengthInBits() / 8
}
-func (m ModbusPDUReadExceptionStatusResponse) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUReadExceptionStatusResponseParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Simple Field (value)
+ var value uint8 = io.ReadUint8(8)
-func (m ModbusPDUReadExceptionStatusResponse) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Create the instance
+ return NewModbusPDUReadExceptionStatusResponse(value)
}
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadFifoQueueRequest.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadFifoQueueRequest.go
index becbb77..7c42a40 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadFifoQueueRequest.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadFifoQueueRequest.go
@@ -18,13 +18,24 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUReadFifoQueueRequest struct {
fifoPointerAddress uint16
ModbusPDU
}
+func (m ModbusPDUReadFifoQueueRequest) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUReadFifoQueueRequest(fifoPointerAddress uint16) ModbusPDUInitializer {
+ return &ModbusPDUReadFifoQueueRequest{fifoPointerAddress: fifoPointerAddress}
+}
+
func (m ModbusPDUReadFifoQueueRequest) LengthInBits() uint16 {
var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
@@ -38,10 +49,13 @@ func (m ModbusPDUReadFifoQueueRequest) LengthInBytes() uint16 {
return m.LengthInBits() / 8
}
-func (m ModbusPDUReadFifoQueueRequest) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUReadFifoQueueRequestParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Simple Field (fifoPointerAddress)
+ var fifoPointerAddress uint16 = io.ReadUint16(16)
-func (m ModbusPDUReadFifoQueueRequest) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Create the instance
+ return NewModbusPDUReadFifoQueueRequest(fifoPointerAddress)
}
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadFifoQueueResponse.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadFifoQueueResponse.go
index cc593a1..5906ffe 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadFifoQueueResponse.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadFifoQueueResponse.go
@@ -18,38 +18,71 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUReadFifoQueueResponse struct {
- fifoValue []uint16
- ModbusPDU
+ fifoValue []uint16
+ ModbusPDU
+}
+
+func (m ModbusPDUReadFifoQueueResponse) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUReadFifoQueueResponse(fifoValue []uint16) ModbusPDUInitializer {
+ return &ModbusPDUReadFifoQueueResponse{fifoValue: fifoValue}
}
func (m ModbusPDUReadFifoQueueResponse) LengthInBits() uint16 {
- var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
+ var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
- // Implicit Field (byteCount)
- lengthInBits += 16
+ // Implicit Field (byteCount)
+ lengthInBits += 16
- // Implicit Field (fifoCount)
- lengthInBits += 16
+ // Implicit Field (fifoCount)
+ lengthInBits += 16
- // Array field
- if len(m.fifoValue) > 0 {
- lengthInBits += 16 * uint16(len(m.fifoValue))
- }
+ // Array field
+ if len(m.fifoValue) > 0 {
+ lengthInBits += 16 * uint16(len(m.fifoValue))
+ }
- return lengthInBits
+ return lengthInBits
}
func (m ModbusPDUReadFifoQueueResponse) LengthInBytes() uint16 {
- return m.LengthInBits() / 8
+ return m.LengthInBits() / 8
}
-func (m ModbusPDUReadFifoQueueResponse) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUReadFifoQueueResponseParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
-func (m ModbusPDUReadFifoQueueResponse) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Implicit Field (byteCount) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ var byteCount uint16 = io.ReadUint16(16)
+
+ // Implicit Field (fifoCount) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ var fifoCount uint16 = io.ReadUint16(16)
+
+ // Array field (fifoValue)
+ // Count array
+ if fifoCount > math.MaxUint8 {
+ throw new ParseException("Array count of " + (fifoCount) + " exceeds the maximum allowed count of " + math.MaxUint8);
+ }
+ uint16[] fifoValue;
+ {
+ var itemCount := fifoCount
+ fifoValue = new uint16[itemCount]
+ for curItem := 0; curItem < itemCount; curItem++ {
+
+ fifoValue[curItem] = io.ReadUint16(16)
+ }
+ }
+
+ // Create the instance
+ return NewModbusPDUReadFifoQueueResponse(fifoValue)
}
+
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadFileRecordRequest.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadFileRecordRequest.go
index a0b58e1..439758d 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadFileRecordRequest.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadFileRecordRequest.go
@@ -18,37 +18,62 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUReadFileRecordRequest struct {
- items []ModbusPDUReadFileRecordRequestItem
- ModbusPDU
+ items []ModbusPDUReadFileRecordRequestItem
+ ModbusPDU
+}
+
+func (m ModbusPDUReadFileRecordRequest) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUReadFileRecordRequest(items []ModbusPDUReadFileRecordRequestItem) ModbusPDUInitializer {
+ return &ModbusPDUReadFileRecordRequest{items: items}
}
func (m ModbusPDUReadFileRecordRequest) LengthInBits() uint16 {
- var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
+ var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
- // Implicit Field (byteCount)
- lengthInBits += 8
+ // Implicit Field (byteCount)
+ lengthInBits += 8
- // Array field
- if len(m.items) > 0 {
- for _, element := range m.items {
- lengthInBits += element.LengthInBits()
- }
- }
+ // Array field
+ if len(m.items) > 0 {
+ for _, element := range m.items {
+ lengthInBits += element.LengthInBits()
+ }
+ }
- return lengthInBits
+ return lengthInBits
}
func (m ModbusPDUReadFileRecordRequest) LengthInBytes() uint16 {
- return m.LengthInBits() / 8
+ return m.LengthInBits() / 8
}
-func (m ModbusPDUReadFileRecordRequest) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUReadFileRecordRequestParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Implicit Field (byteCount) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ var byteCount uint8 = io.ReadUint8(8)
-func (m ModbusPDUReadFileRecordRequest) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Array field (items)
+ // Length array
+ var _itemsLength := byteCount
+ List<ModbusPDUReadFileRecordRequestItem> _itemsList = new LinkedList<>();
+ itemsEndPos := io.GetPos() + _itemsLength;
+ for ;io.getPos() < itemsEndPos; {
+ _itemsList.add(ModbusPDUReadFileRecordRequestItemIO.staticParse(io));
+ }
+ ModbusPDUReadFileRecordRequestItem[] items = _itemsList.toArray(new ModbusPDUReadFileRecordRequestItem[0])
+
+ // Create the instance
+ return NewModbusPDUReadFileRecordRequest(items)
}
+
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadFileRecordRequestItem.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadFileRecordRequestItem.go
index 1b7548b..5765574 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadFileRecordRequestItem.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadFileRecordRequestItem.go
@@ -18,7 +18,10 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUReadFileRecordRequestItem struct {
referenceType uint8
@@ -27,6 +30,10 @@ type ModbusPDUReadFileRecordRequestItem struct {
recordLength uint16
}
+func NewModbusPDUReadFileRecordRequestItem(referenceType uint8, fileNumber uint16, recordNumber uint16, recordLength uint16) ModbusPDUReadFileRecordRequestItem {
+ return &ModbusPDUReadFileRecordRequestItem{referenceType: referenceType, fileNumber: fileNumber, recordNumber: recordNumber, recordLength: recordLength}
+}
+
func (m ModbusPDUReadFileRecordRequestItem) LengthInBits() uint16 {
var lengthInBits uint16 = 0
@@ -49,10 +56,22 @@ func (m ModbusPDUReadFileRecordRequestItem) LengthInBytes() uint16 {
return m.LengthInBits() / 8
}
-func (m ModbusPDUReadFileRecordRequestItem) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUReadFileRecordRequestItemParse(io spi.ReadBuffer) ModbusPDUReadFileRecordRequestItem {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Simple Field (referenceType)
+ var referenceType uint8 = io.ReadUint8(8)
+
+ // Simple Field (fileNumber)
+ var fileNumber uint16 = io.ReadUint16(16)
+
+ // Simple Field (recordNumber)
+ var recordNumber uint16 = io.ReadUint16(16)
+
+ // Simple Field (recordLength)
+ var recordLength uint16 = io.ReadUint16(16)
-func (m ModbusPDUReadFileRecordRequestItem) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Create the instance
+ return NewModbusPDUReadFileRecordRequestItem(referenceType, fileNumber, recordNumber, recordLength)
}
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadFileRecordResponse.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadFileRecordResponse.go
index 0064a2a..3c69968 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadFileRecordResponse.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadFileRecordResponse.go
@@ -18,37 +18,62 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUReadFileRecordResponse struct {
- items []ModbusPDUReadFileRecordResponseItem
- ModbusPDU
+ items []ModbusPDUReadFileRecordResponseItem
+ ModbusPDU
+}
+
+func (m ModbusPDUReadFileRecordResponse) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUReadFileRecordResponse(items []ModbusPDUReadFileRecordResponseItem) ModbusPDUInitializer {
+ return &ModbusPDUReadFileRecordResponse{items: items}
}
func (m ModbusPDUReadFileRecordResponse) LengthInBits() uint16 {
- var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
+ var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
- // Implicit Field (byteCount)
- lengthInBits += 8
+ // Implicit Field (byteCount)
+ lengthInBits += 8
- // Array field
- if len(m.items) > 0 {
- for _, element := range m.items {
- lengthInBits += element.LengthInBits()
- }
- }
+ // Array field
+ if len(m.items) > 0 {
+ for _, element := range m.items {
+ lengthInBits += element.LengthInBits()
+ }
+ }
- return lengthInBits
+ return lengthInBits
}
func (m ModbusPDUReadFileRecordResponse) LengthInBytes() uint16 {
- return m.LengthInBits() / 8
+ return m.LengthInBits() / 8
}
-func (m ModbusPDUReadFileRecordResponse) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUReadFileRecordResponseParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Implicit Field (byteCount) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ var byteCount uint8 = io.ReadUint8(8)
-func (m ModbusPDUReadFileRecordResponse) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Array field (items)
+ // Length array
+ var _itemsLength := byteCount
+ List<ModbusPDUReadFileRecordResponseItem> _itemsList = new LinkedList<>();
+ itemsEndPos := io.GetPos() + _itemsLength;
+ for ;io.getPos() < itemsEndPos; {
+ _itemsList.add(ModbusPDUReadFileRecordResponseItemIO.staticParse(io));
+ }
+ ModbusPDUReadFileRecordResponseItem[] items = _itemsList.toArray(new ModbusPDUReadFileRecordResponseItem[0])
+
+ // Create the instance
+ return NewModbusPDUReadFileRecordResponse(items)
}
+
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadFileRecordResponseItem.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadFileRecordResponseItem.go
index babebec..2b571a9 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadFileRecordResponseItem.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadFileRecordResponseItem.go
@@ -18,38 +18,67 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUReadFileRecordResponseItem struct {
- referenceType uint8
- data []int8
+ referenceType uint8
+ data []int8
+
+}
+
+
+func NewModbusPDUReadFileRecordResponseItem(referenceType uint8, data []int8) ModbusPDUReadFileRecordResponseItem {
+ return &ModbusPDUReadFileRecordResponseItem{referenceType: referenceType, data: data}
}
func (m ModbusPDUReadFileRecordResponseItem) LengthInBits() uint16 {
- var lengthInBits uint16 = 0
+ var lengthInBits uint16 = 0
- // Implicit Field (dataLength)
- lengthInBits += 8
+ // Implicit Field (dataLength)
+ lengthInBits += 8
- // Simple field (referenceType)
- lengthInBits += 8
+ // Simple field (referenceType)
+ lengthInBits += 8
- // Array field
- if len(m.data) > 0 {
- lengthInBits += 8 * uint16(len(m.data))
- }
+ // Array field
+ if len(m.data) > 0 {
+ lengthInBits += 8 * uint16(len(m.data))
+ }
- return lengthInBits
+ return lengthInBits
}
func (m ModbusPDUReadFileRecordResponseItem) LengthInBytes() uint16 {
- return m.LengthInBits() / 8
+ return m.LengthInBits() / 8
}
-func (m ModbusPDUReadFileRecordResponseItem) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUReadFileRecordResponseItemParse(io spi.ReadBuffer) ModbusPDUReadFileRecordResponseItem {
+ var startPos = io.GetPos()
+ var curPos uint16
-func (m ModbusPDUReadFileRecordResponseItem) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Implicit Field (dataLength) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ var dataLength uint8 = io.ReadUint8(8)
+
+ // Simple Field (referenceType)
+ var referenceType uint8 = io.ReadUint8(8)
+
+ // Array field (data)
+ // Length array
+ var _dataLength := (dataLength) - (1)
+ List<int8> _dataList = new LinkedList<>();
+ dataEndPos := io.GetPos() + _dataLength;
+ for ;io.getPos() < dataEndPos; {
+ _dataList.add(io.ReadInt8(8));
+ }
+ int8[] data = new int8[_dataList.size()]
+ for i := 0; i < _dataList.size(); i++ {
+ data[i] = (int8) _dataList.get(i)
+ }
+
+ // Create the instance
+ return NewModbusPDUReadFileRecordResponseItem(referenceType, data)
}
+
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadHoldingRegistersRequest.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadHoldingRegistersRequest.go
index 8151a7d..88ab0b5 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadHoldingRegistersRequest.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadHoldingRegistersRequest.go
@@ -18,7 +18,10 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUReadHoldingRegistersRequest struct {
startingAddress uint16
@@ -26,6 +29,14 @@ type ModbusPDUReadHoldingRegistersRequest struct {
ModbusPDU
}
+func (m ModbusPDUReadHoldingRegistersRequest) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUReadHoldingRegistersRequest(startingAddress uint16, quantity uint16) ModbusPDUInitializer {
+ return &ModbusPDUReadHoldingRegistersRequest{startingAddress: startingAddress, quantity: quantity}
+}
+
func (m ModbusPDUReadHoldingRegistersRequest) LengthInBits() uint16 {
var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
@@ -42,10 +53,16 @@ func (m ModbusPDUReadHoldingRegistersRequest) LengthInBytes() uint16 {
return m.LengthInBits() / 8
}
-func (m ModbusPDUReadHoldingRegistersRequest) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUReadHoldingRegistersRequestParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Simple Field (startingAddress)
+ var startingAddress uint16 = io.ReadUint16(16)
+
+ // Simple Field (quantity)
+ var quantity uint16 = io.ReadUint16(16)
-func (m ModbusPDUReadHoldingRegistersRequest) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Create the instance
+ return NewModbusPDUReadHoldingRegistersRequest(startingAddress, quantity)
}
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadHoldingRegistersResponse.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadHoldingRegistersResponse.go
index 156b681..f5702b4 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadHoldingRegistersResponse.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadHoldingRegistersResponse.go
@@ -18,35 +18,65 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUReadHoldingRegistersResponse struct {
- value []int8
- ModbusPDU
+ value []int8
+ ModbusPDU
+}
+
+func (m ModbusPDUReadHoldingRegistersResponse) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUReadHoldingRegistersResponse(value []int8) ModbusPDUInitializer {
+ return &ModbusPDUReadHoldingRegistersResponse{value: value}
}
func (m ModbusPDUReadHoldingRegistersResponse) LengthInBits() uint16 {
- var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
+ var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
- // Implicit Field (byteCount)
- lengthInBits += 8
+ // Implicit Field (byteCount)
+ lengthInBits += 8
- // Array field
- if len(m.value) > 0 {
- lengthInBits += 8 * uint16(len(m.value))
- }
+ // Array field
+ if len(m.value) > 0 {
+ lengthInBits += 8 * uint16(len(m.value))
+ }
- return lengthInBits
+ return lengthInBits
}
func (m ModbusPDUReadHoldingRegistersResponse) LengthInBytes() uint16 {
- return m.LengthInBits() / 8
+ return m.LengthInBits() / 8
}
-func (m ModbusPDUReadHoldingRegistersResponse) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUReadHoldingRegistersResponseParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Implicit Field (byteCount) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ var byteCount uint8 = io.ReadUint8(8)
-func (m ModbusPDUReadHoldingRegistersResponse) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Array field (value)
+ // Count array
+ if byteCount > math.MaxUint8 {
+ throw new ParseException("Array count of " + (byteCount) + " exceeds the maximum allowed count of " + math.MaxUint8);
+ }
+ int8[] value;
+ {
+ var itemCount := byteCount
+ value = new int8[itemCount]
+ for curItem := 0; curItem < itemCount; curItem++ {
+
+ value[curItem] = io.ReadInt8(8)
+ }
+ }
+
+ // Create the instance
+ return NewModbusPDUReadHoldingRegistersResponse(value)
}
+
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadInputRegistersRequest.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadInputRegistersRequest.go
index fcdb439..15d271b 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadInputRegistersRequest.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadInputRegistersRequest.go
@@ -18,7 +18,10 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUReadInputRegistersRequest struct {
startingAddress uint16
@@ -26,6 +29,14 @@ type ModbusPDUReadInputRegistersRequest struct {
ModbusPDU
}
+func (m ModbusPDUReadInputRegistersRequest) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUReadInputRegistersRequest(startingAddress uint16, quantity uint16) ModbusPDUInitializer {
+ return &ModbusPDUReadInputRegistersRequest{startingAddress: startingAddress, quantity: quantity}
+}
+
func (m ModbusPDUReadInputRegistersRequest) LengthInBits() uint16 {
var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
@@ -42,10 +53,16 @@ func (m ModbusPDUReadInputRegistersRequest) LengthInBytes() uint16 {
return m.LengthInBits() / 8
}
-func (m ModbusPDUReadInputRegistersRequest) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUReadInputRegistersRequestParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Simple Field (startingAddress)
+ var startingAddress uint16 = io.ReadUint16(16)
+
+ // Simple Field (quantity)
+ var quantity uint16 = io.ReadUint16(16)
-func (m ModbusPDUReadInputRegistersRequest) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Create the instance
+ return NewModbusPDUReadInputRegistersRequest(startingAddress, quantity)
}
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadInputRegistersResponse.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadInputRegistersResponse.go
index 06163fa..7d5d418 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadInputRegistersResponse.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadInputRegistersResponse.go
@@ -18,35 +18,65 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUReadInputRegistersResponse struct {
- value []int8
- ModbusPDU
+ value []int8
+ ModbusPDU
+}
+
+func (m ModbusPDUReadInputRegistersResponse) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUReadInputRegistersResponse(value []int8) ModbusPDUInitializer {
+ return &ModbusPDUReadInputRegistersResponse{value: value}
}
func (m ModbusPDUReadInputRegistersResponse) LengthInBits() uint16 {
- var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
+ var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
- // Implicit Field (byteCount)
- lengthInBits += 8
+ // Implicit Field (byteCount)
+ lengthInBits += 8
- // Array field
- if len(m.value) > 0 {
- lengthInBits += 8 * uint16(len(m.value))
- }
+ // Array field
+ if len(m.value) > 0 {
+ lengthInBits += 8 * uint16(len(m.value))
+ }
- return lengthInBits
+ return lengthInBits
}
func (m ModbusPDUReadInputRegistersResponse) LengthInBytes() uint16 {
- return m.LengthInBits() / 8
+ return m.LengthInBits() / 8
}
-func (m ModbusPDUReadInputRegistersResponse) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUReadInputRegistersResponseParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Implicit Field (byteCount) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ var byteCount uint8 = io.ReadUint8(8)
-func (m ModbusPDUReadInputRegistersResponse) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Array field (value)
+ // Count array
+ if byteCount > math.MaxUint8 {
+ throw new ParseException("Array count of " + (byteCount) + " exceeds the maximum allowed count of " + math.MaxUint8);
+ }
+ int8[] value;
+ {
+ var itemCount := byteCount
+ value = new int8[itemCount]
+ for curItem := 0; curItem < itemCount; curItem++ {
+
+ value[curItem] = io.ReadInt8(8)
+ }
+ }
+
+ // Create the instance
+ return NewModbusPDUReadInputRegistersResponse(value)
}
+
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersRequest.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersRequest.go
index 2ba3302..0dff68b 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersRequest.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersRequest.go
@@ -18,51 +18,93 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUReadWriteMultipleHoldingRegistersRequest struct {
- readStartingAddress uint16
- readQuantity uint16
- writeStartingAddress uint16
- writeQuantity uint16
- value []int8
- ModbusPDU
+ readStartingAddress uint16
+ readQuantity uint16
+ writeStartingAddress uint16
+ writeQuantity uint16
+ value []int8
+ ModbusPDU
+}
+
+func (m ModbusPDUReadWriteMultipleHoldingRegistersRequest) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUReadWriteMultipleHoldingRegistersRequest(readStartingAddress uint16, readQuantity uint16, writeStartingAddress uint16, writeQuantity uint16, value []int8) ModbusPDUInitializer {
+ return &ModbusPDUReadWriteMultipleHoldingRegistersRequest{readStartingAddress: readStartingAddress, readQuantity: readQuantity, writeStartingAddress: writeStartingAddress, writeQuantity: writeQuantity, value: value}
}
func (m ModbusPDUReadWriteMultipleHoldingRegistersRequest) LengthInBits() uint16 {
- var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
+ var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
- // Simple field (readStartingAddress)
- lengthInBits += 16
+ // Simple field (readStartingAddress)
+ lengthInBits += 16
- // Simple field (readQuantity)
- lengthInBits += 16
+ // Simple field (readQuantity)
+ lengthInBits += 16
- // Simple field (writeStartingAddress)
- lengthInBits += 16
+ // Simple field (writeStartingAddress)
+ lengthInBits += 16
- // Simple field (writeQuantity)
- lengthInBits += 16
+ // Simple field (writeQuantity)
+ lengthInBits += 16
- // Implicit Field (byteCount)
- lengthInBits += 8
+ // Implicit Field (byteCount)
+ lengthInBits += 8
- // Array field
- if len(m.value) > 0 {
- lengthInBits += 8 * uint16(len(m.value))
- }
+ // Array field
+ if len(m.value) > 0 {
+ lengthInBits += 8 * uint16(len(m.value))
+ }
- return lengthInBits
+ return lengthInBits
}
func (m ModbusPDUReadWriteMultipleHoldingRegistersRequest) LengthInBytes() uint16 {
- return m.LengthInBits() / 8
+ return m.LengthInBits() / 8
}
-func (m ModbusPDUReadWriteMultipleHoldingRegistersRequest) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUReadWriteMultipleHoldingRegistersRequestParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Simple Field (readStartingAddress)
+ var readStartingAddress uint16 = io.ReadUint16(16)
-func (m ModbusPDUReadWriteMultipleHoldingRegistersRequest) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Simple Field (readQuantity)
+ var readQuantity uint16 = io.ReadUint16(16)
+
+ // Simple Field (writeStartingAddress)
+ var writeStartingAddress uint16 = io.ReadUint16(16)
+
+ // Simple Field (writeQuantity)
+ var writeQuantity uint16 = io.ReadUint16(16)
+
+ // Implicit Field (byteCount) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ var byteCount uint8 = io.ReadUint8(8)
+
+ // Array field (value)
+ // Count array
+ if byteCount > math.MaxUint8 {
+ throw new ParseException("Array count of " + (byteCount) + " exceeds the maximum allowed count of " + math.MaxUint8);
+ }
+ int8[] value;
+ {
+ var itemCount := byteCount
+ value = new int8[itemCount]
+ for curItem := 0; curItem < itemCount; curItem++ {
+
+ value[curItem] = io.ReadInt8(8)
+ }
+ }
+
+ // Create the instance
+ return NewModbusPDUReadWriteMultipleHoldingRegistersRequest(readStartingAddress, readQuantity, writeStartingAddress, writeQuantity, value)
}
+
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersResponse.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersResponse.go
index 92106cb..4280e09 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersResponse.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersResponse.go
@@ -18,35 +18,65 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUReadWriteMultipleHoldingRegistersResponse struct {
- value []int8
- ModbusPDU
+ value []int8
+ ModbusPDU
+}
+
+func (m ModbusPDUReadWriteMultipleHoldingRegistersResponse) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUReadWriteMultipleHoldingRegistersResponse(value []int8) ModbusPDUInitializer {
+ return &ModbusPDUReadWriteMultipleHoldingRegistersResponse{value: value}
}
func (m ModbusPDUReadWriteMultipleHoldingRegistersResponse) LengthInBits() uint16 {
- var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
+ var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
- // Implicit Field (byteCount)
- lengthInBits += 8
+ // Implicit Field (byteCount)
+ lengthInBits += 8
- // Array field
- if len(m.value) > 0 {
- lengthInBits += 8 * uint16(len(m.value))
- }
+ // Array field
+ if len(m.value) > 0 {
+ lengthInBits += 8 * uint16(len(m.value))
+ }
- return lengthInBits
+ return lengthInBits
}
func (m ModbusPDUReadWriteMultipleHoldingRegistersResponse) LengthInBytes() uint16 {
- return m.LengthInBits() / 8
+ return m.LengthInBits() / 8
}
-func (m ModbusPDUReadWriteMultipleHoldingRegistersResponse) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUReadWriteMultipleHoldingRegistersResponseParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Implicit Field (byteCount) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ var byteCount uint8 = io.ReadUint8(8)
-func (m ModbusPDUReadWriteMultipleHoldingRegistersResponse) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Array field (value)
+ // Count array
+ if byteCount > math.MaxUint8 {
+ throw new ParseException("Array count of " + (byteCount) + " exceeds the maximum allowed count of " + math.MaxUint8);
+ }
+ int8[] value;
+ {
+ var itemCount := byteCount
+ value = new int8[itemCount]
+ for curItem := 0; curItem < itemCount; curItem++ {
+
+ value[curItem] = io.ReadInt8(8)
+ }
+ }
+
+ // Create the instance
+ return NewModbusPDUReadWriteMultipleHoldingRegistersResponse(value)
}
+
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReportServerIdRequest.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReportServerIdRequest.go
index 2f08fef..60b0687 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReportServerIdRequest.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReportServerIdRequest.go
@@ -18,12 +18,23 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUReportServerIdRequest struct {
ModbusPDU
}
+func (m ModbusPDUReportServerIdRequest) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUReportServerIdRequest() ModbusPDUInitializer {
+ return &ModbusPDUReportServerIdRequest{}
+}
+
func (m ModbusPDUReportServerIdRequest) LengthInBits() uint16 {
var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
@@ -34,10 +45,10 @@ func (m ModbusPDUReportServerIdRequest) LengthInBytes() uint16 {
return m.LengthInBits() / 8
}
-func (m ModbusPDUReportServerIdRequest) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUReportServerIdRequestParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
-func (m ModbusPDUReportServerIdRequest) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Create the instance
+ return NewModbusPDUReportServerIdRequest()
}
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReportServerIdResponse.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReportServerIdResponse.go
index 1b30682..a4525da 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReportServerIdResponse.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUReportServerIdResponse.go
@@ -18,35 +18,65 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUReportServerIdResponse struct {
- value []int8
- ModbusPDU
+ value []int8
+ ModbusPDU
+}
+
+func (m ModbusPDUReportServerIdResponse) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUReportServerIdResponse(value []int8) ModbusPDUInitializer {
+ return &ModbusPDUReportServerIdResponse{value: value}
}
func (m ModbusPDUReportServerIdResponse) LengthInBits() uint16 {
- var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
+ var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
- // Implicit Field (byteCount)
- lengthInBits += 8
+ // Implicit Field (byteCount)
+ lengthInBits += 8
- // Array field
- if len(m.value) > 0 {
- lengthInBits += 8 * uint16(len(m.value))
- }
+ // Array field
+ if len(m.value) > 0 {
+ lengthInBits += 8 * uint16(len(m.value))
+ }
- return lengthInBits
+ return lengthInBits
}
func (m ModbusPDUReportServerIdResponse) LengthInBytes() uint16 {
- return m.LengthInBits() / 8
+ return m.LengthInBits() / 8
}
-func (m ModbusPDUReportServerIdResponse) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUReportServerIdResponseParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Implicit Field (byteCount) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ var byteCount uint8 = io.ReadUint8(8)
-func (m ModbusPDUReportServerIdResponse) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Array field (value)
+ // Count array
+ if byteCount > math.MaxUint8 {
+ throw new ParseException("Array count of " + (byteCount) + " exceeds the maximum allowed count of " + math.MaxUint8);
+ }
+ int8[] value;
+ {
+ var itemCount := byteCount
+ value = new int8[itemCount]
+ for curItem := 0; curItem < itemCount; curItem++ {
+
+ value[curItem] = io.ReadInt8(8)
+ }
+ }
+
+ // Create the instance
+ return NewModbusPDUReportServerIdResponse(value)
}
+
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteFileRecordRequest.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteFileRecordRequest.go
index 4416d74..360e4d3 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteFileRecordRequest.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteFileRecordRequest.go
@@ -18,37 +18,62 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUWriteFileRecordRequest struct {
- items []ModbusPDUWriteFileRecordRequestItem
- ModbusPDU
+ items []ModbusPDUWriteFileRecordRequestItem
+ ModbusPDU
+}
+
+func (m ModbusPDUWriteFileRecordRequest) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUWriteFileRecordRequest(items []ModbusPDUWriteFileRecordRequestItem) ModbusPDUInitializer {
+ return &ModbusPDUWriteFileRecordRequest{items: items}
}
func (m ModbusPDUWriteFileRecordRequest) LengthInBits() uint16 {
- var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
+ var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
- // Implicit Field (byteCount)
- lengthInBits += 8
+ // Implicit Field (byteCount)
+ lengthInBits += 8
- // Array field
- if len(m.items) > 0 {
- for _, element := range m.items {
- lengthInBits += element.LengthInBits()
- }
- }
+ // Array field
+ if len(m.items) > 0 {
+ for _, element := range m.items {
+ lengthInBits += element.LengthInBits()
+ }
+ }
- return lengthInBits
+ return lengthInBits
}
func (m ModbusPDUWriteFileRecordRequest) LengthInBytes() uint16 {
- return m.LengthInBits() / 8
+ return m.LengthInBits() / 8
}
-func (m ModbusPDUWriteFileRecordRequest) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUWriteFileRecordRequestParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Implicit Field (byteCount) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ var byteCount uint8 = io.ReadUint8(8)
-func (m ModbusPDUWriteFileRecordRequest) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Array field (items)
+ // Length array
+ var _itemsLength := byteCount
+ List<ModbusPDUWriteFileRecordRequestItem> _itemsList = new LinkedList<>();
+ itemsEndPos := io.GetPos() + _itemsLength;
+ for ;io.getPos() < itemsEndPos; {
+ _itemsList.add(ModbusPDUWriteFileRecordRequestItemIO.staticParse(io));
+ }
+ ModbusPDUWriteFileRecordRequestItem[] items = _itemsList.toArray(new ModbusPDUWriteFileRecordRequestItem[0])
+
+ // Create the instance
+ return NewModbusPDUWriteFileRecordRequest(items)
}
+
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteFileRecordRequestItem.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteFileRecordRequestItem.go
index 1bded56..dc9b300 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteFileRecordRequestItem.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteFileRecordRequestItem.go
@@ -18,46 +18,81 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUWriteFileRecordRequestItem struct {
- referenceType uint8
- fileNumber uint16
- recordNumber uint16
- recordData []int8
+ referenceType uint8
+ fileNumber uint16
+ recordNumber uint16
+ recordData []int8
+
+}
+
+
+func NewModbusPDUWriteFileRecordRequestItem(referenceType uint8, fileNumber uint16, recordNumber uint16, recordData []int8) ModbusPDUWriteFileRecordRequestItem {
+ return &ModbusPDUWriteFileRecordRequestItem{referenceType: referenceType, fileNumber: fileNumber, recordNumber: recordNumber, recordData: recordData}
}
func (m ModbusPDUWriteFileRecordRequestItem) LengthInBits() uint16 {
- var lengthInBits uint16 = 0
+ var lengthInBits uint16 = 0
- // Simple field (referenceType)
- lengthInBits += 8
+ // Simple field (referenceType)
+ lengthInBits += 8
- // Simple field (fileNumber)
- lengthInBits += 16
+ // Simple field (fileNumber)
+ lengthInBits += 16
- // Simple field (recordNumber)
- lengthInBits += 16
+ // Simple field (recordNumber)
+ lengthInBits += 16
- // Implicit Field (recordLength)
- lengthInBits += 16
+ // Implicit Field (recordLength)
+ lengthInBits += 16
- // Array field
- if len(m.recordData) > 0 {
- lengthInBits += 8 * uint16(len(m.recordData))
- }
+ // Array field
+ if len(m.recordData) > 0 {
+ lengthInBits += 8 * uint16(len(m.recordData))
+ }
- return lengthInBits
+ return lengthInBits
}
func (m ModbusPDUWriteFileRecordRequestItem) LengthInBytes() uint16 {
- return m.LengthInBits() / 8
+ return m.LengthInBits() / 8
}
-func (m ModbusPDUWriteFileRecordRequestItem) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUWriteFileRecordRequestItemParse(io spi.ReadBuffer) ModbusPDUWriteFileRecordRequestItem {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Simple Field (referenceType)
+ var referenceType uint8 = io.ReadUint8(8)
-func (m ModbusPDUWriteFileRecordRequestItem) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Simple Field (fileNumber)
+ var fileNumber uint16 = io.ReadUint16(16)
+
+ // Simple Field (recordNumber)
+ var recordNumber uint16 = io.ReadUint16(16)
+
+ // Implicit Field (recordLength) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ var recordLength uint16 = io.ReadUint16(16)
+
+ // Array field (recordData)
+ // Length array
+ var _recordDataLength := (recordLength) * (2)
+ List<int8> _recordDataList = new LinkedList<>();
+ recordDataEndPos := io.GetPos() + _recordDataLength;
+ for ;io.getPos() < recordDataEndPos; {
+ _recordDataList.add(io.ReadInt8(8));
+ }
+ int8[] recordData = new int8[_recordDataList.size()]
+ for i := 0; i < _recordDataList.size(); i++ {
+ recordData[i] = (int8) _recordDataList.get(i)
+ }
+
+ // Create the instance
+ return NewModbusPDUWriteFileRecordRequestItem(referenceType, fileNumber, recordNumber, recordData)
}
+
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteFileRecordResponse.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteFileRecordResponse.go
index bee009b..77f1bf3 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteFileRecordResponse.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteFileRecordResponse.go
@@ -18,37 +18,62 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUWriteFileRecordResponse struct {
- items []ModbusPDUWriteFileRecordResponseItem
- ModbusPDU
+ items []ModbusPDUWriteFileRecordResponseItem
+ ModbusPDU
+}
+
+func (m ModbusPDUWriteFileRecordResponse) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUWriteFileRecordResponse(items []ModbusPDUWriteFileRecordResponseItem) ModbusPDUInitializer {
+ return &ModbusPDUWriteFileRecordResponse{items: items}
}
func (m ModbusPDUWriteFileRecordResponse) LengthInBits() uint16 {
- var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
+ var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
- // Implicit Field (byteCount)
- lengthInBits += 8
+ // Implicit Field (byteCount)
+ lengthInBits += 8
- // Array field
- if len(m.items) > 0 {
- for _, element := range m.items {
- lengthInBits += element.LengthInBits()
- }
- }
+ // Array field
+ if len(m.items) > 0 {
+ for _, element := range m.items {
+ lengthInBits += element.LengthInBits()
+ }
+ }
- return lengthInBits
+ return lengthInBits
}
func (m ModbusPDUWriteFileRecordResponse) LengthInBytes() uint16 {
- return m.LengthInBits() / 8
+ return m.LengthInBits() / 8
}
-func (m ModbusPDUWriteFileRecordResponse) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUWriteFileRecordResponseParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Implicit Field (byteCount) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ var byteCount uint8 = io.ReadUint8(8)
-func (m ModbusPDUWriteFileRecordResponse) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Array field (items)
+ // Length array
+ var _itemsLength := byteCount
+ List<ModbusPDUWriteFileRecordResponseItem> _itemsList = new LinkedList<>();
+ itemsEndPos := io.GetPos() + _itemsLength;
+ for ;io.getPos() < itemsEndPos; {
+ _itemsList.add(ModbusPDUWriteFileRecordResponseItemIO.staticParse(io));
+ }
+ ModbusPDUWriteFileRecordResponseItem[] items = _itemsList.toArray(new ModbusPDUWriteFileRecordResponseItem[0])
+
+ // Create the instance
+ return NewModbusPDUWriteFileRecordResponse(items)
}
+
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteFileRecordResponseItem.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteFileRecordResponseItem.go
index 2f0e526..d0a3035 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteFileRecordResponseItem.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteFileRecordResponseItem.go
@@ -18,46 +18,81 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUWriteFileRecordResponseItem struct {
- referenceType uint8
- fileNumber uint16
- recordNumber uint16
- recordData []int8
+ referenceType uint8
+ fileNumber uint16
+ recordNumber uint16
+ recordData []int8
+
+}
+
+
+func NewModbusPDUWriteFileRecordResponseItem(referenceType uint8, fileNumber uint16, recordNumber uint16, recordData []int8) ModbusPDUWriteFileRecordResponseItem {
+ return &ModbusPDUWriteFileRecordResponseItem{referenceType: referenceType, fileNumber: fileNumber, recordNumber: recordNumber, recordData: recordData}
}
func (m ModbusPDUWriteFileRecordResponseItem) LengthInBits() uint16 {
- var lengthInBits uint16 = 0
+ var lengthInBits uint16 = 0
- // Simple field (referenceType)
- lengthInBits += 8
+ // Simple field (referenceType)
+ lengthInBits += 8
- // Simple field (fileNumber)
- lengthInBits += 16
+ // Simple field (fileNumber)
+ lengthInBits += 16
- // Simple field (recordNumber)
- lengthInBits += 16
+ // Simple field (recordNumber)
+ lengthInBits += 16
- // Implicit Field (recordLength)
- lengthInBits += 16
+ // Implicit Field (recordLength)
+ lengthInBits += 16
- // Array field
- if len(m.recordData) > 0 {
- lengthInBits += 8 * uint16(len(m.recordData))
- }
+ // Array field
+ if len(m.recordData) > 0 {
+ lengthInBits += 8 * uint16(len(m.recordData))
+ }
- return lengthInBits
+ return lengthInBits
}
func (m ModbusPDUWriteFileRecordResponseItem) LengthInBytes() uint16 {
- return m.LengthInBits() / 8
+ return m.LengthInBits() / 8
}
-func (m ModbusPDUWriteFileRecordResponseItem) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUWriteFileRecordResponseItemParse(io spi.ReadBuffer) ModbusPDUWriteFileRecordResponseItem {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Simple Field (referenceType)
+ var referenceType uint8 = io.ReadUint8(8)
-func (m ModbusPDUWriteFileRecordResponseItem) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Simple Field (fileNumber)
+ var fileNumber uint16 = io.ReadUint16(16)
+
+ // Simple Field (recordNumber)
+ var recordNumber uint16 = io.ReadUint16(16)
+
+ // Implicit Field (recordLength) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ var recordLength uint16 = io.ReadUint16(16)
+
+ // Array field (recordData)
+ // Length array
+ var _recordDataLength := recordLength
+ List<int8> _recordDataList = new LinkedList<>();
+ recordDataEndPos := io.GetPos() + _recordDataLength;
+ for ;io.getPos() < recordDataEndPos; {
+ _recordDataList.add(io.ReadInt8(8));
+ }
+ int8[] recordData = new int8[_recordDataList.size()]
+ for i := 0; i < _recordDataList.size(); i++ {
+ recordData[i] = (int8) _recordDataList.get(i)
+ }
+
+ // Create the instance
+ return NewModbusPDUWriteFileRecordResponseItem(referenceType, fileNumber, recordNumber, recordData)
}
+
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteMultipleCoilsRequest.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteMultipleCoilsRequest.go
index 8ab4459..d7b9579 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteMultipleCoilsRequest.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteMultipleCoilsRequest.go
@@ -18,43 +18,79 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUWriteMultipleCoilsRequest struct {
- startingAddress uint16
- quantity uint16
- value []int8
- ModbusPDU
+ startingAddress uint16
+ quantity uint16
+ value []int8
+ ModbusPDU
+}
+
+func (m ModbusPDUWriteMultipleCoilsRequest) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUWriteMultipleCoilsRequest(startingAddress uint16, quantity uint16, value []int8) ModbusPDUInitializer {
+ return &ModbusPDUWriteMultipleCoilsRequest{startingAddress: startingAddress, quantity: quantity, value: value}
}
func (m ModbusPDUWriteMultipleCoilsRequest) LengthInBits() uint16 {
- var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
+ var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
- // Simple field (startingAddress)
- lengthInBits += 16
+ // Simple field (startingAddress)
+ lengthInBits += 16
- // Simple field (quantity)
- lengthInBits += 16
+ // Simple field (quantity)
+ lengthInBits += 16
- // Implicit Field (byteCount)
- lengthInBits += 8
+ // Implicit Field (byteCount)
+ lengthInBits += 8
- // Array field
- if len(m.value) > 0 {
- lengthInBits += 8 * uint16(len(m.value))
- }
+ // Array field
+ if len(m.value) > 0 {
+ lengthInBits += 8 * uint16(len(m.value))
+ }
- return lengthInBits
+ return lengthInBits
}
func (m ModbusPDUWriteMultipleCoilsRequest) LengthInBytes() uint16 {
- return m.LengthInBits() / 8
+ return m.LengthInBits() / 8
}
-func (m ModbusPDUWriteMultipleCoilsRequest) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUWriteMultipleCoilsRequestParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
-func (m ModbusPDUWriteMultipleCoilsRequest) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Simple Field (startingAddress)
+ var startingAddress uint16 = io.ReadUint16(16)
+
+ // Simple Field (quantity)
+ var quantity uint16 = io.ReadUint16(16)
+
+ // Implicit Field (byteCount) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ var byteCount uint8 = io.ReadUint8(8)
+
+ // Array field (value)
+ // Count array
+ if byteCount > math.MaxUint8 {
+ throw new ParseException("Array count of " + (byteCount) + " exceeds the maximum allowed count of " + math.MaxUint8);
+ }
+ int8[] value;
+ {
+ var itemCount := byteCount
+ value = new int8[itemCount]
+ for curItem := 0; curItem < itemCount; curItem++ {
+
+ value[curItem] = io.ReadInt8(8)
+ }
+ }
+
+ // Create the instance
+ return NewModbusPDUWriteMultipleCoilsRequest(startingAddress, quantity, value)
}
+
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteMultipleCoilsResponse.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteMultipleCoilsResponse.go
index c95ee59..5609a77 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteMultipleCoilsResponse.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteMultipleCoilsResponse.go
@@ -18,7 +18,10 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUWriteMultipleCoilsResponse struct {
startingAddress uint16
@@ -26,6 +29,14 @@ type ModbusPDUWriteMultipleCoilsResponse struct {
ModbusPDU
}
+func (m ModbusPDUWriteMultipleCoilsResponse) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUWriteMultipleCoilsResponse(startingAddress uint16, quantity uint16) ModbusPDUInitializer {
+ return &ModbusPDUWriteMultipleCoilsResponse{startingAddress: startingAddress, quantity: quantity}
+}
+
func (m ModbusPDUWriteMultipleCoilsResponse) LengthInBits() uint16 {
var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
@@ -42,10 +53,16 @@ func (m ModbusPDUWriteMultipleCoilsResponse) LengthInBytes() uint16 {
return m.LengthInBits() / 8
}
-func (m ModbusPDUWriteMultipleCoilsResponse) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUWriteMultipleCoilsResponseParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Simple Field (startingAddress)
+ var startingAddress uint16 = io.ReadUint16(16)
+
+ // Simple Field (quantity)
+ var quantity uint16 = io.ReadUint16(16)
-func (m ModbusPDUWriteMultipleCoilsResponse) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Create the instance
+ return NewModbusPDUWriteMultipleCoilsResponse(startingAddress, quantity)
}
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersRequest.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersRequest.go
index f19afe8..8e8aed1 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersRequest.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersRequest.go
@@ -18,43 +18,79 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUWriteMultipleHoldingRegistersRequest struct {
- startingAddress uint16
- quantity uint16
- value []int8
- ModbusPDU
+ startingAddress uint16
+ quantity uint16
+ value []int8
+ ModbusPDU
+}
+
+func (m ModbusPDUWriteMultipleHoldingRegistersRequest) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUWriteMultipleHoldingRegistersRequest(startingAddress uint16, quantity uint16, value []int8) ModbusPDUInitializer {
+ return &ModbusPDUWriteMultipleHoldingRegistersRequest{startingAddress: startingAddress, quantity: quantity, value: value}
}
func (m ModbusPDUWriteMultipleHoldingRegistersRequest) LengthInBits() uint16 {
- var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
+ var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
- // Simple field (startingAddress)
- lengthInBits += 16
+ // Simple field (startingAddress)
+ lengthInBits += 16
- // Simple field (quantity)
- lengthInBits += 16
+ // Simple field (quantity)
+ lengthInBits += 16
- // Implicit Field (byteCount)
- lengthInBits += 8
+ // Implicit Field (byteCount)
+ lengthInBits += 8
- // Array field
- if len(m.value) > 0 {
- lengthInBits += 8 * uint16(len(m.value))
- }
+ // Array field
+ if len(m.value) > 0 {
+ lengthInBits += 8 * uint16(len(m.value))
+ }
- return lengthInBits
+ return lengthInBits
}
func (m ModbusPDUWriteMultipleHoldingRegistersRequest) LengthInBytes() uint16 {
- return m.LengthInBits() / 8
+ return m.LengthInBits() / 8
}
-func (m ModbusPDUWriteMultipleHoldingRegistersRequest) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUWriteMultipleHoldingRegistersRequestParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
-func (m ModbusPDUWriteMultipleHoldingRegistersRequest) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Simple Field (startingAddress)
+ var startingAddress uint16 = io.ReadUint16(16)
+
+ // Simple Field (quantity)
+ var quantity uint16 = io.ReadUint16(16)
+
+ // Implicit Field (byteCount) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ var byteCount uint8 = io.ReadUint8(8)
+
+ // Array field (value)
+ // Count array
+ if byteCount > math.MaxUint8 {
+ throw new ParseException("Array count of " + (byteCount) + " exceeds the maximum allowed count of " + math.MaxUint8);
+ }
+ int8[] value;
+ {
+ var itemCount := byteCount
+ value = new int8[itemCount]
+ for curItem := 0; curItem < itemCount; curItem++ {
+
+ value[curItem] = io.ReadInt8(8)
+ }
+ }
+
+ // Create the instance
+ return NewModbusPDUWriteMultipleHoldingRegistersRequest(startingAddress, quantity, value)
}
+
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersResponse.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersResponse.go
index 241623e..6184cbd 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersResponse.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersResponse.go
@@ -18,7 +18,10 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUWriteMultipleHoldingRegistersResponse struct {
startingAddress uint16
@@ -26,6 +29,14 @@ type ModbusPDUWriteMultipleHoldingRegistersResponse struct {
ModbusPDU
}
+func (m ModbusPDUWriteMultipleHoldingRegistersResponse) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUWriteMultipleHoldingRegistersResponse(startingAddress uint16, quantity uint16) ModbusPDUInitializer {
+ return &ModbusPDUWriteMultipleHoldingRegistersResponse{startingAddress: startingAddress, quantity: quantity}
+}
+
func (m ModbusPDUWriteMultipleHoldingRegistersResponse) LengthInBits() uint16 {
var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
@@ -42,10 +53,16 @@ func (m ModbusPDUWriteMultipleHoldingRegistersResponse) LengthInBytes() uint16 {
return m.LengthInBits() / 8
}
-func (m ModbusPDUWriteMultipleHoldingRegistersResponse) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUWriteMultipleHoldingRegistersResponseParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Simple Field (startingAddress)
+ var startingAddress uint16 = io.ReadUint16(16)
+
+ // Simple Field (quantity)
+ var quantity uint16 = io.ReadUint16(16)
-func (m ModbusPDUWriteMultipleHoldingRegistersResponse) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Create the instance
+ return NewModbusPDUWriteMultipleHoldingRegistersResponse(startingAddress, quantity)
}
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteSingleCoilRequest.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteSingleCoilRequest.go
index 6b48e4b..ef56415 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteSingleCoilRequest.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteSingleCoilRequest.go
@@ -18,7 +18,10 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUWriteSingleCoilRequest struct {
address uint16
@@ -26,6 +29,14 @@ type ModbusPDUWriteSingleCoilRequest struct {
ModbusPDU
}
+func (m ModbusPDUWriteSingleCoilRequest) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUWriteSingleCoilRequest(address uint16, value uint16) ModbusPDUInitializer {
+ return &ModbusPDUWriteSingleCoilRequest{address: address, value: value}
+}
+
func (m ModbusPDUWriteSingleCoilRequest) LengthInBits() uint16 {
var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
@@ -42,10 +53,16 @@ func (m ModbusPDUWriteSingleCoilRequest) LengthInBytes() uint16 {
return m.LengthInBits() / 8
}
-func (m ModbusPDUWriteSingleCoilRequest) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUWriteSingleCoilRequestParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Simple Field (address)
+ var address uint16 = io.ReadUint16(16)
+
+ // Simple Field (value)
+ var value uint16 = io.ReadUint16(16)
-func (m ModbusPDUWriteSingleCoilRequest) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Create the instance
+ return NewModbusPDUWriteSingleCoilRequest(address, value)
}
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteSingleCoilResponse.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteSingleCoilResponse.go
index fce6b04..7c5a877 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteSingleCoilResponse.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteSingleCoilResponse.go
@@ -18,7 +18,10 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUWriteSingleCoilResponse struct {
address uint16
@@ -26,6 +29,14 @@ type ModbusPDUWriteSingleCoilResponse struct {
ModbusPDU
}
+func (m ModbusPDUWriteSingleCoilResponse) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUWriteSingleCoilResponse(address uint16, value uint16) ModbusPDUInitializer {
+ return &ModbusPDUWriteSingleCoilResponse{address: address, value: value}
+}
+
func (m ModbusPDUWriteSingleCoilResponse) LengthInBits() uint16 {
var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
@@ -42,10 +53,16 @@ func (m ModbusPDUWriteSingleCoilResponse) LengthInBytes() uint16 {
return m.LengthInBits() / 8
}
-func (m ModbusPDUWriteSingleCoilResponse) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUWriteSingleCoilResponseParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Simple Field (address)
+ var address uint16 = io.ReadUint16(16)
+
+ // Simple Field (value)
+ var value uint16 = io.ReadUint16(16)
-func (m ModbusPDUWriteSingleCoilResponse) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Create the instance
+ return NewModbusPDUWriteSingleCoilResponse(address, value)
}
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteSingleRegisterRequest.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteSingleRegisterRequest.go
index ec83e1f..f1ee827 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteSingleRegisterRequest.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteSingleRegisterRequest.go
@@ -18,7 +18,10 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUWriteSingleRegisterRequest struct {
address uint16
@@ -26,6 +29,14 @@ type ModbusPDUWriteSingleRegisterRequest struct {
ModbusPDU
}
+func (m ModbusPDUWriteSingleRegisterRequest) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUWriteSingleRegisterRequest(address uint16, value uint16) ModbusPDUInitializer {
+ return &ModbusPDUWriteSingleRegisterRequest{address: address, value: value}
+}
+
func (m ModbusPDUWriteSingleRegisterRequest) LengthInBits() uint16 {
var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
@@ -42,10 +53,16 @@ func (m ModbusPDUWriteSingleRegisterRequest) LengthInBytes() uint16 {
return m.LengthInBits() / 8
}
-func (m ModbusPDUWriteSingleRegisterRequest) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUWriteSingleRegisterRequestParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Simple Field (address)
+ var address uint16 = io.ReadUint16(16)
+
+ // Simple Field (value)
+ var value uint16 = io.ReadUint16(16)
-func (m ModbusPDUWriteSingleRegisterRequest) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Create the instance
+ return NewModbusPDUWriteSingleRegisterRequest(address, value)
}
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteSingleRegisterResponse.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteSingleRegisterResponse.go
index 6fdefe2..c8642ac 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteSingleRegisterResponse.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusPDUWriteSingleRegisterResponse.go
@@ -18,7 +18,10 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusPDUWriteSingleRegisterResponse struct {
address uint16
@@ -26,6 +29,14 @@ type ModbusPDUWriteSingleRegisterResponse struct {
ModbusPDU
}
+func (m ModbusPDUWriteSingleRegisterResponse) initialize() ModbusPDU {
+ return m.ModbusPDU
+}
+
+func NewModbusPDUWriteSingleRegisterResponse(address uint16, value uint16) ModbusPDUInitializer {
+ return &ModbusPDUWriteSingleRegisterResponse{address: address, value: value}
+}
+
func (m ModbusPDUWriteSingleRegisterResponse) LengthInBits() uint16 {
var lengthInBits uint16 = m.ModbusPDU.LengthInBits()
@@ -42,10 +53,16 @@ func (m ModbusPDUWriteSingleRegisterResponse) LengthInBytes() uint16 {
return m.LengthInBits() / 8
}
-func (m ModbusPDUWriteSingleRegisterResponse) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusPDUWriteSingleRegisterResponseParse(io spi.ReadBuffer) ModbusPDUInitializer {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Simple Field (address)
+ var address uint16 = io.ReadUint16(16)
+
+ // Simple Field (value)
+ var value uint16 = io.ReadUint16(16)
-func (m ModbusPDUWriteSingleRegisterResponse) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Create the instance
+ return NewModbusPDUWriteSingleRegisterResponse(address, value)
}
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusSerialADU.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusSerialADU.go
index ad25ac6..7009210 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusSerialADU.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusSerialADU.go
@@ -18,44 +18,74 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusSerialADU struct {
- transactionId uint16
- length uint16
- address uint8
- pdu ModbusPDU
+ transactionId uint16
+ length uint16
+ address uint8
+ pdu ModbusPDU
+
+}
+
+
+func NewModbusSerialADU(transactionId uint16, length uint16, address uint8, pdu ModbusPDU) ModbusSerialADU {
+ return &ModbusSerialADU{transactionId: transactionId, length: length, address: address, pdu: pdu}
}
func (m ModbusSerialADU) LengthInBits() uint16 {
- var lengthInBits uint16 = 0
+ var lengthInBits uint16 = 0
- // Simple field (transactionId)
- lengthInBits += 16
+ // Simple field (transactionId)
+ lengthInBits += 16
- // Reserved Field (reserved)
- lengthInBits += 16
+ // Reserved Field (reserved)
+ lengthInBits += 16
- // Simple field (length)
- lengthInBits += 16
+ // Simple field (length)
+ lengthInBits += 16
- // Simple field (address)
- lengthInBits += 8
+ // Simple field (address)
+ lengthInBits += 8
- // Simple field (pdu)
- lengthInBits += m.pdu.LengthInBits()
+ // Simple field (pdu)
+ lengthInBits += m.pdu.LengthInBits()
- return lengthInBits
+ return lengthInBits
}
func (m ModbusSerialADU) LengthInBytes() uint16 {
- return m.LengthInBits() / 8
+ return m.LengthInBits() / 8
}
-func (m ModbusSerialADU) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusSerialADUParse(io spi.ReadBuffer, response bool) ModbusSerialADU {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Simple Field (transactionId)
+ var transactionId uint16 = io.ReadUint16(16)
-func (m ModbusSerialADU) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
+ {
+ var reserved uint16 = io.ReadUint16(16)
+ if reserved != (uint16) 0x0000 {
+ LOGGER.info("Expected constant value " + 0x0000 + " but got " + reserved + " for reserved field.")
+ }
+ }
+
+ // Simple Field (length)
+ var length uint16 = io.ReadUint16(16)
+
+ // Simple Field (address)
+ var address uint8 = io.ReadUint8(8)
+
+ // Simple Field (pdu)
+ var pdu ModbusPDU = ModbusPDUIO.staticParse(io, (bool) (response))
+
+ // Create the instance
+ return NewModbusSerialADU(transactionId, length, address, pdu)
}
+
diff --git a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusTcpADU.go b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusTcpADU.go
index 0b321d3..fd7e5d7 100644
--- a/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusTcpADU.go
+++ b/sandbox/plc4go/generated-sources/plc4go/go/modbus/readwrite/ModbusTcpADU.go
@@ -18,43 +18,71 @@
//
package readwrite
-import "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+import (
+ "math"
+ "plc4x.apache.org/plc4go-modbus-driver/0.8.0/src/plc4go/spi"
+)
type ModbusTcpADU struct {
- transactionIdentifier uint16
- unitIdentifier uint8
- pdu ModbusPDU
+ transactionIdentifier uint16
+ unitIdentifier uint8
+ pdu ModbusPDU
+
+}
+
+
+func NewModbusTcpADU(transactionIdentifier uint16, unitIdentifier uint8, pdu ModbusPDU) ModbusTcpADU {
+ return &ModbusTcpADU{transactionIdentifier: transactionIdentifier, unitIdentifier: unitIdentifier, pdu: pdu}
}
func (m ModbusTcpADU) LengthInBits() uint16 {
- var lengthInBits uint16 = 0
+ var lengthInBits uint16 = 0
- // Simple field (transactionIdentifier)
- lengthInBits += 16
+ // Simple field (transactionIdentifier)
+ lengthInBits += 16
- // Const Field (protocolIdentifier)
- lengthInBits += 16
+ // Const Field (protocolIdentifier)
+ lengthInBits += 16
- // Implicit Field (length)
- lengthInBits += 16
+ // Implicit Field (length)
+ lengthInBits += 16
- // Simple field (unitIdentifier)
- lengthInBits += 8
+ // Simple field (unitIdentifier)
+ lengthInBits += 8
- // Simple field (pdu)
- lengthInBits += m.pdu.LengthInBits()
+ // Simple field (pdu)
+ lengthInBits += m.pdu.LengthInBits()
- return lengthInBits
+ return lengthInBits
}
func (m ModbusTcpADU) LengthInBytes() uint16 {
- return m.LengthInBits() / 8
+ return m.LengthInBits() / 8
}
-func (m ModbusTcpADU) Parse(io spi.ReadBuffer) {
- // TODO: Implement ...
-}
+func ModbusTcpADUParse(io spi.ReadBuffer, response bool) ModbusTcpADU {
+ var startPos = io.GetPos()
+ var curPos uint16
+
+ // Simple Field (transactionIdentifier)
+ var transactionIdentifier uint16 = io.ReadUint16(16)
-func (m ModbusTcpADU) Serialize(io spi.WriteBuffer) {
- // TODO: Implement ...
+ // Const Field (protocolIdentifier)
+ uint16 protocolIdentifier = io.ReadUint16(16)
+ if protocolIdentifier != ModbusTcpADU.PROTOCOLIDENTIFIER {
+ throw new ParseException("Expected constant value " + ModbusTcpADU.PROTOCOLIDENTIFIER + " but got " + protocolIdentifier)
+ }
+
+ // Implicit Field (length) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content)
+ var length uint16 = io.ReadUint16(16)
+
+ // Simple Field (unitIdentifier)
+ var unitIdentifier uint8 = io.ReadUint8(8)
+
+ // Simple Field (pdu)
+ var pdu ModbusPDU = ModbusPDUIO.staticParse(io, (bool) (response))
+
+ // Create the instance
+ return NewModbusTcpADU(transactionIdentifier, unitIdentifier, pdu)
}
+
diff --git a/sandbox/pom.xml b/sandbox/pom.xml
index e22fe3a..6216f51 100644
--- a/sandbox/pom.xml
+++ b/sandbox/pom.xml
@@ -94,7 +94,6 @@
</modules>
</profile>
-
<!-- Build PLC4X including the Go modules -->
<profile>
<id>with-go</id>