You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@plc4x.apache.org by sr...@apache.org on 2022/03/02 15:38:44 UTC
[plc4x] branch develop updated: feat(plc4go/c-bus): added IdentifyReplyCommand
This is an automated email from the ASF dual-hosted git repository.
sruehl pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/plc4x.git
The following commit(s) were added to refs/heads/develop by this push:
new 9dd8a07 feat(plc4go/c-bus): added IdentifyReplyCommand
9dd8a07 is described below
commit 9dd8a07e968ccafeb4a5662bc2619b15f2fffcbe
Author: Sebastian Rühl <sr...@apache.org>
AuthorDate: Wed Mar 2 16:34:35 2022 +0100
feat(plc4go/c-bus): added IdentifyReplyCommand
---
.../internal/plc4go/cbus/readwrite/ParserHelper.go | 63 +-
.../plc4go/cbus/readwrite/XmlParserHelper.go | 57 +-
.../plc4go/cbus/readwrite/model/ChannelStatus.go | 129 ++++
.../cbus/readwrite/model/IdentifyReplyCommand.go | 197 ++++++
.../IdentifyReplyCommandCurrentSenseLevels.go | 150 +++++
.../model/IdentifyReplyCommandDSIStatus.go | 509 ++++++++++++++
.../readwrite/model/IdentifyReplyCommandDelays.go | 150 +++++
...dentifyReplyCommandExtendedDiagnosticSummary.go | 743 +++++++++++++++++++++
.../model/IdentifyReplyCommandFirmwareSummary.go | 228 +++++++
.../model/IdentifyReplyCommandFirmwareVersion.go | 176 +++++
.../IdentifyReplyCommandGAVPhysicalAddresses.go | 179 +++++
.../model/IdentifyReplyCommandGAVValuesCurrent.go | 179 +++++
.../model/IdentifyReplyCommandGAVValuesStored.go | 179 +++++
.../model/IdentifyReplyCommandLogicalAssignment.go | 150 +++++
.../model/IdentifyReplyCommandManufacturer.go | 176 +++++
.../model/IdentifyReplyCommandMaximumLevels.go | 150 +++++
.../model/IdentifyReplyCommandMinimumLevels.go | 150 +++++
.../IdentifyReplyCommandNetworkTerminalLevels.go | 150 +++++
.../model/IdentifyReplyCommandNetworkVoltage.go | 243 +++++++
.../model/IdentifyReplyCommandOutputUnitSummary.go | 150 +++++
.../model/IdentifyReplyCommandTerminalLevels.go | 150 +++++
.../readwrite/model/IdentifyReplyCommandType.go | 176 +++++
.../plc4go/cbus/readwrite/model/UnitStatus.go | 129 ++++
.../src/main/resources/protocols/cbus/c-bus.mspec | 106 +++
24 files changed, 4612 insertions(+), 57 deletions(-)
diff --git a/plc4go/internal/plc4go/cbus/readwrite/ParserHelper.go b/plc4go/internal/plc4go/cbus/readwrite/ParserHelper.go
index 73481c7..dc5d248 100644
--- a/plc4go/internal/plc4go/cbus/readwrite/ParserHelper.go
+++ b/plc4go/internal/plc4go/cbus/readwrite/ParserHelper.go
@@ -36,22 +36,49 @@ func (m CbusParserHelper) Parse(typeName string, arguments []string, io utils.Re
return model.CALDataParse(io)
case "Checksum":
return model.ChecksumParse(io)
- case "BridgeAddress":
- return model.BridgeAddressParse(io)
case "CALReply":
return model.CALReplyParse(io)
- case "MonitoredSAL":
- return model.MonitoredSALParse(io)
case "ExclamationMark":
return model.ExclamationMarkParse(io)
+ case "NetworkRoute":
+ return model.NetworkRouteParse(io)
+ case "Application":
+ return model.ApplicationParse(io)
+ case "NetworkNumber":
+ return model.NetworkNumberParse(io)
+ case "StandardFormatStatusReply":
+ return model.StandardFormatStatusReplyParse(io)
+ case "CBusOptions":
+ return model.CBusOptionsParse(io)
+ case "SALData":
+ return model.SALDataParse(io)
+ case "CBusCommand":
+ srchk, err := utils.StrToBool(arguments[0])
+ if err != nil {
+ return nil, errors.Wrap(err, "Error parsing")
+ }
+ return model.CBusCommandParse(io, srchk)
+ case "IdentifyReplyCommand":
+ var attribute model.Attribute
+ return model.IdentifyReplyCommandParse(io, attribute)
+ case "BridgeCount":
+ return model.BridgeCountParse(io)
+ case "PowerUp":
+ return model.PowerUpParse(io)
+ case "Reply":
+ return model.ReplyParse(io)
+ case "SerialInterfaceAddress":
+ return model.SerialInterfaceAddressParse(io)
+ case "BridgeAddress":
+ return model.BridgeAddressParse(io)
+ case "MonitoredSAL":
+ return model.MonitoredSALParse(io)
case "ParameterChange":
return model.ParameterChangeParse(io)
case "StatusByte":
return model.StatusByteParse(io)
case "ReplyNetwork":
return model.ReplyNetworkParse(io)
- case "NetworkRoute":
- return model.NetworkRouteParse(io)
case "ExtendedStatusHeader":
return model.ExtendedStatusHeaderParse(io)
case "CommandHeader":
@@ -64,26 +91,10 @@ func (m CbusParserHelper) Parse(typeName string, arguments []string, io utils.Re
return nil, errors.Wrap(err, "Error parsing")
}
return model.CBusPointToMultiPointCommandParse(io, srchk)
- case "Application":
- return model.ApplicationParse(io)
case "StatusHeader":
return model.StatusHeaderParse(io)
case "StatusRequest":
return model.StatusRequestParse(io)
- case "NetworkNumber":
- return model.NetworkNumberParse(io)
- case "StandardFormatStatusReply":
- return model.StandardFormatStatusReplyParse(io)
- case "CBusOptions":
- return model.CBusOptionsParse(io)
- case "SALData":
- return model.SALDataParse(io)
- case "CBusCommand":
- srchk, err := utils.StrToBool(arguments[0])
- if err != nil {
- return nil, errors.Wrap(err, "Error parsing")
- }
- return model.CBusCommandParse(io, srchk)
case "UnitAddress":
return model.UnitAddressParse(io)
case "NetworkProtocolControlInformation":
@@ -98,22 +109,14 @@ func (m CbusParserHelper) Parse(typeName string, arguments []string, io utils.Re
return nil, errors.Wrap(err, "Error parsing")
}
return model.CBusPointToPointCommandParse(io, srchk)
- case "BridgeCount":
- return model.BridgeCountParse(io)
case "Alpha":
return model.AlphaParse(io)
- case "PowerUp":
- return model.PowerUpParse(io)
case "CBusPointToPointToMultipointCommand":
srchk, err := utils.StrToBool(arguments[0])
if err != nil {
return nil, errors.Wrap(err, "Error parsing")
}
return model.CBusPointToPointToMultipointCommandParse(io, srchk)
- case "Reply":
- return model.ReplyParse(io)
- case "SerialInterfaceAddress":
- return model.SerialInterfaceAddressParse(io)
}
return nil, errors.Errorf("Unsupported type %s", typeName)
}
diff --git a/plc4go/internal/plc4go/cbus/readwrite/XmlParserHelper.go b/plc4go/internal/plc4go/cbus/readwrite/XmlParserHelper.go
index 834a764..588c469 100644
--- a/plc4go/internal/plc4go/cbus/readwrite/XmlParserHelper.go
+++ b/plc4go/internal/plc4go/cbus/readwrite/XmlParserHelper.go
@@ -46,22 +46,46 @@ func (m CbusXmlParserHelper) Parse(typeName string, xmlString string, parserArgu
return model.CALDataParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
case "Checksum":
return model.ChecksumParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
- case "BridgeAddress":
- return model.BridgeAddressParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
case "CALReply":
return model.CALReplyParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
- case "MonitoredSAL":
- return model.MonitoredSALParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
case "ExclamationMark":
return model.ExclamationMarkParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
+ case "NetworkRoute":
+ return model.NetworkRouteParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
+ case "Application":
+ return model.ApplicationParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
+ case "NetworkNumber":
+ return model.NetworkNumberParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
+ case "StandardFormatStatusReply":
+ return model.StandardFormatStatusReplyParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
+ case "CBusOptions":
+ return model.CBusOptionsParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
+ case "SALData":
+ return model.SALDataParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
+ case "CBusCommand":
+ srchk := parserArguments[0] == "true"
+ return model.CBusCommandParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)), srchk)
+ case "IdentifyReplyCommand":
+ attribute := model.AttributeByName(parserArguments[0])
+ return model.IdentifyReplyCommandParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)), attribute)
+ case "BridgeCount":
+ return model.BridgeCountParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
+ case "PowerUp":
+ return model.PowerUpParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
+ case "Reply":
+ return model.ReplyParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
+ case "SerialInterfaceAddress":
+ return model.SerialInterfaceAddressParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
+ case "BridgeAddress":
+ return model.BridgeAddressParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
+ case "MonitoredSAL":
+ return model.MonitoredSALParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
case "ParameterChange":
return model.ParameterChangeParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
case "StatusByte":
return model.StatusByteParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
case "ReplyNetwork":
return model.ReplyNetworkParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
- case "NetworkRoute":
- return model.NetworkRouteParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
case "ExtendedStatusHeader":
return model.ExtendedStatusHeaderParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
case "CommandHeader":
@@ -71,23 +95,10 @@ func (m CbusXmlParserHelper) Parse(typeName string, xmlString string, parserArgu
case "CBusPointToMultiPointCommand":
srchk := parserArguments[0] == "true"
return model.CBusPointToMultiPointCommandParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)), srchk)
- case "Application":
- return model.ApplicationParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
case "StatusHeader":
return model.StatusHeaderParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
case "StatusRequest":
return model.StatusRequestParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
- case "NetworkNumber":
- return model.NetworkNumberParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
- case "StandardFormatStatusReply":
- return model.StandardFormatStatusReplyParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
- case "CBusOptions":
- return model.CBusOptionsParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
- case "SALData":
- return model.SALDataParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
- case "CBusCommand":
- srchk := parserArguments[0] == "true"
- return model.CBusCommandParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)), srchk)
case "UnitAddress":
return model.UnitAddressParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
case "NetworkProtocolControlInformation":
@@ -99,19 +110,11 @@ func (m CbusXmlParserHelper) Parse(typeName string, xmlString string, parserArgu
case "CBusPointToPointCommand":
srchk := parserArguments[0] == "true"
return model.CBusPointToPointCommandParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)), srchk)
- case "BridgeCount":
- return model.BridgeCountParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
case "Alpha":
return model.AlphaParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
- case "PowerUp":
- return model.PowerUpParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
case "CBusPointToPointToMultipointCommand":
srchk := parserArguments[0] == "true"
return model.CBusPointToPointToMultipointCommandParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)), srchk)
- case "Reply":
- return model.ReplyParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
- case "SerialInterfaceAddress":
- return model.SerialInterfaceAddressParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
}
return nil, errors.Errorf("Unsupported type %s", typeName)
}
diff --git a/plc4go/internal/plc4go/cbus/readwrite/model/ChannelStatus.go b/plc4go/internal/plc4go/cbus/readwrite/model/ChannelStatus.go
new file mode 100644
index 0000000..8d40e05
--- /dev/null
+++ b/plc4go/internal/plc4go/cbus/readwrite/model/ChannelStatus.go
@@ -0,0 +1,129 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+ "github.com/pkg/errors"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+type ChannelStatus uint8
+
+type IChannelStatus interface {
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+const (
+ ChannelStatus_OK ChannelStatus = 0
+ ChannelStatus_LAMP_FAULT ChannelStatus = 2
+ ChannelStatus_CURRENT_LIMIT_OR_SHORT ChannelStatus = 3
+)
+
+var ChannelStatusValues []ChannelStatus
+
+func init() {
+ _ = errors.New
+ ChannelStatusValues = []ChannelStatus{
+ ChannelStatus_OK,
+ ChannelStatus_LAMP_FAULT,
+ ChannelStatus_CURRENT_LIMIT_OR_SHORT,
+ }
+}
+
+func ChannelStatusByValue(value uint8) ChannelStatus {
+ switch value {
+ case 0:
+ return ChannelStatus_OK
+ case 2:
+ return ChannelStatus_LAMP_FAULT
+ case 3:
+ return ChannelStatus_CURRENT_LIMIT_OR_SHORT
+ }
+ return 0
+}
+
+func ChannelStatusByName(value string) ChannelStatus {
+ switch value {
+ case "OK":
+ return ChannelStatus_OK
+ case "LAMP_FAULT":
+ return ChannelStatus_LAMP_FAULT
+ case "CURRENT_LIMIT_OR_SHORT":
+ return ChannelStatus_CURRENT_LIMIT_OR_SHORT
+ }
+ return 0
+}
+
+func ChannelStatusKnows(value uint8) bool {
+ for _, typeValue := range ChannelStatusValues {
+ if uint8(typeValue) == value {
+ return true
+ }
+ }
+ return false
+}
+
+func CastChannelStatus(structType interface{}) ChannelStatus {
+ castFunc := func(typ interface{}) ChannelStatus {
+ if sChannelStatus, ok := typ.(ChannelStatus); ok {
+ return sChannelStatus
+ }
+ return 0
+ }
+ return castFunc(structType)
+}
+
+func (m ChannelStatus) GetLengthInBits() uint16 {
+ return 8
+}
+
+func (m ChannelStatus) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func ChannelStatusParse(readBuffer utils.ReadBuffer) (ChannelStatus, error) {
+ val, err := readBuffer.ReadUint8("ChannelStatus", 8)
+ if err != nil {
+ return 0, nil
+ }
+ return ChannelStatusByValue(val), nil
+}
+
+func (e ChannelStatus) Serialize(writeBuffer utils.WriteBuffer) error {
+ return writeBuffer.WriteUint8("ChannelStatus", 8, uint8(e), utils.WithAdditionalStringRepresentation(e.name()))
+}
+
+func (e ChannelStatus) name() string {
+ switch e {
+ case ChannelStatus_OK:
+ return "OK"
+ case ChannelStatus_LAMP_FAULT:
+ return "LAMP_FAULT"
+ case ChannelStatus_CURRENT_LIMIT_OR_SHORT:
+ return "CURRENT_LIMIT_OR_SHORT"
+ }
+ return ""
+}
+
+func (e ChannelStatus) String() string {
+ return e.name()
+}
diff --git a/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommand.go b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommand.go
new file mode 100644
index 0000000..bd6da15
--- /dev/null
+++ b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommand.go
@@ -0,0 +1,197 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+ "github.com/pkg/errors"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// The data-structure of this message
+type IdentifyReplyCommand struct {
+ Child IIdentifyReplyCommandChild
+}
+
+// The corresponding interface
+type IIdentifyReplyCommand interface {
+ // Attribute returns Attribute
+ Attribute() Attribute
+ // GetLengthInBytes returns the length in bytes
+ GetLengthInBytes() uint16
+ // GetLengthInBits returns the length in bits
+ GetLengthInBits() uint16
+ // Serialize serializes this type
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+type IIdentifyReplyCommandParent interface {
+ SerializeParent(writeBuffer utils.WriteBuffer, child IIdentifyReplyCommand, serializeChildFunction func() error) error
+ GetTypeName() string
+}
+
+type IIdentifyReplyCommandChild interface {
+ Serialize(writeBuffer utils.WriteBuffer) error
+ InitializeParent(parent *IdentifyReplyCommand)
+ GetTypeName() string
+ IIdentifyReplyCommand
+}
+
+///////////////////////////////////////////////////////////
+// Accessors for property fields.
+///////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////
+// Accessors for virtual fields.
+///////////////////////////////////////////////////////////
+
+// NewIdentifyReplyCommand factory function for IdentifyReplyCommand
+func NewIdentifyReplyCommand() *IdentifyReplyCommand {
+ return &IdentifyReplyCommand{}
+}
+
+func CastIdentifyReplyCommand(structType interface{}) *IdentifyReplyCommand {
+ castFunc := func(typ interface{}) *IdentifyReplyCommand {
+ if casted, ok := typ.(IdentifyReplyCommand); ok {
+ return &casted
+ }
+ if casted, ok := typ.(*IdentifyReplyCommand); ok {
+ return casted
+ }
+ return nil
+ }
+ return castFunc(structType)
+}
+
+func (m *IdentifyReplyCommand) GetTypeName() string {
+ return "IdentifyReplyCommand"
+}
+
+func (m *IdentifyReplyCommand) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *IdentifyReplyCommand) GetLengthInBitsConditional(lastItem bool) uint16 {
+ return m.Child.GetLengthInBits()
+}
+
+func (m *IdentifyReplyCommand) GetParentLengthInBits() uint16 {
+ lengthInBits := uint16(0)
+
+ return lengthInBits
+}
+
+func (m *IdentifyReplyCommand) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func IdentifyReplyCommandParse(readBuffer utils.ReadBuffer, attribute Attribute) (*IdentifyReplyCommand, error) {
+ if pullErr := readBuffer.PullContext("IdentifyReplyCommand"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := readBuffer.GetPos()
+ _ = currentPos
+
+ // Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type)
+ var _parent *IdentifyReplyCommand
+ var typeSwitchError error
+ switch {
+ case attribute == Attribute_Manufacturer: // IdentifyReplyCommandManufacturer
+ _parent, typeSwitchError = IdentifyReplyCommandManufacturerParse(readBuffer, attribute)
+ case attribute == Attribute_Type: // IdentifyReplyCommandType
+ _parent, typeSwitchError = IdentifyReplyCommandTypeParse(readBuffer, attribute)
+ case attribute == Attribute_FirmwareVersion: // IdentifyReplyCommandFirmwareVersion
+ _parent, typeSwitchError = IdentifyReplyCommandFirmwareVersionParse(readBuffer, attribute)
+ case attribute == Attribute_Summary: // IdentifyReplyCommandFirmwareSummary
+ _parent, typeSwitchError = IdentifyReplyCommandFirmwareSummaryParse(readBuffer, attribute)
+ case attribute == Attribute_ExtendedDiagnosticSummary: // IdentifyReplyCommandExtendedDiagnosticSummary
+ _parent, typeSwitchError = IdentifyReplyCommandExtendedDiagnosticSummaryParse(readBuffer, attribute)
+ case attribute == Attribute_NetworkTerminalLevels: // IdentifyReplyCommandNetworkTerminalLevels
+ _parent, typeSwitchError = IdentifyReplyCommandNetworkTerminalLevelsParse(readBuffer, attribute)
+ case attribute == Attribute_TerminalLevel: // IdentifyReplyCommandTerminalLevels
+ _parent, typeSwitchError = IdentifyReplyCommandTerminalLevelsParse(readBuffer, attribute)
+ case attribute == Attribute_NetworkVoltage: // IdentifyReplyCommandNetworkVoltage
+ _parent, typeSwitchError = IdentifyReplyCommandNetworkVoltageParse(readBuffer, attribute)
+ case attribute == Attribute_GAVValuesCurrent: // IdentifyReplyCommandGAVValuesCurrent
+ _parent, typeSwitchError = IdentifyReplyCommandGAVValuesCurrentParse(readBuffer, attribute)
+ case attribute == Attribute_GAVValuesStored: // IdentifyReplyCommandGAVValuesStored
+ _parent, typeSwitchError = IdentifyReplyCommandGAVValuesStoredParse(readBuffer, attribute)
+ case attribute == Attribute_GAVPhysicalAddresses: // IdentifyReplyCommandGAVPhysicalAddresses
+ _parent, typeSwitchError = IdentifyReplyCommandGAVPhysicalAddressesParse(readBuffer, attribute)
+ case attribute == Attribute_LogicalAssignment: // IdentifyReplyCommandLogicalAssignment
+ _parent, typeSwitchError = IdentifyReplyCommandLogicalAssignmentParse(readBuffer, attribute)
+ case attribute == Attribute_Delays: // IdentifyReplyCommandDelays
+ _parent, typeSwitchError = IdentifyReplyCommandDelaysParse(readBuffer, attribute)
+ case attribute == Attribute_MinimumLevels: // IdentifyReplyCommandMinimumLevels
+ _parent, typeSwitchError = IdentifyReplyCommandMinimumLevelsParse(readBuffer, attribute)
+ case attribute == Attribute_MaximumLevels: // IdentifyReplyCommandMaximumLevels
+ _parent, typeSwitchError = IdentifyReplyCommandMaximumLevelsParse(readBuffer, attribute)
+ case attribute == Attribute_CurrentSenseLevels: // IdentifyReplyCommandCurrentSenseLevels
+ _parent, typeSwitchError = IdentifyReplyCommandCurrentSenseLevelsParse(readBuffer, attribute)
+ case attribute == Attribute_OutputUnitSummary: // IdentifyReplyCommandOutputUnitSummary
+ _parent, typeSwitchError = IdentifyReplyCommandOutputUnitSummaryParse(readBuffer, attribute)
+ case attribute == Attribute_DSIStatus: // IdentifyReplyCommandDSIStatus
+ _parent, typeSwitchError = IdentifyReplyCommandDSIStatusParse(readBuffer, attribute)
+ default:
+ // TODO: return actual type
+ typeSwitchError = errors.New("Unmapped type")
+ }
+ if typeSwitchError != nil {
+ return nil, errors.Wrap(typeSwitchError, "Error parsing sub-type for type-switch.")
+ }
+
+ if closeErr := readBuffer.CloseContext("IdentifyReplyCommand"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Finish initializing
+ _parent.Child.InitializeParent(_parent)
+ return _parent, nil
+}
+
+func (m *IdentifyReplyCommand) Serialize(writeBuffer utils.WriteBuffer) error {
+ return m.Child.Serialize(writeBuffer)
+}
+
+func (m *IdentifyReplyCommand) SerializeParent(writeBuffer utils.WriteBuffer, child IIdentifyReplyCommand, serializeChildFunction func() error) error {
+ if pushErr := writeBuffer.PushContext("IdentifyReplyCommand"); pushErr != nil {
+ return pushErr
+ }
+
+ // Switch field (Depending on the discriminator values, passes the serialization to a sub-type)
+ if _typeSwitchErr := serializeChildFunction(); _typeSwitchErr != nil {
+ return errors.Wrap(_typeSwitchErr, "Error serializing sub-type field")
+ }
+
+ if popErr := writeBuffer.PopContext("IdentifyReplyCommand"); popErr != nil {
+ return popErr
+ }
+ return nil
+}
+
+func (m *IdentifyReplyCommand) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ buffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ m.Serialize(buffer)
+ return buffer.GetBox().String()
+}
diff --git a/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandCurrentSenseLevels.go b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandCurrentSenseLevels.go
new file mode 100644
index 0000000..52eb200
--- /dev/null
+++ b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandCurrentSenseLevels.go
@@ -0,0 +1,150 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// The data-structure of this message
+type IdentifyReplyCommandCurrentSenseLevels struct {
+ *IdentifyReplyCommand
+}
+
+// The corresponding interface
+type IIdentifyReplyCommandCurrentSenseLevels interface {
+ // GetLengthInBytes returns the length in bytes
+ GetLengthInBytes() uint16
+ // GetLengthInBits returns the length in bits
+ GetLengthInBits() uint16
+ // Serialize serializes this type
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+///////////////////////////////////////////////////////////
+// Accessors for discriminator values.
+///////////////////////////////////////////////////////////
+func (m *IdentifyReplyCommandCurrentSenseLevels) Attribute() Attribute {
+ return Attribute_CurrentSenseLevels
+}
+
+func (m *IdentifyReplyCommandCurrentSenseLevels) GetAttribute() Attribute {
+ return Attribute_CurrentSenseLevels
+}
+
+func (m *IdentifyReplyCommandCurrentSenseLevels) InitializeParent(parent *IdentifyReplyCommand) {}
+
+///////////////////////////////////////////////////////////
+// Accessors for property fields.
+///////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////
+// Accessors for virtual fields.
+///////////////////////////////////////////////////////////
+
+// NewIdentifyReplyCommandCurrentSenseLevels factory function for IdentifyReplyCommandCurrentSenseLevels
+func NewIdentifyReplyCommandCurrentSenseLevels() *IdentifyReplyCommand {
+ child := &IdentifyReplyCommandCurrentSenseLevels{
+ IdentifyReplyCommand: NewIdentifyReplyCommand(),
+ }
+ child.Child = child
+ return child.IdentifyReplyCommand
+}
+
+func CastIdentifyReplyCommandCurrentSenseLevels(structType interface{}) *IdentifyReplyCommandCurrentSenseLevels {
+ castFunc := func(typ interface{}) *IdentifyReplyCommandCurrentSenseLevels {
+ if casted, ok := typ.(IdentifyReplyCommandCurrentSenseLevels); ok {
+ return &casted
+ }
+ if casted, ok := typ.(*IdentifyReplyCommandCurrentSenseLevels); ok {
+ return casted
+ }
+ if casted, ok := typ.(IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandCurrentSenseLevels(casted.Child)
+ }
+ if casted, ok := typ.(*IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandCurrentSenseLevels(casted.Child)
+ }
+ return nil
+ }
+ return castFunc(structType)
+}
+
+func (m *IdentifyReplyCommandCurrentSenseLevels) GetTypeName() string {
+ return "IdentifyReplyCommandCurrentSenseLevels"
+}
+
+func (m *IdentifyReplyCommandCurrentSenseLevels) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *IdentifyReplyCommandCurrentSenseLevels) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ return lengthInBits
+}
+
+func (m *IdentifyReplyCommandCurrentSenseLevels) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func IdentifyReplyCommandCurrentSenseLevelsParse(readBuffer utils.ReadBuffer, attribute Attribute) (*IdentifyReplyCommand, error) {
+ if pullErr := readBuffer.PullContext("IdentifyReplyCommandCurrentSenseLevels"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := readBuffer.GetPos()
+ _ = currentPos
+
+ if closeErr := readBuffer.CloseContext("IdentifyReplyCommandCurrentSenseLevels"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &IdentifyReplyCommandCurrentSenseLevels{
+ IdentifyReplyCommand: &IdentifyReplyCommand{},
+ }
+ _child.IdentifyReplyCommand.Child = _child
+ return _child.IdentifyReplyCommand, nil
+}
+
+func (m *IdentifyReplyCommandCurrentSenseLevels) Serialize(writeBuffer utils.WriteBuffer) error {
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("IdentifyReplyCommandCurrentSenseLevels"); pushErr != nil {
+ return pushErr
+ }
+
+ if popErr := writeBuffer.PopContext("IdentifyReplyCommandCurrentSenseLevels"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *IdentifyReplyCommandCurrentSenseLevels) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ buffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ m.Serialize(buffer)
+ return buffer.GetBox().String()
+}
diff --git a/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandDSIStatus.go b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandDSIStatus.go
new file mode 100644
index 0000000..1689313
--- /dev/null
+++ b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandDSIStatus.go
@@ -0,0 +1,509 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+ "github.com/pkg/errors"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// The data-structure of this message
+type IdentifyReplyCommandDSIStatus struct {
+ *IdentifyReplyCommand
+ ChannelStatus1 ChannelStatus
+ ChannelStatus2 ChannelStatus
+ ChannelStatus3 ChannelStatus
+ ChannelStatus4 ChannelStatus
+ ChannelStatus5 ChannelStatus
+ ChannelStatus6 ChannelStatus
+ ChannelStatus7 ChannelStatus
+ ChannelStatus8 ChannelStatus
+ UnitStatus UnitStatus
+ DimmingUCRevisionNumber byte
+}
+
+// The corresponding interface
+type IIdentifyReplyCommandDSIStatus interface {
+ // GetChannelStatus1 returns ChannelStatus1
+ GetChannelStatus1() ChannelStatus
+ // GetChannelStatus2 returns ChannelStatus2
+ GetChannelStatus2() ChannelStatus
+ // GetChannelStatus3 returns ChannelStatus3
+ GetChannelStatus3() ChannelStatus
+ // GetChannelStatus4 returns ChannelStatus4
+ GetChannelStatus4() ChannelStatus
+ // GetChannelStatus5 returns ChannelStatus5
+ GetChannelStatus5() ChannelStatus
+ // GetChannelStatus6 returns ChannelStatus6
+ GetChannelStatus6() ChannelStatus
+ // GetChannelStatus7 returns ChannelStatus7
+ GetChannelStatus7() ChannelStatus
+ // GetChannelStatus8 returns ChannelStatus8
+ GetChannelStatus8() ChannelStatus
+ // GetUnitStatus returns UnitStatus
+ GetUnitStatus() UnitStatus
+ // GetDimmingUCRevisionNumber returns DimmingUCRevisionNumber
+ GetDimmingUCRevisionNumber() byte
+ // GetLengthInBytes returns the length in bytes
+ GetLengthInBytes() uint16
+ // GetLengthInBits returns the length in bits
+ GetLengthInBits() uint16
+ // Serialize serializes this type
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+///////////////////////////////////////////////////////////
+// Accessors for discriminator values.
+///////////////////////////////////////////////////////////
+func (m *IdentifyReplyCommandDSIStatus) Attribute() Attribute {
+ return Attribute_DSIStatus
+}
+
+func (m *IdentifyReplyCommandDSIStatus) GetAttribute() Attribute {
+ return Attribute_DSIStatus
+}
+
+func (m *IdentifyReplyCommandDSIStatus) InitializeParent(parent *IdentifyReplyCommand) {}
+
+///////////////////////////////////////////////////////////
+// Accessors for property fields.
+///////////////////////////////////////////////////////////
+func (m *IdentifyReplyCommandDSIStatus) GetChannelStatus1() ChannelStatus {
+ return m.ChannelStatus1
+}
+
+func (m *IdentifyReplyCommandDSIStatus) GetChannelStatus2() ChannelStatus {
+ return m.ChannelStatus2
+}
+
+func (m *IdentifyReplyCommandDSIStatus) GetChannelStatus3() ChannelStatus {
+ return m.ChannelStatus3
+}
+
+func (m *IdentifyReplyCommandDSIStatus) GetChannelStatus4() ChannelStatus {
+ return m.ChannelStatus4
+}
+
+func (m *IdentifyReplyCommandDSIStatus) GetChannelStatus5() ChannelStatus {
+ return m.ChannelStatus5
+}
+
+func (m *IdentifyReplyCommandDSIStatus) GetChannelStatus6() ChannelStatus {
+ return m.ChannelStatus6
+}
+
+func (m *IdentifyReplyCommandDSIStatus) GetChannelStatus7() ChannelStatus {
+ return m.ChannelStatus7
+}
+
+func (m *IdentifyReplyCommandDSIStatus) GetChannelStatus8() ChannelStatus {
+ return m.ChannelStatus8
+}
+
+func (m *IdentifyReplyCommandDSIStatus) GetUnitStatus() UnitStatus {
+ return m.UnitStatus
+}
+
+func (m *IdentifyReplyCommandDSIStatus) GetDimmingUCRevisionNumber() byte {
+ return m.DimmingUCRevisionNumber
+}
+
+///////////////////////////////////////////////////////////
+// Accessors for virtual fields.
+///////////////////////////////////////////////////////////
+
+// NewIdentifyReplyCommandDSIStatus factory function for IdentifyReplyCommandDSIStatus
+func NewIdentifyReplyCommandDSIStatus(channelStatus1 ChannelStatus, channelStatus2 ChannelStatus, channelStatus3 ChannelStatus, channelStatus4 ChannelStatus, channelStatus5 ChannelStatus, channelStatus6 ChannelStatus, channelStatus7 ChannelStatus, channelStatus8 ChannelStatus, unitStatus UnitStatus, dimmingUCRevisionNumber byte) *IdentifyReplyCommand {
+ child := &IdentifyReplyCommandDSIStatus{
+ ChannelStatus1: channelStatus1,
+ ChannelStatus2: channelStatus2,
+ ChannelStatus3: channelStatus3,
+ ChannelStatus4: channelStatus4,
+ ChannelStatus5: channelStatus5,
+ ChannelStatus6: channelStatus6,
+ ChannelStatus7: channelStatus7,
+ ChannelStatus8: channelStatus8,
+ UnitStatus: unitStatus,
+ DimmingUCRevisionNumber: dimmingUCRevisionNumber,
+ IdentifyReplyCommand: NewIdentifyReplyCommand(),
+ }
+ child.Child = child
+ return child.IdentifyReplyCommand
+}
+
+func CastIdentifyReplyCommandDSIStatus(structType interface{}) *IdentifyReplyCommandDSIStatus {
+ castFunc := func(typ interface{}) *IdentifyReplyCommandDSIStatus {
+ if casted, ok := typ.(IdentifyReplyCommandDSIStatus); ok {
+ return &casted
+ }
+ if casted, ok := typ.(*IdentifyReplyCommandDSIStatus); ok {
+ return casted
+ }
+ if casted, ok := typ.(IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandDSIStatus(casted.Child)
+ }
+ if casted, ok := typ.(*IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandDSIStatus(casted.Child)
+ }
+ return nil
+ }
+ return castFunc(structType)
+}
+
+func (m *IdentifyReplyCommandDSIStatus) GetTypeName() string {
+ return "IdentifyReplyCommandDSIStatus"
+}
+
+func (m *IdentifyReplyCommandDSIStatus) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *IdentifyReplyCommandDSIStatus) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (channelStatus1)
+ lengthInBits += 8
+
+ // Simple field (channelStatus2)
+ lengthInBits += 8
+
+ // Simple field (channelStatus3)
+ lengthInBits += 8
+
+ // Simple field (channelStatus4)
+ lengthInBits += 8
+
+ // Simple field (channelStatus5)
+ lengthInBits += 8
+
+ // Simple field (channelStatus6)
+ lengthInBits += 8
+
+ // Simple field (channelStatus7)
+ lengthInBits += 8
+
+ // Simple field (channelStatus8)
+ lengthInBits += 8
+
+ // Simple field (unitStatus)
+ lengthInBits += 8
+
+ // Simple field (dimmingUCRevisionNumber)
+ lengthInBits += 8
+
+ return lengthInBits
+}
+
+func (m *IdentifyReplyCommandDSIStatus) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func IdentifyReplyCommandDSIStatusParse(readBuffer utils.ReadBuffer, attribute Attribute) (*IdentifyReplyCommand, error) {
+ if pullErr := readBuffer.PullContext("IdentifyReplyCommandDSIStatus"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := readBuffer.GetPos()
+ _ = currentPos
+
+ // Simple Field (channelStatus1)
+ if pullErr := readBuffer.PullContext("channelStatus1"); pullErr != nil {
+ return nil, pullErr
+ }
+ _channelStatus1, _channelStatus1Err := ChannelStatusParse(readBuffer)
+ if _channelStatus1Err != nil {
+ return nil, errors.Wrap(_channelStatus1Err, "Error parsing 'channelStatus1' field")
+ }
+ channelStatus1 := _channelStatus1
+ if closeErr := readBuffer.CloseContext("channelStatus1"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Simple Field (channelStatus2)
+ if pullErr := readBuffer.PullContext("channelStatus2"); pullErr != nil {
+ return nil, pullErr
+ }
+ _channelStatus2, _channelStatus2Err := ChannelStatusParse(readBuffer)
+ if _channelStatus2Err != nil {
+ return nil, errors.Wrap(_channelStatus2Err, "Error parsing 'channelStatus2' field")
+ }
+ channelStatus2 := _channelStatus2
+ if closeErr := readBuffer.CloseContext("channelStatus2"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Simple Field (channelStatus3)
+ if pullErr := readBuffer.PullContext("channelStatus3"); pullErr != nil {
+ return nil, pullErr
+ }
+ _channelStatus3, _channelStatus3Err := ChannelStatusParse(readBuffer)
+ if _channelStatus3Err != nil {
+ return nil, errors.Wrap(_channelStatus3Err, "Error parsing 'channelStatus3' field")
+ }
+ channelStatus3 := _channelStatus3
+ if closeErr := readBuffer.CloseContext("channelStatus3"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Simple Field (channelStatus4)
+ if pullErr := readBuffer.PullContext("channelStatus4"); pullErr != nil {
+ return nil, pullErr
+ }
+ _channelStatus4, _channelStatus4Err := ChannelStatusParse(readBuffer)
+ if _channelStatus4Err != nil {
+ return nil, errors.Wrap(_channelStatus4Err, "Error parsing 'channelStatus4' field")
+ }
+ channelStatus4 := _channelStatus4
+ if closeErr := readBuffer.CloseContext("channelStatus4"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Simple Field (channelStatus5)
+ if pullErr := readBuffer.PullContext("channelStatus5"); pullErr != nil {
+ return nil, pullErr
+ }
+ _channelStatus5, _channelStatus5Err := ChannelStatusParse(readBuffer)
+ if _channelStatus5Err != nil {
+ return nil, errors.Wrap(_channelStatus5Err, "Error parsing 'channelStatus5' field")
+ }
+ channelStatus5 := _channelStatus5
+ if closeErr := readBuffer.CloseContext("channelStatus5"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Simple Field (channelStatus6)
+ if pullErr := readBuffer.PullContext("channelStatus6"); pullErr != nil {
+ return nil, pullErr
+ }
+ _channelStatus6, _channelStatus6Err := ChannelStatusParse(readBuffer)
+ if _channelStatus6Err != nil {
+ return nil, errors.Wrap(_channelStatus6Err, "Error parsing 'channelStatus6' field")
+ }
+ channelStatus6 := _channelStatus6
+ if closeErr := readBuffer.CloseContext("channelStatus6"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Simple Field (channelStatus7)
+ if pullErr := readBuffer.PullContext("channelStatus7"); pullErr != nil {
+ return nil, pullErr
+ }
+ _channelStatus7, _channelStatus7Err := ChannelStatusParse(readBuffer)
+ if _channelStatus7Err != nil {
+ return nil, errors.Wrap(_channelStatus7Err, "Error parsing 'channelStatus7' field")
+ }
+ channelStatus7 := _channelStatus7
+ if closeErr := readBuffer.CloseContext("channelStatus7"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Simple Field (channelStatus8)
+ if pullErr := readBuffer.PullContext("channelStatus8"); pullErr != nil {
+ return nil, pullErr
+ }
+ _channelStatus8, _channelStatus8Err := ChannelStatusParse(readBuffer)
+ if _channelStatus8Err != nil {
+ return nil, errors.Wrap(_channelStatus8Err, "Error parsing 'channelStatus8' field")
+ }
+ channelStatus8 := _channelStatus8
+ if closeErr := readBuffer.CloseContext("channelStatus8"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Simple Field (unitStatus)
+ if pullErr := readBuffer.PullContext("unitStatus"); pullErr != nil {
+ return nil, pullErr
+ }
+ _unitStatus, _unitStatusErr := UnitStatusParse(readBuffer)
+ if _unitStatusErr != nil {
+ return nil, errors.Wrap(_unitStatusErr, "Error parsing 'unitStatus' field")
+ }
+ unitStatus := _unitStatus
+ if closeErr := readBuffer.CloseContext("unitStatus"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Simple Field (dimmingUCRevisionNumber)
+ _dimmingUCRevisionNumber, _dimmingUCRevisionNumberErr := readBuffer.ReadByte("dimmingUCRevisionNumber")
+ if _dimmingUCRevisionNumberErr != nil {
+ return nil, errors.Wrap(_dimmingUCRevisionNumberErr, "Error parsing 'dimmingUCRevisionNumber' field")
+ }
+ dimmingUCRevisionNumber := _dimmingUCRevisionNumber
+
+ if closeErr := readBuffer.CloseContext("IdentifyReplyCommandDSIStatus"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &IdentifyReplyCommandDSIStatus{
+ ChannelStatus1: channelStatus1,
+ ChannelStatus2: channelStatus2,
+ ChannelStatus3: channelStatus3,
+ ChannelStatus4: channelStatus4,
+ ChannelStatus5: channelStatus5,
+ ChannelStatus6: channelStatus6,
+ ChannelStatus7: channelStatus7,
+ ChannelStatus8: channelStatus8,
+ UnitStatus: unitStatus,
+ DimmingUCRevisionNumber: dimmingUCRevisionNumber,
+ IdentifyReplyCommand: &IdentifyReplyCommand{},
+ }
+ _child.IdentifyReplyCommand.Child = _child
+ return _child.IdentifyReplyCommand, nil
+}
+
+func (m *IdentifyReplyCommandDSIStatus) Serialize(writeBuffer utils.WriteBuffer) error {
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("IdentifyReplyCommandDSIStatus"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (channelStatus1)
+ if pushErr := writeBuffer.PushContext("channelStatus1"); pushErr != nil {
+ return pushErr
+ }
+ _channelStatus1Err := m.ChannelStatus1.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("channelStatus1"); popErr != nil {
+ return popErr
+ }
+ if _channelStatus1Err != nil {
+ return errors.Wrap(_channelStatus1Err, "Error serializing 'channelStatus1' field")
+ }
+
+ // Simple Field (channelStatus2)
+ if pushErr := writeBuffer.PushContext("channelStatus2"); pushErr != nil {
+ return pushErr
+ }
+ _channelStatus2Err := m.ChannelStatus2.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("channelStatus2"); popErr != nil {
+ return popErr
+ }
+ if _channelStatus2Err != nil {
+ return errors.Wrap(_channelStatus2Err, "Error serializing 'channelStatus2' field")
+ }
+
+ // Simple Field (channelStatus3)
+ if pushErr := writeBuffer.PushContext("channelStatus3"); pushErr != nil {
+ return pushErr
+ }
+ _channelStatus3Err := m.ChannelStatus3.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("channelStatus3"); popErr != nil {
+ return popErr
+ }
+ if _channelStatus3Err != nil {
+ return errors.Wrap(_channelStatus3Err, "Error serializing 'channelStatus3' field")
+ }
+
+ // Simple Field (channelStatus4)
+ if pushErr := writeBuffer.PushContext("channelStatus4"); pushErr != nil {
+ return pushErr
+ }
+ _channelStatus4Err := m.ChannelStatus4.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("channelStatus4"); popErr != nil {
+ return popErr
+ }
+ if _channelStatus4Err != nil {
+ return errors.Wrap(_channelStatus4Err, "Error serializing 'channelStatus4' field")
+ }
+
+ // Simple Field (channelStatus5)
+ if pushErr := writeBuffer.PushContext("channelStatus5"); pushErr != nil {
+ return pushErr
+ }
+ _channelStatus5Err := m.ChannelStatus5.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("channelStatus5"); popErr != nil {
+ return popErr
+ }
+ if _channelStatus5Err != nil {
+ return errors.Wrap(_channelStatus5Err, "Error serializing 'channelStatus5' field")
+ }
+
+ // Simple Field (channelStatus6)
+ if pushErr := writeBuffer.PushContext("channelStatus6"); pushErr != nil {
+ return pushErr
+ }
+ _channelStatus6Err := m.ChannelStatus6.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("channelStatus6"); popErr != nil {
+ return popErr
+ }
+ if _channelStatus6Err != nil {
+ return errors.Wrap(_channelStatus6Err, "Error serializing 'channelStatus6' field")
+ }
+
+ // Simple Field (channelStatus7)
+ if pushErr := writeBuffer.PushContext("channelStatus7"); pushErr != nil {
+ return pushErr
+ }
+ _channelStatus7Err := m.ChannelStatus7.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("channelStatus7"); popErr != nil {
+ return popErr
+ }
+ if _channelStatus7Err != nil {
+ return errors.Wrap(_channelStatus7Err, "Error serializing 'channelStatus7' field")
+ }
+
+ // Simple Field (channelStatus8)
+ if pushErr := writeBuffer.PushContext("channelStatus8"); pushErr != nil {
+ return pushErr
+ }
+ _channelStatus8Err := m.ChannelStatus8.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("channelStatus8"); popErr != nil {
+ return popErr
+ }
+ if _channelStatus8Err != nil {
+ return errors.Wrap(_channelStatus8Err, "Error serializing 'channelStatus8' field")
+ }
+
+ // Simple Field (unitStatus)
+ if pushErr := writeBuffer.PushContext("unitStatus"); pushErr != nil {
+ return pushErr
+ }
+ _unitStatusErr := m.UnitStatus.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("unitStatus"); popErr != nil {
+ return popErr
+ }
+ if _unitStatusErr != nil {
+ return errors.Wrap(_unitStatusErr, "Error serializing 'unitStatus' field")
+ }
+
+ // Simple Field (dimmingUCRevisionNumber)
+ dimmingUCRevisionNumber := byte(m.DimmingUCRevisionNumber)
+ _dimmingUCRevisionNumberErr := writeBuffer.WriteByte("dimmingUCRevisionNumber", (dimmingUCRevisionNumber))
+ if _dimmingUCRevisionNumberErr != nil {
+ return errors.Wrap(_dimmingUCRevisionNumberErr, "Error serializing 'dimmingUCRevisionNumber' field")
+ }
+
+ if popErr := writeBuffer.PopContext("IdentifyReplyCommandDSIStatus"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *IdentifyReplyCommandDSIStatus) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ buffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ m.Serialize(buffer)
+ return buffer.GetBox().String()
+}
diff --git a/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandDelays.go b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandDelays.go
new file mode 100644
index 0000000..cdc8c7f
--- /dev/null
+++ b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandDelays.go
@@ -0,0 +1,150 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// The data-structure of this message
+type IdentifyReplyCommandDelays struct {
+ *IdentifyReplyCommand
+}
+
+// The corresponding interface
+type IIdentifyReplyCommandDelays interface {
+ // GetLengthInBytes returns the length in bytes
+ GetLengthInBytes() uint16
+ // GetLengthInBits returns the length in bits
+ GetLengthInBits() uint16
+ // Serialize serializes this type
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+///////////////////////////////////////////////////////////
+// Accessors for discriminator values.
+///////////////////////////////////////////////////////////
+func (m *IdentifyReplyCommandDelays) Attribute() Attribute {
+ return Attribute_Delays
+}
+
+func (m *IdentifyReplyCommandDelays) GetAttribute() Attribute {
+ return Attribute_Delays
+}
+
+func (m *IdentifyReplyCommandDelays) InitializeParent(parent *IdentifyReplyCommand) {}
+
+///////////////////////////////////////////////////////////
+// Accessors for property fields.
+///////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////
+// Accessors for virtual fields.
+///////////////////////////////////////////////////////////
+
+// NewIdentifyReplyCommandDelays factory function for IdentifyReplyCommandDelays
+func NewIdentifyReplyCommandDelays() *IdentifyReplyCommand {
+ child := &IdentifyReplyCommandDelays{
+ IdentifyReplyCommand: NewIdentifyReplyCommand(),
+ }
+ child.Child = child
+ return child.IdentifyReplyCommand
+}
+
+func CastIdentifyReplyCommandDelays(structType interface{}) *IdentifyReplyCommandDelays {
+ castFunc := func(typ interface{}) *IdentifyReplyCommandDelays {
+ if casted, ok := typ.(IdentifyReplyCommandDelays); ok {
+ return &casted
+ }
+ if casted, ok := typ.(*IdentifyReplyCommandDelays); ok {
+ return casted
+ }
+ if casted, ok := typ.(IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandDelays(casted.Child)
+ }
+ if casted, ok := typ.(*IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandDelays(casted.Child)
+ }
+ return nil
+ }
+ return castFunc(structType)
+}
+
+func (m *IdentifyReplyCommandDelays) GetTypeName() string {
+ return "IdentifyReplyCommandDelays"
+}
+
+func (m *IdentifyReplyCommandDelays) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *IdentifyReplyCommandDelays) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ return lengthInBits
+}
+
+func (m *IdentifyReplyCommandDelays) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func IdentifyReplyCommandDelaysParse(readBuffer utils.ReadBuffer, attribute Attribute) (*IdentifyReplyCommand, error) {
+ if pullErr := readBuffer.PullContext("IdentifyReplyCommandDelays"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := readBuffer.GetPos()
+ _ = currentPos
+
+ if closeErr := readBuffer.CloseContext("IdentifyReplyCommandDelays"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &IdentifyReplyCommandDelays{
+ IdentifyReplyCommand: &IdentifyReplyCommand{},
+ }
+ _child.IdentifyReplyCommand.Child = _child
+ return _child.IdentifyReplyCommand, nil
+}
+
+func (m *IdentifyReplyCommandDelays) Serialize(writeBuffer utils.WriteBuffer) error {
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("IdentifyReplyCommandDelays"); pushErr != nil {
+ return pushErr
+ }
+
+ if popErr := writeBuffer.PopContext("IdentifyReplyCommandDelays"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *IdentifyReplyCommandDelays) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ buffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ m.Serialize(buffer)
+ return buffer.GetBox().String()
+}
diff --git a/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandExtendedDiagnosticSummary.go b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandExtendedDiagnosticSummary.go
new file mode 100644
index 0000000..8628b99
--- /dev/null
+++ b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandExtendedDiagnosticSummary.go
@@ -0,0 +1,743 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+ "github.com/pkg/errors"
+ "github.com/rs/zerolog/log"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// The data-structure of this message
+type IdentifyReplyCommandExtendedDiagnosticSummary struct {
+ *IdentifyReplyCommand
+ LowApplication *Application
+ HighApplication *Application
+ Area byte
+ Crc uint16
+ SerialNumber uint32
+ NetworkVoltage byte
+ OutputUnit bool
+ EnableChecksumAlarm bool
+ NetworkVoltageMarginal bool
+ NetworkVoltageLow bool
+ UnitInLearnMode bool
+ MicroPowerReset bool
+ InternalStackOverflow bool
+ CommsTxError bool
+ MicroReset bool
+ EEDataError bool
+ EEChecksumError bool
+ EEWriteError bool
+ InstallationMMIError bool
+}
+
+// The corresponding interface
+type IIdentifyReplyCommandExtendedDiagnosticSummary interface {
+ // GetLowApplication returns LowApplication
+ GetLowApplication() *Application
+ // GetHighApplication returns HighApplication
+ GetHighApplication() *Application
+ // GetArea returns Area
+ GetArea() byte
+ // GetCrc returns Crc
+ GetCrc() uint16
+ // GetSerialNumber returns SerialNumber
+ GetSerialNumber() uint32
+ // GetNetworkVoltage returns NetworkVoltage
+ GetNetworkVoltage() byte
+ // GetOutputUnit returns OutputUnit
+ GetOutputUnit() bool
+ // GetEnableChecksumAlarm returns EnableChecksumAlarm
+ GetEnableChecksumAlarm() bool
+ // GetNetworkVoltageMarginal returns NetworkVoltageMarginal
+ GetNetworkVoltageMarginal() bool
+ // GetNetworkVoltageLow returns NetworkVoltageLow
+ GetNetworkVoltageLow() bool
+ // GetUnitInLearnMode returns UnitInLearnMode
+ GetUnitInLearnMode() bool
+ // GetMicroPowerReset returns MicroPowerReset
+ GetMicroPowerReset() bool
+ // GetInternalStackOverflow returns InternalStackOverflow
+ GetInternalStackOverflow() bool
+ // GetCommsTxError returns CommsTxError
+ GetCommsTxError() bool
+ // GetMicroReset returns MicroReset
+ GetMicroReset() bool
+ // GetEEDataError returns EEDataError
+ GetEEDataError() bool
+ // GetEEChecksumError returns EEChecksumError
+ GetEEChecksumError() bool
+ // GetEEWriteError returns EEWriteError
+ GetEEWriteError() bool
+ // GetInstallationMMIError returns InstallationMMIError
+ GetInstallationMMIError() bool
+ // GetLengthInBytes returns the length in bytes
+ GetLengthInBytes() uint16
+ // GetLengthInBits returns the length in bits
+ GetLengthInBits() uint16
+ // Serialize serializes this type
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+///////////////////////////////////////////////////////////
+// Accessors for discriminator values.
+///////////////////////////////////////////////////////////
+func (m *IdentifyReplyCommandExtendedDiagnosticSummary) Attribute() Attribute {
+ return Attribute_ExtendedDiagnosticSummary
+}
+
+func (m *IdentifyReplyCommandExtendedDiagnosticSummary) GetAttribute() Attribute {
+ return Attribute_ExtendedDiagnosticSummary
+}
+
+func (m *IdentifyReplyCommandExtendedDiagnosticSummary) InitializeParent(parent *IdentifyReplyCommand) {
+}
+
+///////////////////////////////////////////////////////////
+// Accessors for property fields.
+///////////////////////////////////////////////////////////
+func (m *IdentifyReplyCommandExtendedDiagnosticSummary) GetLowApplication() *Application {
+ return m.LowApplication
+}
+
+func (m *IdentifyReplyCommandExtendedDiagnosticSummary) GetHighApplication() *Application {
+ return m.HighApplication
+}
+
+func (m *IdentifyReplyCommandExtendedDiagnosticSummary) GetArea() byte {
+ return m.Area
+}
+
+func (m *IdentifyReplyCommandExtendedDiagnosticSummary) GetCrc() uint16 {
+ return m.Crc
+}
+
+func (m *IdentifyReplyCommandExtendedDiagnosticSummary) GetSerialNumber() uint32 {
+ return m.SerialNumber
+}
+
+func (m *IdentifyReplyCommandExtendedDiagnosticSummary) GetNetworkVoltage() byte {
+ return m.NetworkVoltage
+}
+
+func (m *IdentifyReplyCommandExtendedDiagnosticSummary) GetOutputUnit() bool {
+ return m.OutputUnit
+}
+
+func (m *IdentifyReplyCommandExtendedDiagnosticSummary) GetEnableChecksumAlarm() bool {
+ return m.EnableChecksumAlarm
+}
+
+func (m *IdentifyReplyCommandExtendedDiagnosticSummary) GetNetworkVoltageMarginal() bool {
+ return m.NetworkVoltageMarginal
+}
+
+func (m *IdentifyReplyCommandExtendedDiagnosticSummary) GetNetworkVoltageLow() bool {
+ return m.NetworkVoltageLow
+}
+
+func (m *IdentifyReplyCommandExtendedDiagnosticSummary) GetUnitInLearnMode() bool {
+ return m.UnitInLearnMode
+}
+
+func (m *IdentifyReplyCommandExtendedDiagnosticSummary) GetMicroPowerReset() bool {
+ return m.MicroPowerReset
+}
+
+func (m *IdentifyReplyCommandExtendedDiagnosticSummary) GetInternalStackOverflow() bool {
+ return m.InternalStackOverflow
+}
+
+func (m *IdentifyReplyCommandExtendedDiagnosticSummary) GetCommsTxError() bool {
+ return m.CommsTxError
+}
+
+func (m *IdentifyReplyCommandExtendedDiagnosticSummary) GetMicroReset() bool {
+ return m.MicroReset
+}
+
+func (m *IdentifyReplyCommandExtendedDiagnosticSummary) GetEEDataError() bool {
+ return m.EEDataError
+}
+
+func (m *IdentifyReplyCommandExtendedDiagnosticSummary) GetEEChecksumError() bool {
+ return m.EEChecksumError
+}
+
+func (m *IdentifyReplyCommandExtendedDiagnosticSummary) GetEEWriteError() bool {
+ return m.EEWriteError
+}
+
+func (m *IdentifyReplyCommandExtendedDiagnosticSummary) GetInstallationMMIError() bool {
+ return m.InstallationMMIError
+}
+
+///////////////////////////////////////////////////////////
+// Accessors for virtual fields.
+///////////////////////////////////////////////////////////
+
+// NewIdentifyReplyCommandExtendedDiagnosticSummary factory function for IdentifyReplyCommandExtendedDiagnosticSummary
+func NewIdentifyReplyCommandExtendedDiagnosticSummary(lowApplication *Application, highApplication *Application, area byte, crc uint16, serialNumber uint32, networkVoltage byte, outputUnit bool, enableChecksumAlarm bool, networkVoltageMarginal bool, networkVoltageLow bool, unitInLearnMode bool, microPowerReset bool, internalStackOverflow bool, commsTxError bool, microReset bool, EEDataError bool, EEChecksumError bool, EEWriteError bool, installationMMIError bool) *IdentifyReplyCommand {
+ child := &IdentifyReplyCommandExtendedDiagnosticSummary{
+ LowApplication: lowApplication,
+ HighApplication: highApplication,
+ Area: area,
+ Crc: crc,
+ SerialNumber: serialNumber,
+ NetworkVoltage: networkVoltage,
+ OutputUnit: outputUnit,
+ EnableChecksumAlarm: enableChecksumAlarm,
+ NetworkVoltageMarginal: networkVoltageMarginal,
+ NetworkVoltageLow: networkVoltageLow,
+ UnitInLearnMode: unitInLearnMode,
+ MicroPowerReset: microPowerReset,
+ InternalStackOverflow: internalStackOverflow,
+ CommsTxError: commsTxError,
+ MicroReset: microReset,
+ EEDataError: EEDataError,
+ EEChecksumError: EEChecksumError,
+ EEWriteError: EEWriteError,
+ InstallationMMIError: installationMMIError,
+ IdentifyReplyCommand: NewIdentifyReplyCommand(),
+ }
+ child.Child = child
+ return child.IdentifyReplyCommand
+}
+
+func CastIdentifyReplyCommandExtendedDiagnosticSummary(structType interface{}) *IdentifyReplyCommandExtendedDiagnosticSummary {
+ castFunc := func(typ interface{}) *IdentifyReplyCommandExtendedDiagnosticSummary {
+ if casted, ok := typ.(IdentifyReplyCommandExtendedDiagnosticSummary); ok {
+ return &casted
+ }
+ if casted, ok := typ.(*IdentifyReplyCommandExtendedDiagnosticSummary); ok {
+ return casted
+ }
+ if casted, ok := typ.(IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandExtendedDiagnosticSummary(casted.Child)
+ }
+ if casted, ok := typ.(*IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandExtendedDiagnosticSummary(casted.Child)
+ }
+ return nil
+ }
+ return castFunc(structType)
+}
+
+func (m *IdentifyReplyCommandExtendedDiagnosticSummary) GetTypeName() string {
+ return "IdentifyReplyCommandExtendedDiagnosticSummary"
+}
+
+func (m *IdentifyReplyCommandExtendedDiagnosticSummary) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *IdentifyReplyCommandExtendedDiagnosticSummary) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (lowApplication)
+ lengthInBits += m.LowApplication.GetLengthInBits()
+
+ // Simple field (highApplication)
+ lengthInBits += m.HighApplication.GetLengthInBits()
+
+ // Simple field (area)
+ lengthInBits += 8
+
+ // Simple field (crc)
+ lengthInBits += 16
+
+ // Simple field (serialNumber)
+ lengthInBits += 32
+
+ // Simple field (networkVoltage)
+ lengthInBits += 8
+
+ // Simple field (outputUnit)
+ lengthInBits += 1
+
+ // Simple field (enableChecksumAlarm)
+ lengthInBits += 1
+
+ // Reserved Field (reserved)
+ lengthInBits += 1
+
+ // Reserved Field (reserved)
+ lengthInBits += 1
+
+ // Reserved Field (reserved)
+ lengthInBits += 1
+
+ // Simple field (networkVoltageMarginal)
+ lengthInBits += 1
+
+ // Simple field (networkVoltageLow)
+ lengthInBits += 1
+
+ // Simple field (unitInLearnMode)
+ lengthInBits += 1
+
+ // Simple field (microPowerReset)
+ lengthInBits += 1
+
+ // Simple field (internalStackOverflow)
+ lengthInBits += 1
+
+ // Simple field (commsTxError)
+ lengthInBits += 1
+
+ // Simple field (microReset)
+ lengthInBits += 1
+
+ // Simple field (EEDataError)
+ lengthInBits += 1
+
+ // Simple field (EEChecksumError)
+ lengthInBits += 1
+
+ // Simple field (EEWriteError)
+ lengthInBits += 1
+
+ // Simple field (installationMMIError)
+ lengthInBits += 1
+
+ return lengthInBits
+}
+
+func (m *IdentifyReplyCommandExtendedDiagnosticSummary) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func IdentifyReplyCommandExtendedDiagnosticSummaryParse(readBuffer utils.ReadBuffer, attribute Attribute) (*IdentifyReplyCommand, error) {
+ if pullErr := readBuffer.PullContext("IdentifyReplyCommandExtendedDiagnosticSummary"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := readBuffer.GetPos()
+ _ = currentPos
+
+ // Simple Field (lowApplication)
+ if pullErr := readBuffer.PullContext("lowApplication"); pullErr != nil {
+ return nil, pullErr
+ }
+ _lowApplication, _lowApplicationErr := ApplicationParse(readBuffer)
+ if _lowApplicationErr != nil {
+ return nil, errors.Wrap(_lowApplicationErr, "Error parsing 'lowApplication' field")
+ }
+ lowApplication := CastApplication(_lowApplication)
+ if closeErr := readBuffer.CloseContext("lowApplication"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Simple Field (highApplication)
+ if pullErr := readBuffer.PullContext("highApplication"); pullErr != nil {
+ return nil, pullErr
+ }
+ _highApplication, _highApplicationErr := ApplicationParse(readBuffer)
+ if _highApplicationErr != nil {
+ return nil, errors.Wrap(_highApplicationErr, "Error parsing 'highApplication' field")
+ }
+ highApplication := CastApplication(_highApplication)
+ if closeErr := readBuffer.CloseContext("highApplication"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Simple Field (area)
+ _area, _areaErr := readBuffer.ReadByte("area")
+ if _areaErr != nil {
+ return nil, errors.Wrap(_areaErr, "Error parsing 'area' field")
+ }
+ area := _area
+
+ // Simple Field (crc)
+ _crc, _crcErr := readBuffer.ReadUint16("crc", 16)
+ if _crcErr != nil {
+ return nil, errors.Wrap(_crcErr, "Error parsing 'crc' field")
+ }
+ crc := _crc
+
+ // Simple Field (serialNumber)
+ _serialNumber, _serialNumberErr := readBuffer.ReadUint32("serialNumber", 32)
+ if _serialNumberErr != nil {
+ return nil, errors.Wrap(_serialNumberErr, "Error parsing 'serialNumber' field")
+ }
+ serialNumber := _serialNumber
+
+ // Simple Field (networkVoltage)
+ _networkVoltage, _networkVoltageErr := readBuffer.ReadByte("networkVoltage")
+ if _networkVoltageErr != nil {
+ return nil, errors.Wrap(_networkVoltageErr, "Error parsing 'networkVoltage' field")
+ }
+ networkVoltage := _networkVoltage
+
+ // Simple Field (outputUnit)
+ _outputUnit, _outputUnitErr := readBuffer.ReadBit("outputUnit")
+ if _outputUnitErr != nil {
+ return nil, errors.Wrap(_outputUnitErr, "Error parsing 'outputUnit' field")
+ }
+ outputUnit := _outputUnit
+
+ // Simple Field (enableChecksumAlarm)
+ _enableChecksumAlarm, _enableChecksumAlarmErr := readBuffer.ReadBit("enableChecksumAlarm")
+ if _enableChecksumAlarmErr != nil {
+ return nil, errors.Wrap(_enableChecksumAlarmErr, "Error parsing 'enableChecksumAlarm' field")
+ }
+ enableChecksumAlarm := _enableChecksumAlarm
+
+ // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
+ {
+ reserved, _err := readBuffer.ReadUint8("reserved", 1)
+ if _err != nil {
+ return nil, errors.Wrap(_err, "Error parsing 'reserved' field")
+ }
+ if reserved != uint8(0) {
+ log.Info().Fields(map[string]interface{}{
+ "expected value": uint8(0),
+ "got value": reserved,
+ }).Msg("Got unexpected response.")
+ }
+ }
+
+ // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
+ {
+ reserved, _err := readBuffer.ReadUint8("reserved", 1)
+ if _err != nil {
+ return nil, errors.Wrap(_err, "Error parsing 'reserved' field")
+ }
+ if reserved != uint8(0) {
+ log.Info().Fields(map[string]interface{}{
+ "expected value": uint8(0),
+ "got value": reserved,
+ }).Msg("Got unexpected response.")
+ }
+ }
+
+ // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
+ {
+ reserved, _err := readBuffer.ReadUint8("reserved", 1)
+ if _err != nil {
+ return nil, errors.Wrap(_err, "Error parsing 'reserved' field")
+ }
+ if reserved != uint8(0) {
+ log.Info().Fields(map[string]interface{}{
+ "expected value": uint8(0),
+ "got value": reserved,
+ }).Msg("Got unexpected response.")
+ }
+ }
+
+ // Simple Field (networkVoltageMarginal)
+ _networkVoltageMarginal, _networkVoltageMarginalErr := readBuffer.ReadBit("networkVoltageMarginal")
+ if _networkVoltageMarginalErr != nil {
+ return nil, errors.Wrap(_networkVoltageMarginalErr, "Error parsing 'networkVoltageMarginal' field")
+ }
+ networkVoltageMarginal := _networkVoltageMarginal
+
+ // Simple Field (networkVoltageLow)
+ _networkVoltageLow, _networkVoltageLowErr := readBuffer.ReadBit("networkVoltageLow")
+ if _networkVoltageLowErr != nil {
+ return nil, errors.Wrap(_networkVoltageLowErr, "Error parsing 'networkVoltageLow' field")
+ }
+ networkVoltageLow := _networkVoltageLow
+
+ // Simple Field (unitInLearnMode)
+ _unitInLearnMode, _unitInLearnModeErr := readBuffer.ReadBit("unitInLearnMode")
+ if _unitInLearnModeErr != nil {
+ return nil, errors.Wrap(_unitInLearnModeErr, "Error parsing 'unitInLearnMode' field")
+ }
+ unitInLearnMode := _unitInLearnMode
+
+ // Simple Field (microPowerReset)
+ _microPowerReset, _microPowerResetErr := readBuffer.ReadBit("microPowerReset")
+ if _microPowerResetErr != nil {
+ return nil, errors.Wrap(_microPowerResetErr, "Error parsing 'microPowerReset' field")
+ }
+ microPowerReset := _microPowerReset
+
+ // Simple Field (internalStackOverflow)
+ _internalStackOverflow, _internalStackOverflowErr := readBuffer.ReadBit("internalStackOverflow")
+ if _internalStackOverflowErr != nil {
+ return nil, errors.Wrap(_internalStackOverflowErr, "Error parsing 'internalStackOverflow' field")
+ }
+ internalStackOverflow := _internalStackOverflow
+
+ // Simple Field (commsTxError)
+ _commsTxError, _commsTxErrorErr := readBuffer.ReadBit("commsTxError")
+ if _commsTxErrorErr != nil {
+ return nil, errors.Wrap(_commsTxErrorErr, "Error parsing 'commsTxError' field")
+ }
+ commsTxError := _commsTxError
+
+ // Simple Field (microReset)
+ _microReset, _microResetErr := readBuffer.ReadBit("microReset")
+ if _microResetErr != nil {
+ return nil, errors.Wrap(_microResetErr, "Error parsing 'microReset' field")
+ }
+ microReset := _microReset
+
+ // Simple Field (EEDataError)
+ _EEDataError, _EEDataErrorErr := readBuffer.ReadBit("EEDataError")
+ if _EEDataErrorErr != nil {
+ return nil, errors.Wrap(_EEDataErrorErr, "Error parsing 'EEDataError' field")
+ }
+ EEDataError := _EEDataError
+
+ // Simple Field (EEChecksumError)
+ _EEChecksumError, _EEChecksumErrorErr := readBuffer.ReadBit("EEChecksumError")
+ if _EEChecksumErrorErr != nil {
+ return nil, errors.Wrap(_EEChecksumErrorErr, "Error parsing 'EEChecksumError' field")
+ }
+ EEChecksumError := _EEChecksumError
+
+ // Simple Field (EEWriteError)
+ _EEWriteError, _EEWriteErrorErr := readBuffer.ReadBit("EEWriteError")
+ if _EEWriteErrorErr != nil {
+ return nil, errors.Wrap(_EEWriteErrorErr, "Error parsing 'EEWriteError' field")
+ }
+ EEWriteError := _EEWriteError
+
+ // Simple Field (installationMMIError)
+ _installationMMIError, _installationMMIErrorErr := readBuffer.ReadBit("installationMMIError")
+ if _installationMMIErrorErr != nil {
+ return nil, errors.Wrap(_installationMMIErrorErr, "Error parsing 'installationMMIError' field")
+ }
+ installationMMIError := _installationMMIError
+
+ if closeErr := readBuffer.CloseContext("IdentifyReplyCommandExtendedDiagnosticSummary"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &IdentifyReplyCommandExtendedDiagnosticSummary{
+ LowApplication: CastApplication(lowApplication),
+ HighApplication: CastApplication(highApplication),
+ Area: area,
+ Crc: crc,
+ SerialNumber: serialNumber,
+ NetworkVoltage: networkVoltage,
+ OutputUnit: outputUnit,
+ EnableChecksumAlarm: enableChecksumAlarm,
+ NetworkVoltageMarginal: networkVoltageMarginal,
+ NetworkVoltageLow: networkVoltageLow,
+ UnitInLearnMode: unitInLearnMode,
+ MicroPowerReset: microPowerReset,
+ InternalStackOverflow: internalStackOverflow,
+ CommsTxError: commsTxError,
+ MicroReset: microReset,
+ EEDataError: EEDataError,
+ EEChecksumError: EEChecksumError,
+ EEWriteError: EEWriteError,
+ InstallationMMIError: installationMMIError,
+ IdentifyReplyCommand: &IdentifyReplyCommand{},
+ }
+ _child.IdentifyReplyCommand.Child = _child
+ return _child.IdentifyReplyCommand, nil
+}
+
+func (m *IdentifyReplyCommandExtendedDiagnosticSummary) Serialize(writeBuffer utils.WriteBuffer) error {
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("IdentifyReplyCommandExtendedDiagnosticSummary"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (lowApplication)
+ if pushErr := writeBuffer.PushContext("lowApplication"); pushErr != nil {
+ return pushErr
+ }
+ _lowApplicationErr := m.LowApplication.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("lowApplication"); popErr != nil {
+ return popErr
+ }
+ if _lowApplicationErr != nil {
+ return errors.Wrap(_lowApplicationErr, "Error serializing 'lowApplication' field")
+ }
+
+ // Simple Field (highApplication)
+ if pushErr := writeBuffer.PushContext("highApplication"); pushErr != nil {
+ return pushErr
+ }
+ _highApplicationErr := m.HighApplication.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("highApplication"); popErr != nil {
+ return popErr
+ }
+ if _highApplicationErr != nil {
+ return errors.Wrap(_highApplicationErr, "Error serializing 'highApplication' field")
+ }
+
+ // Simple Field (area)
+ area := byte(m.Area)
+ _areaErr := writeBuffer.WriteByte("area", (area))
+ if _areaErr != nil {
+ return errors.Wrap(_areaErr, "Error serializing 'area' field")
+ }
+
+ // Simple Field (crc)
+ crc := uint16(m.Crc)
+ _crcErr := writeBuffer.WriteUint16("crc", 16, (crc))
+ if _crcErr != nil {
+ return errors.Wrap(_crcErr, "Error serializing 'crc' field")
+ }
+
+ // Simple Field (serialNumber)
+ serialNumber := uint32(m.SerialNumber)
+ _serialNumberErr := writeBuffer.WriteUint32("serialNumber", 32, (serialNumber))
+ if _serialNumberErr != nil {
+ return errors.Wrap(_serialNumberErr, "Error serializing 'serialNumber' field")
+ }
+
+ // Simple Field (networkVoltage)
+ networkVoltage := byte(m.NetworkVoltage)
+ _networkVoltageErr := writeBuffer.WriteByte("networkVoltage", (networkVoltage))
+ if _networkVoltageErr != nil {
+ return errors.Wrap(_networkVoltageErr, "Error serializing 'networkVoltage' field")
+ }
+
+ // Simple Field (outputUnit)
+ outputUnit := bool(m.OutputUnit)
+ _outputUnitErr := writeBuffer.WriteBit("outputUnit", (outputUnit))
+ if _outputUnitErr != nil {
+ return errors.Wrap(_outputUnitErr, "Error serializing 'outputUnit' field")
+ }
+
+ // Simple Field (enableChecksumAlarm)
+ enableChecksumAlarm := bool(m.EnableChecksumAlarm)
+ _enableChecksumAlarmErr := writeBuffer.WriteBit("enableChecksumAlarm", (enableChecksumAlarm))
+ if _enableChecksumAlarmErr != nil {
+ return errors.Wrap(_enableChecksumAlarmErr, "Error serializing 'enableChecksumAlarm' field")
+ }
+
+ // Reserved Field (reserved)
+ {
+ _err := writeBuffer.WriteUint8("reserved", 1, uint8(0))
+ if _err != nil {
+ return errors.Wrap(_err, "Error serializing 'reserved' field")
+ }
+ }
+
+ // Reserved Field (reserved)
+ {
+ _err := writeBuffer.WriteUint8("reserved", 1, uint8(0))
+ if _err != nil {
+ return errors.Wrap(_err, "Error serializing 'reserved' field")
+ }
+ }
+
+ // Reserved Field (reserved)
+ {
+ _err := writeBuffer.WriteUint8("reserved", 1, uint8(0))
+ if _err != nil {
+ return errors.Wrap(_err, "Error serializing 'reserved' field")
+ }
+ }
+
+ // Simple Field (networkVoltageMarginal)
+ networkVoltageMarginal := bool(m.NetworkVoltageMarginal)
+ _networkVoltageMarginalErr := writeBuffer.WriteBit("networkVoltageMarginal", (networkVoltageMarginal))
+ if _networkVoltageMarginalErr != nil {
+ return errors.Wrap(_networkVoltageMarginalErr, "Error serializing 'networkVoltageMarginal' field")
+ }
+
+ // Simple Field (networkVoltageLow)
+ networkVoltageLow := bool(m.NetworkVoltageLow)
+ _networkVoltageLowErr := writeBuffer.WriteBit("networkVoltageLow", (networkVoltageLow))
+ if _networkVoltageLowErr != nil {
+ return errors.Wrap(_networkVoltageLowErr, "Error serializing 'networkVoltageLow' field")
+ }
+
+ // Simple Field (unitInLearnMode)
+ unitInLearnMode := bool(m.UnitInLearnMode)
+ _unitInLearnModeErr := writeBuffer.WriteBit("unitInLearnMode", (unitInLearnMode))
+ if _unitInLearnModeErr != nil {
+ return errors.Wrap(_unitInLearnModeErr, "Error serializing 'unitInLearnMode' field")
+ }
+
+ // Simple Field (microPowerReset)
+ microPowerReset := bool(m.MicroPowerReset)
+ _microPowerResetErr := writeBuffer.WriteBit("microPowerReset", (microPowerReset))
+ if _microPowerResetErr != nil {
+ return errors.Wrap(_microPowerResetErr, "Error serializing 'microPowerReset' field")
+ }
+
+ // Simple Field (internalStackOverflow)
+ internalStackOverflow := bool(m.InternalStackOverflow)
+ _internalStackOverflowErr := writeBuffer.WriteBit("internalStackOverflow", (internalStackOverflow))
+ if _internalStackOverflowErr != nil {
+ return errors.Wrap(_internalStackOverflowErr, "Error serializing 'internalStackOverflow' field")
+ }
+
+ // Simple Field (commsTxError)
+ commsTxError := bool(m.CommsTxError)
+ _commsTxErrorErr := writeBuffer.WriteBit("commsTxError", (commsTxError))
+ if _commsTxErrorErr != nil {
+ return errors.Wrap(_commsTxErrorErr, "Error serializing 'commsTxError' field")
+ }
+
+ // Simple Field (microReset)
+ microReset := bool(m.MicroReset)
+ _microResetErr := writeBuffer.WriteBit("microReset", (microReset))
+ if _microResetErr != nil {
+ return errors.Wrap(_microResetErr, "Error serializing 'microReset' field")
+ }
+
+ // Simple Field (EEDataError)
+ EEDataError := bool(m.EEDataError)
+ _EEDataErrorErr := writeBuffer.WriteBit("EEDataError", (EEDataError))
+ if _EEDataErrorErr != nil {
+ return errors.Wrap(_EEDataErrorErr, "Error serializing 'EEDataError' field")
+ }
+
+ // Simple Field (EEChecksumError)
+ EEChecksumError := bool(m.EEChecksumError)
+ _EEChecksumErrorErr := writeBuffer.WriteBit("EEChecksumError", (EEChecksumError))
+ if _EEChecksumErrorErr != nil {
+ return errors.Wrap(_EEChecksumErrorErr, "Error serializing 'EEChecksumError' field")
+ }
+
+ // Simple Field (EEWriteError)
+ EEWriteError := bool(m.EEWriteError)
+ _EEWriteErrorErr := writeBuffer.WriteBit("EEWriteError", (EEWriteError))
+ if _EEWriteErrorErr != nil {
+ return errors.Wrap(_EEWriteErrorErr, "Error serializing 'EEWriteError' field")
+ }
+
+ // Simple Field (installationMMIError)
+ installationMMIError := bool(m.InstallationMMIError)
+ _installationMMIErrorErr := writeBuffer.WriteBit("installationMMIError", (installationMMIError))
+ if _installationMMIErrorErr != nil {
+ return errors.Wrap(_installationMMIErrorErr, "Error serializing 'installationMMIError' field")
+ }
+
+ if popErr := writeBuffer.PopContext("IdentifyReplyCommandExtendedDiagnosticSummary"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *IdentifyReplyCommandExtendedDiagnosticSummary) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ buffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ m.Serialize(buffer)
+ return buffer.GetBox().String()
+}
diff --git a/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandFirmwareSummary.go b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandFirmwareSummary.go
new file mode 100644
index 0000000..fb74fef
--- /dev/null
+++ b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandFirmwareSummary.go
@@ -0,0 +1,228 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+ "github.com/pkg/errors"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// The data-structure of this message
+type IdentifyReplyCommandFirmwareSummary struct {
+ *IdentifyReplyCommand
+ FirmwareVersion string
+ UnitServiceType byte
+ Version string
+}
+
+// The corresponding interface
+type IIdentifyReplyCommandFirmwareSummary interface {
+ // GetFirmwareVersion returns FirmwareVersion
+ GetFirmwareVersion() string
+ // GetUnitServiceType returns UnitServiceType
+ GetUnitServiceType() byte
+ // GetVersion returns Version
+ GetVersion() string
+ // GetLengthInBytes returns the length in bytes
+ GetLengthInBytes() uint16
+ // GetLengthInBits returns the length in bits
+ GetLengthInBits() uint16
+ // Serialize serializes this type
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+///////////////////////////////////////////////////////////
+// Accessors for discriminator values.
+///////////////////////////////////////////////////////////
+func (m *IdentifyReplyCommandFirmwareSummary) Attribute() Attribute {
+ return Attribute_Summary
+}
+
+func (m *IdentifyReplyCommandFirmwareSummary) GetAttribute() Attribute {
+ return Attribute_Summary
+}
+
+func (m *IdentifyReplyCommandFirmwareSummary) InitializeParent(parent *IdentifyReplyCommand) {}
+
+///////////////////////////////////////////////////////////
+// Accessors for property fields.
+///////////////////////////////////////////////////////////
+func (m *IdentifyReplyCommandFirmwareSummary) GetFirmwareVersion() string {
+ return m.FirmwareVersion
+}
+
+func (m *IdentifyReplyCommandFirmwareSummary) GetUnitServiceType() byte {
+ return m.UnitServiceType
+}
+
+func (m *IdentifyReplyCommandFirmwareSummary) GetVersion() string {
+ return m.Version
+}
+
+///////////////////////////////////////////////////////////
+// Accessors for virtual fields.
+///////////////////////////////////////////////////////////
+
+// NewIdentifyReplyCommandFirmwareSummary factory function for IdentifyReplyCommandFirmwareSummary
+func NewIdentifyReplyCommandFirmwareSummary(firmwareVersion string, unitServiceType byte, version string) *IdentifyReplyCommand {
+ child := &IdentifyReplyCommandFirmwareSummary{
+ FirmwareVersion: firmwareVersion,
+ UnitServiceType: unitServiceType,
+ Version: version,
+ IdentifyReplyCommand: NewIdentifyReplyCommand(),
+ }
+ child.Child = child
+ return child.IdentifyReplyCommand
+}
+
+func CastIdentifyReplyCommandFirmwareSummary(structType interface{}) *IdentifyReplyCommandFirmwareSummary {
+ castFunc := func(typ interface{}) *IdentifyReplyCommandFirmwareSummary {
+ if casted, ok := typ.(IdentifyReplyCommandFirmwareSummary); ok {
+ return &casted
+ }
+ if casted, ok := typ.(*IdentifyReplyCommandFirmwareSummary); ok {
+ return casted
+ }
+ if casted, ok := typ.(IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandFirmwareSummary(casted.Child)
+ }
+ if casted, ok := typ.(*IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandFirmwareSummary(casted.Child)
+ }
+ return nil
+ }
+ return castFunc(structType)
+}
+
+func (m *IdentifyReplyCommandFirmwareSummary) GetTypeName() string {
+ return "IdentifyReplyCommandFirmwareSummary"
+}
+
+func (m *IdentifyReplyCommandFirmwareSummary) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *IdentifyReplyCommandFirmwareSummary) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (firmwareVersion)
+ lengthInBits += 48
+
+ // Simple field (unitServiceType)
+ lengthInBits += 8
+
+ // Simple field (version)
+ lengthInBits += 32
+
+ return lengthInBits
+}
+
+func (m *IdentifyReplyCommandFirmwareSummary) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func IdentifyReplyCommandFirmwareSummaryParse(readBuffer utils.ReadBuffer, attribute Attribute) (*IdentifyReplyCommand, error) {
+ if pullErr := readBuffer.PullContext("IdentifyReplyCommandFirmwareSummary"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := readBuffer.GetPos()
+ _ = currentPos
+
+ // Simple Field (firmwareVersion)
+ _firmwareVersion, _firmwareVersionErr := readBuffer.ReadString("firmwareVersion", uint32(48))
+ if _firmwareVersionErr != nil {
+ return nil, errors.Wrap(_firmwareVersionErr, "Error parsing 'firmwareVersion' field")
+ }
+ firmwareVersion := _firmwareVersion
+
+ // Simple Field (unitServiceType)
+ _unitServiceType, _unitServiceTypeErr := readBuffer.ReadByte("unitServiceType")
+ if _unitServiceTypeErr != nil {
+ return nil, errors.Wrap(_unitServiceTypeErr, "Error parsing 'unitServiceType' field")
+ }
+ unitServiceType := _unitServiceType
+
+ // Simple Field (version)
+ _version, _versionErr := readBuffer.ReadString("version", uint32(32))
+ if _versionErr != nil {
+ return nil, errors.Wrap(_versionErr, "Error parsing 'version' field")
+ }
+ version := _version
+
+ if closeErr := readBuffer.CloseContext("IdentifyReplyCommandFirmwareSummary"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &IdentifyReplyCommandFirmwareSummary{
+ FirmwareVersion: firmwareVersion,
+ UnitServiceType: unitServiceType,
+ Version: version,
+ IdentifyReplyCommand: &IdentifyReplyCommand{},
+ }
+ _child.IdentifyReplyCommand.Child = _child
+ return _child.IdentifyReplyCommand, nil
+}
+
+func (m *IdentifyReplyCommandFirmwareSummary) Serialize(writeBuffer utils.WriteBuffer) error {
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("IdentifyReplyCommandFirmwareSummary"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (firmwareVersion)
+ firmwareVersion := string(m.FirmwareVersion)
+ _firmwareVersionErr := writeBuffer.WriteString("firmwareVersion", uint32(48), "UTF-8", (firmwareVersion))
+ if _firmwareVersionErr != nil {
+ return errors.Wrap(_firmwareVersionErr, "Error serializing 'firmwareVersion' field")
+ }
+
+ // Simple Field (unitServiceType)
+ unitServiceType := byte(m.UnitServiceType)
+ _unitServiceTypeErr := writeBuffer.WriteByte("unitServiceType", (unitServiceType))
+ if _unitServiceTypeErr != nil {
+ return errors.Wrap(_unitServiceTypeErr, "Error serializing 'unitServiceType' field")
+ }
+
+ // Simple Field (version)
+ version := string(m.Version)
+ _versionErr := writeBuffer.WriteString("version", uint32(32), "UTF-8", (version))
+ if _versionErr != nil {
+ return errors.Wrap(_versionErr, "Error serializing 'version' field")
+ }
+
+ if popErr := writeBuffer.PopContext("IdentifyReplyCommandFirmwareSummary"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *IdentifyReplyCommandFirmwareSummary) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ buffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ m.Serialize(buffer)
+ return buffer.GetBox().String()
+}
diff --git a/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandFirmwareVersion.go b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandFirmwareVersion.go
new file mode 100644
index 0000000..1df328f
--- /dev/null
+++ b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandFirmwareVersion.go
@@ -0,0 +1,176 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+ "github.com/pkg/errors"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// The data-structure of this message
+type IdentifyReplyCommandFirmwareVersion struct {
+ *IdentifyReplyCommand
+ FirmwareVersion string
+}
+
+// The corresponding interface
+type IIdentifyReplyCommandFirmwareVersion interface {
+ // GetFirmwareVersion returns FirmwareVersion
+ GetFirmwareVersion() string
+ // GetLengthInBytes returns the length in bytes
+ GetLengthInBytes() uint16
+ // GetLengthInBits returns the length in bits
+ GetLengthInBits() uint16
+ // Serialize serializes this type
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+///////////////////////////////////////////////////////////
+// Accessors for discriminator values.
+///////////////////////////////////////////////////////////
+func (m *IdentifyReplyCommandFirmwareVersion) Attribute() Attribute {
+ return Attribute_FirmwareVersion
+}
+
+func (m *IdentifyReplyCommandFirmwareVersion) GetAttribute() Attribute {
+ return Attribute_FirmwareVersion
+}
+
+func (m *IdentifyReplyCommandFirmwareVersion) InitializeParent(parent *IdentifyReplyCommand) {}
+
+///////////////////////////////////////////////////////////
+// Accessors for property fields.
+///////////////////////////////////////////////////////////
+func (m *IdentifyReplyCommandFirmwareVersion) GetFirmwareVersion() string {
+ return m.FirmwareVersion
+}
+
+///////////////////////////////////////////////////////////
+// Accessors for virtual fields.
+///////////////////////////////////////////////////////////
+
+// NewIdentifyReplyCommandFirmwareVersion factory function for IdentifyReplyCommandFirmwareVersion
+func NewIdentifyReplyCommandFirmwareVersion(firmwareVersion string) *IdentifyReplyCommand {
+ child := &IdentifyReplyCommandFirmwareVersion{
+ FirmwareVersion: firmwareVersion,
+ IdentifyReplyCommand: NewIdentifyReplyCommand(),
+ }
+ child.Child = child
+ return child.IdentifyReplyCommand
+}
+
+func CastIdentifyReplyCommandFirmwareVersion(structType interface{}) *IdentifyReplyCommandFirmwareVersion {
+ castFunc := func(typ interface{}) *IdentifyReplyCommandFirmwareVersion {
+ if casted, ok := typ.(IdentifyReplyCommandFirmwareVersion); ok {
+ return &casted
+ }
+ if casted, ok := typ.(*IdentifyReplyCommandFirmwareVersion); ok {
+ return casted
+ }
+ if casted, ok := typ.(IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandFirmwareVersion(casted.Child)
+ }
+ if casted, ok := typ.(*IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandFirmwareVersion(casted.Child)
+ }
+ return nil
+ }
+ return castFunc(structType)
+}
+
+func (m *IdentifyReplyCommandFirmwareVersion) GetTypeName() string {
+ return "IdentifyReplyCommandFirmwareVersion"
+}
+
+func (m *IdentifyReplyCommandFirmwareVersion) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *IdentifyReplyCommandFirmwareVersion) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (firmwareVersion)
+ lengthInBits += 64
+
+ return lengthInBits
+}
+
+func (m *IdentifyReplyCommandFirmwareVersion) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func IdentifyReplyCommandFirmwareVersionParse(readBuffer utils.ReadBuffer, attribute Attribute) (*IdentifyReplyCommand, error) {
+ if pullErr := readBuffer.PullContext("IdentifyReplyCommandFirmwareVersion"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := readBuffer.GetPos()
+ _ = currentPos
+
+ // Simple Field (firmwareVersion)
+ _firmwareVersion, _firmwareVersionErr := readBuffer.ReadString("firmwareVersion", uint32(64))
+ if _firmwareVersionErr != nil {
+ return nil, errors.Wrap(_firmwareVersionErr, "Error parsing 'firmwareVersion' field")
+ }
+ firmwareVersion := _firmwareVersion
+
+ if closeErr := readBuffer.CloseContext("IdentifyReplyCommandFirmwareVersion"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &IdentifyReplyCommandFirmwareVersion{
+ FirmwareVersion: firmwareVersion,
+ IdentifyReplyCommand: &IdentifyReplyCommand{},
+ }
+ _child.IdentifyReplyCommand.Child = _child
+ return _child.IdentifyReplyCommand, nil
+}
+
+func (m *IdentifyReplyCommandFirmwareVersion) Serialize(writeBuffer utils.WriteBuffer) error {
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("IdentifyReplyCommandFirmwareVersion"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (firmwareVersion)
+ firmwareVersion := string(m.FirmwareVersion)
+ _firmwareVersionErr := writeBuffer.WriteString("firmwareVersion", uint32(64), "UTF-8", (firmwareVersion))
+ if _firmwareVersionErr != nil {
+ return errors.Wrap(_firmwareVersionErr, "Error serializing 'firmwareVersion' field")
+ }
+
+ if popErr := writeBuffer.PopContext("IdentifyReplyCommandFirmwareVersion"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *IdentifyReplyCommandFirmwareVersion) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ buffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ m.Serialize(buffer)
+ return buffer.GetBox().String()
+}
diff --git a/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandGAVPhysicalAddresses.go b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandGAVPhysicalAddresses.go
new file mode 100644
index 0000000..62f0c0a
--- /dev/null
+++ b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandGAVPhysicalAddresses.go
@@ -0,0 +1,179 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+ "github.com/pkg/errors"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// The data-structure of this message
+type IdentifyReplyCommandGAVPhysicalAddresses struct {
+ *IdentifyReplyCommand
+ Values []byte
+}
+
+// The corresponding interface
+type IIdentifyReplyCommandGAVPhysicalAddresses interface {
+ // GetValues returns Values
+ GetValues() []byte
+ // GetLengthInBytes returns the length in bytes
+ GetLengthInBytes() uint16
+ // GetLengthInBits returns the length in bits
+ GetLengthInBits() uint16
+ // Serialize serializes this type
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+///////////////////////////////////////////////////////////
+// Accessors for discriminator values.
+///////////////////////////////////////////////////////////
+func (m *IdentifyReplyCommandGAVPhysicalAddresses) Attribute() Attribute {
+ return Attribute_GAVPhysicalAddresses
+}
+
+func (m *IdentifyReplyCommandGAVPhysicalAddresses) GetAttribute() Attribute {
+ return Attribute_GAVPhysicalAddresses
+}
+
+func (m *IdentifyReplyCommandGAVPhysicalAddresses) InitializeParent(parent *IdentifyReplyCommand) {}
+
+///////////////////////////////////////////////////////////
+// Accessors for property fields.
+///////////////////////////////////////////////////////////
+func (m *IdentifyReplyCommandGAVPhysicalAddresses) GetValues() []byte {
+ return m.Values
+}
+
+///////////////////////////////////////////////////////////
+// Accessors for virtual fields.
+///////////////////////////////////////////////////////////
+
+// NewIdentifyReplyCommandGAVPhysicalAddresses factory function for IdentifyReplyCommandGAVPhysicalAddresses
+func NewIdentifyReplyCommandGAVPhysicalAddresses(values []byte) *IdentifyReplyCommand {
+ child := &IdentifyReplyCommandGAVPhysicalAddresses{
+ Values: values,
+ IdentifyReplyCommand: NewIdentifyReplyCommand(),
+ }
+ child.Child = child
+ return child.IdentifyReplyCommand
+}
+
+func CastIdentifyReplyCommandGAVPhysicalAddresses(structType interface{}) *IdentifyReplyCommandGAVPhysicalAddresses {
+ castFunc := func(typ interface{}) *IdentifyReplyCommandGAVPhysicalAddresses {
+ if casted, ok := typ.(IdentifyReplyCommandGAVPhysicalAddresses); ok {
+ return &casted
+ }
+ if casted, ok := typ.(*IdentifyReplyCommandGAVPhysicalAddresses); ok {
+ return casted
+ }
+ if casted, ok := typ.(IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandGAVPhysicalAddresses(casted.Child)
+ }
+ if casted, ok := typ.(*IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandGAVPhysicalAddresses(casted.Child)
+ }
+ return nil
+ }
+ return castFunc(structType)
+}
+
+func (m *IdentifyReplyCommandGAVPhysicalAddresses) GetTypeName() string {
+ return "IdentifyReplyCommandGAVPhysicalAddresses"
+}
+
+func (m *IdentifyReplyCommandGAVPhysicalAddresses) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *IdentifyReplyCommandGAVPhysicalAddresses) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Array field
+ if len(m.Values) > 0 {
+ lengthInBits += 8 * uint16(len(m.Values))
+ }
+
+ return lengthInBits
+}
+
+func (m *IdentifyReplyCommandGAVPhysicalAddresses) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func IdentifyReplyCommandGAVPhysicalAddressesParse(readBuffer utils.ReadBuffer, attribute Attribute) (*IdentifyReplyCommand, error) {
+ if pullErr := readBuffer.PullContext("IdentifyReplyCommandGAVPhysicalAddresses"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := readBuffer.GetPos()
+ _ = currentPos
+ // Byte Array field (values)
+ numberOfBytesvalues := int(uint16(16))
+ values, _readArrayErr := readBuffer.ReadByteArray("values", numberOfBytesvalues)
+ if _readArrayErr != nil {
+ return nil, errors.Wrap(_readArrayErr, "Error parsing 'values' field")
+ }
+
+ if closeErr := readBuffer.CloseContext("IdentifyReplyCommandGAVPhysicalAddresses"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &IdentifyReplyCommandGAVPhysicalAddresses{
+ Values: values,
+ IdentifyReplyCommand: &IdentifyReplyCommand{},
+ }
+ _child.IdentifyReplyCommand.Child = _child
+ return _child.IdentifyReplyCommand, nil
+}
+
+func (m *IdentifyReplyCommandGAVPhysicalAddresses) Serialize(writeBuffer utils.WriteBuffer) error {
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("IdentifyReplyCommandGAVPhysicalAddresses"); pushErr != nil {
+ return pushErr
+ }
+
+ // Array Field (values)
+ if m.Values != nil {
+ // Byte Array field (values)
+ _writeArrayErr := writeBuffer.WriteByteArray("values", m.Values)
+ if _writeArrayErr != nil {
+ return errors.Wrap(_writeArrayErr, "Error serializing 'values' field")
+ }
+ }
+
+ if popErr := writeBuffer.PopContext("IdentifyReplyCommandGAVPhysicalAddresses"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *IdentifyReplyCommandGAVPhysicalAddresses) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ buffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ m.Serialize(buffer)
+ return buffer.GetBox().String()
+}
diff --git a/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandGAVValuesCurrent.go b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandGAVValuesCurrent.go
new file mode 100644
index 0000000..65a52f4
--- /dev/null
+++ b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandGAVValuesCurrent.go
@@ -0,0 +1,179 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+ "github.com/pkg/errors"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// The data-structure of this message
+type IdentifyReplyCommandGAVValuesCurrent struct {
+ *IdentifyReplyCommand
+ Values []byte
+}
+
+// The corresponding interface
+type IIdentifyReplyCommandGAVValuesCurrent interface {
+ // GetValues returns Values
+ GetValues() []byte
+ // GetLengthInBytes returns the length in bytes
+ GetLengthInBytes() uint16
+ // GetLengthInBits returns the length in bits
+ GetLengthInBits() uint16
+ // Serialize serializes this type
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+///////////////////////////////////////////////////////////
+// Accessors for discriminator values.
+///////////////////////////////////////////////////////////
+func (m *IdentifyReplyCommandGAVValuesCurrent) Attribute() Attribute {
+ return Attribute_GAVValuesCurrent
+}
+
+func (m *IdentifyReplyCommandGAVValuesCurrent) GetAttribute() Attribute {
+ return Attribute_GAVValuesCurrent
+}
+
+func (m *IdentifyReplyCommandGAVValuesCurrent) InitializeParent(parent *IdentifyReplyCommand) {}
+
+///////////////////////////////////////////////////////////
+// Accessors for property fields.
+///////////////////////////////////////////////////////////
+func (m *IdentifyReplyCommandGAVValuesCurrent) GetValues() []byte {
+ return m.Values
+}
+
+///////////////////////////////////////////////////////////
+// Accessors for virtual fields.
+///////////////////////////////////////////////////////////
+
+// NewIdentifyReplyCommandGAVValuesCurrent factory function for IdentifyReplyCommandGAVValuesCurrent
+func NewIdentifyReplyCommandGAVValuesCurrent(values []byte) *IdentifyReplyCommand {
+ child := &IdentifyReplyCommandGAVValuesCurrent{
+ Values: values,
+ IdentifyReplyCommand: NewIdentifyReplyCommand(),
+ }
+ child.Child = child
+ return child.IdentifyReplyCommand
+}
+
+func CastIdentifyReplyCommandGAVValuesCurrent(structType interface{}) *IdentifyReplyCommandGAVValuesCurrent {
+ castFunc := func(typ interface{}) *IdentifyReplyCommandGAVValuesCurrent {
+ if casted, ok := typ.(IdentifyReplyCommandGAVValuesCurrent); ok {
+ return &casted
+ }
+ if casted, ok := typ.(*IdentifyReplyCommandGAVValuesCurrent); ok {
+ return casted
+ }
+ if casted, ok := typ.(IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandGAVValuesCurrent(casted.Child)
+ }
+ if casted, ok := typ.(*IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandGAVValuesCurrent(casted.Child)
+ }
+ return nil
+ }
+ return castFunc(structType)
+}
+
+func (m *IdentifyReplyCommandGAVValuesCurrent) GetTypeName() string {
+ return "IdentifyReplyCommandGAVValuesCurrent"
+}
+
+func (m *IdentifyReplyCommandGAVValuesCurrent) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *IdentifyReplyCommandGAVValuesCurrent) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Array field
+ if len(m.Values) > 0 {
+ lengthInBits += 8 * uint16(len(m.Values))
+ }
+
+ return lengthInBits
+}
+
+func (m *IdentifyReplyCommandGAVValuesCurrent) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func IdentifyReplyCommandGAVValuesCurrentParse(readBuffer utils.ReadBuffer, attribute Attribute) (*IdentifyReplyCommand, error) {
+ if pullErr := readBuffer.PullContext("IdentifyReplyCommandGAVValuesCurrent"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := readBuffer.GetPos()
+ _ = currentPos
+ // Byte Array field (values)
+ numberOfBytesvalues := int(uint16(16))
+ values, _readArrayErr := readBuffer.ReadByteArray("values", numberOfBytesvalues)
+ if _readArrayErr != nil {
+ return nil, errors.Wrap(_readArrayErr, "Error parsing 'values' field")
+ }
+
+ if closeErr := readBuffer.CloseContext("IdentifyReplyCommandGAVValuesCurrent"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &IdentifyReplyCommandGAVValuesCurrent{
+ Values: values,
+ IdentifyReplyCommand: &IdentifyReplyCommand{},
+ }
+ _child.IdentifyReplyCommand.Child = _child
+ return _child.IdentifyReplyCommand, nil
+}
+
+func (m *IdentifyReplyCommandGAVValuesCurrent) Serialize(writeBuffer utils.WriteBuffer) error {
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("IdentifyReplyCommandGAVValuesCurrent"); pushErr != nil {
+ return pushErr
+ }
+
+ // Array Field (values)
+ if m.Values != nil {
+ // Byte Array field (values)
+ _writeArrayErr := writeBuffer.WriteByteArray("values", m.Values)
+ if _writeArrayErr != nil {
+ return errors.Wrap(_writeArrayErr, "Error serializing 'values' field")
+ }
+ }
+
+ if popErr := writeBuffer.PopContext("IdentifyReplyCommandGAVValuesCurrent"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *IdentifyReplyCommandGAVValuesCurrent) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ buffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ m.Serialize(buffer)
+ return buffer.GetBox().String()
+}
diff --git a/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandGAVValuesStored.go b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandGAVValuesStored.go
new file mode 100644
index 0000000..b2eb285
--- /dev/null
+++ b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandGAVValuesStored.go
@@ -0,0 +1,179 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+ "github.com/pkg/errors"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// The data-structure of this message
+type IdentifyReplyCommandGAVValuesStored struct {
+ *IdentifyReplyCommand
+ Values []byte
+}
+
+// The corresponding interface
+type IIdentifyReplyCommandGAVValuesStored interface {
+ // GetValues returns Values
+ GetValues() []byte
+ // GetLengthInBytes returns the length in bytes
+ GetLengthInBytes() uint16
+ // GetLengthInBits returns the length in bits
+ GetLengthInBits() uint16
+ // Serialize serializes this type
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+///////////////////////////////////////////////////////////
+// Accessors for discriminator values.
+///////////////////////////////////////////////////////////
+func (m *IdentifyReplyCommandGAVValuesStored) Attribute() Attribute {
+ return Attribute_GAVValuesStored
+}
+
+func (m *IdentifyReplyCommandGAVValuesStored) GetAttribute() Attribute {
+ return Attribute_GAVValuesStored
+}
+
+func (m *IdentifyReplyCommandGAVValuesStored) InitializeParent(parent *IdentifyReplyCommand) {}
+
+///////////////////////////////////////////////////////////
+// Accessors for property fields.
+///////////////////////////////////////////////////////////
+func (m *IdentifyReplyCommandGAVValuesStored) GetValues() []byte {
+ return m.Values
+}
+
+///////////////////////////////////////////////////////////
+// Accessors for virtual fields.
+///////////////////////////////////////////////////////////
+
+// NewIdentifyReplyCommandGAVValuesStored factory function for IdentifyReplyCommandGAVValuesStored
+func NewIdentifyReplyCommandGAVValuesStored(values []byte) *IdentifyReplyCommand {
+ child := &IdentifyReplyCommandGAVValuesStored{
+ Values: values,
+ IdentifyReplyCommand: NewIdentifyReplyCommand(),
+ }
+ child.Child = child
+ return child.IdentifyReplyCommand
+}
+
+func CastIdentifyReplyCommandGAVValuesStored(structType interface{}) *IdentifyReplyCommandGAVValuesStored {
+ castFunc := func(typ interface{}) *IdentifyReplyCommandGAVValuesStored {
+ if casted, ok := typ.(IdentifyReplyCommandGAVValuesStored); ok {
+ return &casted
+ }
+ if casted, ok := typ.(*IdentifyReplyCommandGAVValuesStored); ok {
+ return casted
+ }
+ if casted, ok := typ.(IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandGAVValuesStored(casted.Child)
+ }
+ if casted, ok := typ.(*IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandGAVValuesStored(casted.Child)
+ }
+ return nil
+ }
+ return castFunc(structType)
+}
+
+func (m *IdentifyReplyCommandGAVValuesStored) GetTypeName() string {
+ return "IdentifyReplyCommandGAVValuesStored"
+}
+
+func (m *IdentifyReplyCommandGAVValuesStored) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *IdentifyReplyCommandGAVValuesStored) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Array field
+ if len(m.Values) > 0 {
+ lengthInBits += 8 * uint16(len(m.Values))
+ }
+
+ return lengthInBits
+}
+
+func (m *IdentifyReplyCommandGAVValuesStored) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func IdentifyReplyCommandGAVValuesStoredParse(readBuffer utils.ReadBuffer, attribute Attribute) (*IdentifyReplyCommand, error) {
+ if pullErr := readBuffer.PullContext("IdentifyReplyCommandGAVValuesStored"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := readBuffer.GetPos()
+ _ = currentPos
+ // Byte Array field (values)
+ numberOfBytesvalues := int(uint16(16))
+ values, _readArrayErr := readBuffer.ReadByteArray("values", numberOfBytesvalues)
+ if _readArrayErr != nil {
+ return nil, errors.Wrap(_readArrayErr, "Error parsing 'values' field")
+ }
+
+ if closeErr := readBuffer.CloseContext("IdentifyReplyCommandGAVValuesStored"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &IdentifyReplyCommandGAVValuesStored{
+ Values: values,
+ IdentifyReplyCommand: &IdentifyReplyCommand{},
+ }
+ _child.IdentifyReplyCommand.Child = _child
+ return _child.IdentifyReplyCommand, nil
+}
+
+func (m *IdentifyReplyCommandGAVValuesStored) Serialize(writeBuffer utils.WriteBuffer) error {
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("IdentifyReplyCommandGAVValuesStored"); pushErr != nil {
+ return pushErr
+ }
+
+ // Array Field (values)
+ if m.Values != nil {
+ // Byte Array field (values)
+ _writeArrayErr := writeBuffer.WriteByteArray("values", m.Values)
+ if _writeArrayErr != nil {
+ return errors.Wrap(_writeArrayErr, "Error serializing 'values' field")
+ }
+ }
+
+ if popErr := writeBuffer.PopContext("IdentifyReplyCommandGAVValuesStored"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *IdentifyReplyCommandGAVValuesStored) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ buffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ m.Serialize(buffer)
+ return buffer.GetBox().String()
+}
diff --git a/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandLogicalAssignment.go b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandLogicalAssignment.go
new file mode 100644
index 0000000..c872f9f
--- /dev/null
+++ b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandLogicalAssignment.go
@@ -0,0 +1,150 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// The data-structure of this message
+type IdentifyReplyCommandLogicalAssignment struct {
+ *IdentifyReplyCommand
+}
+
+// The corresponding interface
+type IIdentifyReplyCommandLogicalAssignment interface {
+ // GetLengthInBytes returns the length in bytes
+ GetLengthInBytes() uint16
+ // GetLengthInBits returns the length in bits
+ GetLengthInBits() uint16
+ // Serialize serializes this type
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+///////////////////////////////////////////////////////////
+// Accessors for discriminator values.
+///////////////////////////////////////////////////////////
+func (m *IdentifyReplyCommandLogicalAssignment) Attribute() Attribute {
+ return Attribute_LogicalAssignment
+}
+
+func (m *IdentifyReplyCommandLogicalAssignment) GetAttribute() Attribute {
+ return Attribute_LogicalAssignment
+}
+
+func (m *IdentifyReplyCommandLogicalAssignment) InitializeParent(parent *IdentifyReplyCommand) {}
+
+///////////////////////////////////////////////////////////
+// Accessors for property fields.
+///////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////
+// Accessors for virtual fields.
+///////////////////////////////////////////////////////////
+
+// NewIdentifyReplyCommandLogicalAssignment factory function for IdentifyReplyCommandLogicalAssignment
+func NewIdentifyReplyCommandLogicalAssignment() *IdentifyReplyCommand {
+ child := &IdentifyReplyCommandLogicalAssignment{
+ IdentifyReplyCommand: NewIdentifyReplyCommand(),
+ }
+ child.Child = child
+ return child.IdentifyReplyCommand
+}
+
+func CastIdentifyReplyCommandLogicalAssignment(structType interface{}) *IdentifyReplyCommandLogicalAssignment {
+ castFunc := func(typ interface{}) *IdentifyReplyCommandLogicalAssignment {
+ if casted, ok := typ.(IdentifyReplyCommandLogicalAssignment); ok {
+ return &casted
+ }
+ if casted, ok := typ.(*IdentifyReplyCommandLogicalAssignment); ok {
+ return casted
+ }
+ if casted, ok := typ.(IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandLogicalAssignment(casted.Child)
+ }
+ if casted, ok := typ.(*IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandLogicalAssignment(casted.Child)
+ }
+ return nil
+ }
+ return castFunc(structType)
+}
+
+func (m *IdentifyReplyCommandLogicalAssignment) GetTypeName() string {
+ return "IdentifyReplyCommandLogicalAssignment"
+}
+
+func (m *IdentifyReplyCommandLogicalAssignment) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *IdentifyReplyCommandLogicalAssignment) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ return lengthInBits
+}
+
+func (m *IdentifyReplyCommandLogicalAssignment) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func IdentifyReplyCommandLogicalAssignmentParse(readBuffer utils.ReadBuffer, attribute Attribute) (*IdentifyReplyCommand, error) {
+ if pullErr := readBuffer.PullContext("IdentifyReplyCommandLogicalAssignment"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := readBuffer.GetPos()
+ _ = currentPos
+
+ if closeErr := readBuffer.CloseContext("IdentifyReplyCommandLogicalAssignment"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &IdentifyReplyCommandLogicalAssignment{
+ IdentifyReplyCommand: &IdentifyReplyCommand{},
+ }
+ _child.IdentifyReplyCommand.Child = _child
+ return _child.IdentifyReplyCommand, nil
+}
+
+func (m *IdentifyReplyCommandLogicalAssignment) Serialize(writeBuffer utils.WriteBuffer) error {
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("IdentifyReplyCommandLogicalAssignment"); pushErr != nil {
+ return pushErr
+ }
+
+ if popErr := writeBuffer.PopContext("IdentifyReplyCommandLogicalAssignment"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *IdentifyReplyCommandLogicalAssignment) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ buffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ m.Serialize(buffer)
+ return buffer.GetBox().String()
+}
diff --git a/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandManufacturer.go b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandManufacturer.go
new file mode 100644
index 0000000..c4ef3e3
--- /dev/null
+++ b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandManufacturer.go
@@ -0,0 +1,176 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+ "github.com/pkg/errors"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// The data-structure of this message
+type IdentifyReplyCommandManufacturer struct {
+ *IdentifyReplyCommand
+ ManufacturerName string
+}
+
+// The corresponding interface
+type IIdentifyReplyCommandManufacturer interface {
+ // GetManufacturerName returns ManufacturerName
+ GetManufacturerName() string
+ // GetLengthInBytes returns the length in bytes
+ GetLengthInBytes() uint16
+ // GetLengthInBits returns the length in bits
+ GetLengthInBits() uint16
+ // Serialize serializes this type
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+///////////////////////////////////////////////////////////
+// Accessors for discriminator values.
+///////////////////////////////////////////////////////////
+func (m *IdentifyReplyCommandManufacturer) Attribute() Attribute {
+ return Attribute_Manufacturer
+}
+
+func (m *IdentifyReplyCommandManufacturer) GetAttribute() Attribute {
+ return Attribute_Manufacturer
+}
+
+func (m *IdentifyReplyCommandManufacturer) InitializeParent(parent *IdentifyReplyCommand) {}
+
+///////////////////////////////////////////////////////////
+// Accessors for property fields.
+///////////////////////////////////////////////////////////
+func (m *IdentifyReplyCommandManufacturer) GetManufacturerName() string {
+ return m.ManufacturerName
+}
+
+///////////////////////////////////////////////////////////
+// Accessors for virtual fields.
+///////////////////////////////////////////////////////////
+
+// NewIdentifyReplyCommandManufacturer factory function for IdentifyReplyCommandManufacturer
+func NewIdentifyReplyCommandManufacturer(manufacturerName string) *IdentifyReplyCommand {
+ child := &IdentifyReplyCommandManufacturer{
+ ManufacturerName: manufacturerName,
+ IdentifyReplyCommand: NewIdentifyReplyCommand(),
+ }
+ child.Child = child
+ return child.IdentifyReplyCommand
+}
+
+func CastIdentifyReplyCommandManufacturer(structType interface{}) *IdentifyReplyCommandManufacturer {
+ castFunc := func(typ interface{}) *IdentifyReplyCommandManufacturer {
+ if casted, ok := typ.(IdentifyReplyCommandManufacturer); ok {
+ return &casted
+ }
+ if casted, ok := typ.(*IdentifyReplyCommandManufacturer); ok {
+ return casted
+ }
+ if casted, ok := typ.(IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandManufacturer(casted.Child)
+ }
+ if casted, ok := typ.(*IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandManufacturer(casted.Child)
+ }
+ return nil
+ }
+ return castFunc(structType)
+}
+
+func (m *IdentifyReplyCommandManufacturer) GetTypeName() string {
+ return "IdentifyReplyCommandManufacturer"
+}
+
+func (m *IdentifyReplyCommandManufacturer) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *IdentifyReplyCommandManufacturer) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (manufacturerName)
+ lengthInBits += 64
+
+ return lengthInBits
+}
+
+func (m *IdentifyReplyCommandManufacturer) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func IdentifyReplyCommandManufacturerParse(readBuffer utils.ReadBuffer, attribute Attribute) (*IdentifyReplyCommand, error) {
+ if pullErr := readBuffer.PullContext("IdentifyReplyCommandManufacturer"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := readBuffer.GetPos()
+ _ = currentPos
+
+ // Simple Field (manufacturerName)
+ _manufacturerName, _manufacturerNameErr := readBuffer.ReadString("manufacturerName", uint32(64))
+ if _manufacturerNameErr != nil {
+ return nil, errors.Wrap(_manufacturerNameErr, "Error parsing 'manufacturerName' field")
+ }
+ manufacturerName := _manufacturerName
+
+ if closeErr := readBuffer.CloseContext("IdentifyReplyCommandManufacturer"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &IdentifyReplyCommandManufacturer{
+ ManufacturerName: manufacturerName,
+ IdentifyReplyCommand: &IdentifyReplyCommand{},
+ }
+ _child.IdentifyReplyCommand.Child = _child
+ return _child.IdentifyReplyCommand, nil
+}
+
+func (m *IdentifyReplyCommandManufacturer) Serialize(writeBuffer utils.WriteBuffer) error {
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("IdentifyReplyCommandManufacturer"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (manufacturerName)
+ manufacturerName := string(m.ManufacturerName)
+ _manufacturerNameErr := writeBuffer.WriteString("manufacturerName", uint32(64), "UTF-8", (manufacturerName))
+ if _manufacturerNameErr != nil {
+ return errors.Wrap(_manufacturerNameErr, "Error serializing 'manufacturerName' field")
+ }
+
+ if popErr := writeBuffer.PopContext("IdentifyReplyCommandManufacturer"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *IdentifyReplyCommandManufacturer) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ buffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ m.Serialize(buffer)
+ return buffer.GetBox().String()
+}
diff --git a/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandMaximumLevels.go b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandMaximumLevels.go
new file mode 100644
index 0000000..7ef4798
--- /dev/null
+++ b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandMaximumLevels.go
@@ -0,0 +1,150 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// The data-structure of this message
+type IdentifyReplyCommandMaximumLevels struct {
+ *IdentifyReplyCommand
+}
+
+// The corresponding interface
+type IIdentifyReplyCommandMaximumLevels interface {
+ // GetLengthInBytes returns the length in bytes
+ GetLengthInBytes() uint16
+ // GetLengthInBits returns the length in bits
+ GetLengthInBits() uint16
+ // Serialize serializes this type
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+///////////////////////////////////////////////////////////
+// Accessors for discriminator values.
+///////////////////////////////////////////////////////////
+func (m *IdentifyReplyCommandMaximumLevels) Attribute() Attribute {
+ return Attribute_MaximumLevels
+}
+
+func (m *IdentifyReplyCommandMaximumLevels) GetAttribute() Attribute {
+ return Attribute_MaximumLevels
+}
+
+func (m *IdentifyReplyCommandMaximumLevels) InitializeParent(parent *IdentifyReplyCommand) {}
+
+///////////////////////////////////////////////////////////
+// Accessors for property fields.
+///////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////
+// Accessors for virtual fields.
+///////////////////////////////////////////////////////////
+
+// NewIdentifyReplyCommandMaximumLevels factory function for IdentifyReplyCommandMaximumLevels
+func NewIdentifyReplyCommandMaximumLevels() *IdentifyReplyCommand {
+ child := &IdentifyReplyCommandMaximumLevels{
+ IdentifyReplyCommand: NewIdentifyReplyCommand(),
+ }
+ child.Child = child
+ return child.IdentifyReplyCommand
+}
+
+func CastIdentifyReplyCommandMaximumLevels(structType interface{}) *IdentifyReplyCommandMaximumLevels {
+ castFunc := func(typ interface{}) *IdentifyReplyCommandMaximumLevels {
+ if casted, ok := typ.(IdentifyReplyCommandMaximumLevels); ok {
+ return &casted
+ }
+ if casted, ok := typ.(*IdentifyReplyCommandMaximumLevels); ok {
+ return casted
+ }
+ if casted, ok := typ.(IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandMaximumLevels(casted.Child)
+ }
+ if casted, ok := typ.(*IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandMaximumLevels(casted.Child)
+ }
+ return nil
+ }
+ return castFunc(structType)
+}
+
+func (m *IdentifyReplyCommandMaximumLevels) GetTypeName() string {
+ return "IdentifyReplyCommandMaximumLevels"
+}
+
+func (m *IdentifyReplyCommandMaximumLevels) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *IdentifyReplyCommandMaximumLevels) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ return lengthInBits
+}
+
+func (m *IdentifyReplyCommandMaximumLevels) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func IdentifyReplyCommandMaximumLevelsParse(readBuffer utils.ReadBuffer, attribute Attribute) (*IdentifyReplyCommand, error) {
+ if pullErr := readBuffer.PullContext("IdentifyReplyCommandMaximumLevels"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := readBuffer.GetPos()
+ _ = currentPos
+
+ if closeErr := readBuffer.CloseContext("IdentifyReplyCommandMaximumLevels"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &IdentifyReplyCommandMaximumLevels{
+ IdentifyReplyCommand: &IdentifyReplyCommand{},
+ }
+ _child.IdentifyReplyCommand.Child = _child
+ return _child.IdentifyReplyCommand, nil
+}
+
+func (m *IdentifyReplyCommandMaximumLevels) Serialize(writeBuffer utils.WriteBuffer) error {
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("IdentifyReplyCommandMaximumLevels"); pushErr != nil {
+ return pushErr
+ }
+
+ if popErr := writeBuffer.PopContext("IdentifyReplyCommandMaximumLevels"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *IdentifyReplyCommandMaximumLevels) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ buffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ m.Serialize(buffer)
+ return buffer.GetBox().String()
+}
diff --git a/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandMinimumLevels.go b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandMinimumLevels.go
new file mode 100644
index 0000000..3e742c3
--- /dev/null
+++ b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandMinimumLevels.go
@@ -0,0 +1,150 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// The data-structure of this message
+type IdentifyReplyCommandMinimumLevels struct {
+ *IdentifyReplyCommand
+}
+
+// The corresponding interface
+type IIdentifyReplyCommandMinimumLevels interface {
+ // GetLengthInBytes returns the length in bytes
+ GetLengthInBytes() uint16
+ // GetLengthInBits returns the length in bits
+ GetLengthInBits() uint16
+ // Serialize serializes this type
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+///////////////////////////////////////////////////////////
+// Accessors for discriminator values.
+///////////////////////////////////////////////////////////
+func (m *IdentifyReplyCommandMinimumLevels) Attribute() Attribute {
+ return Attribute_MinimumLevels
+}
+
+func (m *IdentifyReplyCommandMinimumLevels) GetAttribute() Attribute {
+ return Attribute_MinimumLevels
+}
+
+func (m *IdentifyReplyCommandMinimumLevels) InitializeParent(parent *IdentifyReplyCommand) {}
+
+///////////////////////////////////////////////////////////
+// Accessors for property fields.
+///////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////
+// Accessors for virtual fields.
+///////////////////////////////////////////////////////////
+
+// NewIdentifyReplyCommandMinimumLevels factory function for IdentifyReplyCommandMinimumLevels
+func NewIdentifyReplyCommandMinimumLevels() *IdentifyReplyCommand {
+ child := &IdentifyReplyCommandMinimumLevels{
+ IdentifyReplyCommand: NewIdentifyReplyCommand(),
+ }
+ child.Child = child
+ return child.IdentifyReplyCommand
+}
+
+func CastIdentifyReplyCommandMinimumLevels(structType interface{}) *IdentifyReplyCommandMinimumLevels {
+ castFunc := func(typ interface{}) *IdentifyReplyCommandMinimumLevels {
+ if casted, ok := typ.(IdentifyReplyCommandMinimumLevels); ok {
+ return &casted
+ }
+ if casted, ok := typ.(*IdentifyReplyCommandMinimumLevels); ok {
+ return casted
+ }
+ if casted, ok := typ.(IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandMinimumLevels(casted.Child)
+ }
+ if casted, ok := typ.(*IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandMinimumLevels(casted.Child)
+ }
+ return nil
+ }
+ return castFunc(structType)
+}
+
+func (m *IdentifyReplyCommandMinimumLevels) GetTypeName() string {
+ return "IdentifyReplyCommandMinimumLevels"
+}
+
+func (m *IdentifyReplyCommandMinimumLevels) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *IdentifyReplyCommandMinimumLevels) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ return lengthInBits
+}
+
+func (m *IdentifyReplyCommandMinimumLevels) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func IdentifyReplyCommandMinimumLevelsParse(readBuffer utils.ReadBuffer, attribute Attribute) (*IdentifyReplyCommand, error) {
+ if pullErr := readBuffer.PullContext("IdentifyReplyCommandMinimumLevels"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := readBuffer.GetPos()
+ _ = currentPos
+
+ if closeErr := readBuffer.CloseContext("IdentifyReplyCommandMinimumLevels"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &IdentifyReplyCommandMinimumLevels{
+ IdentifyReplyCommand: &IdentifyReplyCommand{},
+ }
+ _child.IdentifyReplyCommand.Child = _child
+ return _child.IdentifyReplyCommand, nil
+}
+
+func (m *IdentifyReplyCommandMinimumLevels) Serialize(writeBuffer utils.WriteBuffer) error {
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("IdentifyReplyCommandMinimumLevels"); pushErr != nil {
+ return pushErr
+ }
+
+ if popErr := writeBuffer.PopContext("IdentifyReplyCommandMinimumLevels"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *IdentifyReplyCommandMinimumLevels) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ buffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ m.Serialize(buffer)
+ return buffer.GetBox().String()
+}
diff --git a/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandNetworkTerminalLevels.go b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandNetworkTerminalLevels.go
new file mode 100644
index 0000000..2919fb5
--- /dev/null
+++ b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandNetworkTerminalLevels.go
@@ -0,0 +1,150 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// The data-structure of this message
+type IdentifyReplyCommandNetworkTerminalLevels struct {
+ *IdentifyReplyCommand
+}
+
+// The corresponding interface
+type IIdentifyReplyCommandNetworkTerminalLevels interface {
+ // GetLengthInBytes returns the length in bytes
+ GetLengthInBytes() uint16
+ // GetLengthInBits returns the length in bits
+ GetLengthInBits() uint16
+ // Serialize serializes this type
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+///////////////////////////////////////////////////////////
+// Accessors for discriminator values.
+///////////////////////////////////////////////////////////
+func (m *IdentifyReplyCommandNetworkTerminalLevels) Attribute() Attribute {
+ return Attribute_NetworkTerminalLevels
+}
+
+func (m *IdentifyReplyCommandNetworkTerminalLevels) GetAttribute() Attribute {
+ return Attribute_NetworkTerminalLevels
+}
+
+func (m *IdentifyReplyCommandNetworkTerminalLevels) InitializeParent(parent *IdentifyReplyCommand) {}
+
+///////////////////////////////////////////////////////////
+// Accessors for property fields.
+///////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////
+// Accessors for virtual fields.
+///////////////////////////////////////////////////////////
+
+// NewIdentifyReplyCommandNetworkTerminalLevels factory function for IdentifyReplyCommandNetworkTerminalLevels
+func NewIdentifyReplyCommandNetworkTerminalLevels() *IdentifyReplyCommand {
+ child := &IdentifyReplyCommandNetworkTerminalLevels{
+ IdentifyReplyCommand: NewIdentifyReplyCommand(),
+ }
+ child.Child = child
+ return child.IdentifyReplyCommand
+}
+
+func CastIdentifyReplyCommandNetworkTerminalLevels(structType interface{}) *IdentifyReplyCommandNetworkTerminalLevels {
+ castFunc := func(typ interface{}) *IdentifyReplyCommandNetworkTerminalLevels {
+ if casted, ok := typ.(IdentifyReplyCommandNetworkTerminalLevels); ok {
+ return &casted
+ }
+ if casted, ok := typ.(*IdentifyReplyCommandNetworkTerminalLevels); ok {
+ return casted
+ }
+ if casted, ok := typ.(IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandNetworkTerminalLevels(casted.Child)
+ }
+ if casted, ok := typ.(*IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandNetworkTerminalLevels(casted.Child)
+ }
+ return nil
+ }
+ return castFunc(structType)
+}
+
+func (m *IdentifyReplyCommandNetworkTerminalLevels) GetTypeName() string {
+ return "IdentifyReplyCommandNetworkTerminalLevels"
+}
+
+func (m *IdentifyReplyCommandNetworkTerminalLevels) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *IdentifyReplyCommandNetworkTerminalLevels) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ return lengthInBits
+}
+
+func (m *IdentifyReplyCommandNetworkTerminalLevels) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func IdentifyReplyCommandNetworkTerminalLevelsParse(readBuffer utils.ReadBuffer, attribute Attribute) (*IdentifyReplyCommand, error) {
+ if pullErr := readBuffer.PullContext("IdentifyReplyCommandNetworkTerminalLevels"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := readBuffer.GetPos()
+ _ = currentPos
+
+ if closeErr := readBuffer.CloseContext("IdentifyReplyCommandNetworkTerminalLevels"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &IdentifyReplyCommandNetworkTerminalLevels{
+ IdentifyReplyCommand: &IdentifyReplyCommand{},
+ }
+ _child.IdentifyReplyCommand.Child = _child
+ return _child.IdentifyReplyCommand, nil
+}
+
+func (m *IdentifyReplyCommandNetworkTerminalLevels) Serialize(writeBuffer utils.WriteBuffer) error {
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("IdentifyReplyCommandNetworkTerminalLevels"); pushErr != nil {
+ return pushErr
+ }
+
+ if popErr := writeBuffer.PopContext("IdentifyReplyCommandNetworkTerminalLevels"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *IdentifyReplyCommandNetworkTerminalLevels) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ buffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ m.Serialize(buffer)
+ return buffer.GetBox().String()
+}
diff --git a/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandNetworkVoltage.go b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandNetworkVoltage.go
new file mode 100644
index 0000000..826471f
--- /dev/null
+++ b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandNetworkVoltage.go
@@ -0,0 +1,243 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "fmt"
+ "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+ "github.com/pkg/errors"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// Constant values.
+const IdentifyReplyCommandNetworkVoltage_DOT byte = 0x2C
+const IdentifyReplyCommandNetworkVoltage_V byte = 0x56
+
+// The data-structure of this message
+type IdentifyReplyCommandNetworkVoltage struct {
+ *IdentifyReplyCommand
+ Volts string
+ VoltsDecimalPlace string
+}
+
+// The corresponding interface
+type IIdentifyReplyCommandNetworkVoltage interface {
+ // GetVolts returns Volts
+ GetVolts() string
+ // GetVoltsDecimalPlace returns VoltsDecimalPlace
+ GetVoltsDecimalPlace() string
+ // GetLengthInBytes returns the length in bytes
+ GetLengthInBytes() uint16
+ // GetLengthInBits returns the length in bits
+ GetLengthInBits() uint16
+ // Serialize serializes this type
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+///////////////////////////////////////////////////////////
+// Accessors for discriminator values.
+///////////////////////////////////////////////////////////
+func (m *IdentifyReplyCommandNetworkVoltage) Attribute() Attribute {
+ return Attribute_NetworkVoltage
+}
+
+func (m *IdentifyReplyCommandNetworkVoltage) GetAttribute() Attribute {
+ return Attribute_NetworkVoltage
+}
+
+func (m *IdentifyReplyCommandNetworkVoltage) InitializeParent(parent *IdentifyReplyCommand) {}
+
+///////////////////////////////////////////////////////////
+// Accessors for property fields.
+///////////////////////////////////////////////////////////
+func (m *IdentifyReplyCommandNetworkVoltage) GetVolts() string {
+ return m.Volts
+}
+
+func (m *IdentifyReplyCommandNetworkVoltage) GetVoltsDecimalPlace() string {
+ return m.VoltsDecimalPlace
+}
+
+///////////////////////////////////////////////////////////
+// Accessors for virtual fields.
+///////////////////////////////////////////////////////////
+
+// NewIdentifyReplyCommandNetworkVoltage factory function for IdentifyReplyCommandNetworkVoltage
+func NewIdentifyReplyCommandNetworkVoltage(volts string, voltsDecimalPlace string) *IdentifyReplyCommand {
+ child := &IdentifyReplyCommandNetworkVoltage{
+ Volts: volts,
+ VoltsDecimalPlace: voltsDecimalPlace,
+ IdentifyReplyCommand: NewIdentifyReplyCommand(),
+ }
+ child.Child = child
+ return child.IdentifyReplyCommand
+}
+
+func CastIdentifyReplyCommandNetworkVoltage(structType interface{}) *IdentifyReplyCommandNetworkVoltage {
+ castFunc := func(typ interface{}) *IdentifyReplyCommandNetworkVoltage {
+ if casted, ok := typ.(IdentifyReplyCommandNetworkVoltage); ok {
+ return &casted
+ }
+ if casted, ok := typ.(*IdentifyReplyCommandNetworkVoltage); ok {
+ return casted
+ }
+ if casted, ok := typ.(IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandNetworkVoltage(casted.Child)
+ }
+ if casted, ok := typ.(*IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandNetworkVoltage(casted.Child)
+ }
+ return nil
+ }
+ return castFunc(structType)
+}
+
+func (m *IdentifyReplyCommandNetworkVoltage) GetTypeName() string {
+ return "IdentifyReplyCommandNetworkVoltage"
+}
+
+func (m *IdentifyReplyCommandNetworkVoltage) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *IdentifyReplyCommandNetworkVoltage) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (volts)
+ lengthInBits += 2
+
+ // Const Field (dot)
+ lengthInBits += 8
+
+ // Simple field (voltsDecimalPlace)
+ lengthInBits += 2
+
+ // Const Field (v)
+ lengthInBits += 8
+
+ return lengthInBits
+}
+
+func (m *IdentifyReplyCommandNetworkVoltage) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func IdentifyReplyCommandNetworkVoltageParse(readBuffer utils.ReadBuffer, attribute Attribute) (*IdentifyReplyCommand, error) {
+ if pullErr := readBuffer.PullContext("IdentifyReplyCommandNetworkVoltage"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := readBuffer.GetPos()
+ _ = currentPos
+
+ // Simple Field (volts)
+ _volts, _voltsErr := readBuffer.ReadString("volts", uint32(2))
+ if _voltsErr != nil {
+ return nil, errors.Wrap(_voltsErr, "Error parsing 'volts' field")
+ }
+ volts := _volts
+
+ // Const Field (dot)
+ dot, _dotErr := readBuffer.ReadByte("dot")
+ if _dotErr != nil {
+ return nil, errors.Wrap(_dotErr, "Error parsing 'dot' field")
+ }
+ if dot != IdentifyReplyCommandNetworkVoltage_DOT {
+ return nil, errors.New("Expected constant value " + fmt.Sprintf("%d", IdentifyReplyCommandNetworkVoltage_DOT) + " but got " + fmt.Sprintf("%d", dot))
+ }
+
+ // Simple Field (voltsDecimalPlace)
+ _voltsDecimalPlace, _voltsDecimalPlaceErr := readBuffer.ReadString("voltsDecimalPlace", uint32(2))
+ if _voltsDecimalPlaceErr != nil {
+ return nil, errors.Wrap(_voltsDecimalPlaceErr, "Error parsing 'voltsDecimalPlace' field")
+ }
+ voltsDecimalPlace := _voltsDecimalPlace
+
+ // Const Field (v)
+ v, _vErr := readBuffer.ReadByte("v")
+ if _vErr != nil {
+ return nil, errors.Wrap(_vErr, "Error parsing 'v' field")
+ }
+ if v != IdentifyReplyCommandNetworkVoltage_V {
+ return nil, errors.New("Expected constant value " + fmt.Sprintf("%d", IdentifyReplyCommandNetworkVoltage_V) + " but got " + fmt.Sprintf("%d", v))
+ }
+
+ if closeErr := readBuffer.CloseContext("IdentifyReplyCommandNetworkVoltage"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &IdentifyReplyCommandNetworkVoltage{
+ Volts: volts,
+ VoltsDecimalPlace: voltsDecimalPlace,
+ IdentifyReplyCommand: &IdentifyReplyCommand{},
+ }
+ _child.IdentifyReplyCommand.Child = _child
+ return _child.IdentifyReplyCommand, nil
+}
+
+func (m *IdentifyReplyCommandNetworkVoltage) Serialize(writeBuffer utils.WriteBuffer) error {
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("IdentifyReplyCommandNetworkVoltage"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (volts)
+ volts := string(m.Volts)
+ _voltsErr := writeBuffer.WriteString("volts", uint32(2), "UTF-8", (volts))
+ if _voltsErr != nil {
+ return errors.Wrap(_voltsErr, "Error serializing 'volts' field")
+ }
+
+ // Const Field (dot)
+ _dotErr := writeBuffer.WriteByte("dot", 0x2C)
+ if _dotErr != nil {
+ return errors.Wrap(_dotErr, "Error serializing 'dot' field")
+ }
+
+ // Simple Field (voltsDecimalPlace)
+ voltsDecimalPlace := string(m.VoltsDecimalPlace)
+ _voltsDecimalPlaceErr := writeBuffer.WriteString("voltsDecimalPlace", uint32(2), "UTF-8", (voltsDecimalPlace))
+ if _voltsDecimalPlaceErr != nil {
+ return errors.Wrap(_voltsDecimalPlaceErr, "Error serializing 'voltsDecimalPlace' field")
+ }
+
+ // Const Field (v)
+ _vErr := writeBuffer.WriteByte("v", 0x56)
+ if _vErr != nil {
+ return errors.Wrap(_vErr, "Error serializing 'v' field")
+ }
+
+ if popErr := writeBuffer.PopContext("IdentifyReplyCommandNetworkVoltage"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *IdentifyReplyCommandNetworkVoltage) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ buffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ m.Serialize(buffer)
+ return buffer.GetBox().String()
+}
diff --git a/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandOutputUnitSummary.go b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandOutputUnitSummary.go
new file mode 100644
index 0000000..27f676c
--- /dev/null
+++ b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandOutputUnitSummary.go
@@ -0,0 +1,150 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// The data-structure of this message
+type IdentifyReplyCommandOutputUnitSummary struct {
+ *IdentifyReplyCommand
+}
+
+// The corresponding interface
+type IIdentifyReplyCommandOutputUnitSummary interface {
+ // GetLengthInBytes returns the length in bytes
+ GetLengthInBytes() uint16
+ // GetLengthInBits returns the length in bits
+ GetLengthInBits() uint16
+ // Serialize serializes this type
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+///////////////////////////////////////////////////////////
+// Accessors for discriminator values.
+///////////////////////////////////////////////////////////
+func (m *IdentifyReplyCommandOutputUnitSummary) Attribute() Attribute {
+ return Attribute_OutputUnitSummary
+}
+
+func (m *IdentifyReplyCommandOutputUnitSummary) GetAttribute() Attribute {
+ return Attribute_OutputUnitSummary
+}
+
+func (m *IdentifyReplyCommandOutputUnitSummary) InitializeParent(parent *IdentifyReplyCommand) {}
+
+///////////////////////////////////////////////////////////
+// Accessors for property fields.
+///////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////
+// Accessors for virtual fields.
+///////////////////////////////////////////////////////////
+
+// NewIdentifyReplyCommandOutputUnitSummary factory function for IdentifyReplyCommandOutputUnitSummary
+func NewIdentifyReplyCommandOutputUnitSummary() *IdentifyReplyCommand {
+ child := &IdentifyReplyCommandOutputUnitSummary{
+ IdentifyReplyCommand: NewIdentifyReplyCommand(),
+ }
+ child.Child = child
+ return child.IdentifyReplyCommand
+}
+
+func CastIdentifyReplyCommandOutputUnitSummary(structType interface{}) *IdentifyReplyCommandOutputUnitSummary {
+ castFunc := func(typ interface{}) *IdentifyReplyCommandOutputUnitSummary {
+ if casted, ok := typ.(IdentifyReplyCommandOutputUnitSummary); ok {
+ return &casted
+ }
+ if casted, ok := typ.(*IdentifyReplyCommandOutputUnitSummary); ok {
+ return casted
+ }
+ if casted, ok := typ.(IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandOutputUnitSummary(casted.Child)
+ }
+ if casted, ok := typ.(*IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandOutputUnitSummary(casted.Child)
+ }
+ return nil
+ }
+ return castFunc(structType)
+}
+
+func (m *IdentifyReplyCommandOutputUnitSummary) GetTypeName() string {
+ return "IdentifyReplyCommandOutputUnitSummary"
+}
+
+func (m *IdentifyReplyCommandOutputUnitSummary) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *IdentifyReplyCommandOutputUnitSummary) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ return lengthInBits
+}
+
+func (m *IdentifyReplyCommandOutputUnitSummary) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func IdentifyReplyCommandOutputUnitSummaryParse(readBuffer utils.ReadBuffer, attribute Attribute) (*IdentifyReplyCommand, error) {
+ if pullErr := readBuffer.PullContext("IdentifyReplyCommandOutputUnitSummary"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := readBuffer.GetPos()
+ _ = currentPos
+
+ if closeErr := readBuffer.CloseContext("IdentifyReplyCommandOutputUnitSummary"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &IdentifyReplyCommandOutputUnitSummary{
+ IdentifyReplyCommand: &IdentifyReplyCommand{},
+ }
+ _child.IdentifyReplyCommand.Child = _child
+ return _child.IdentifyReplyCommand, nil
+}
+
+func (m *IdentifyReplyCommandOutputUnitSummary) Serialize(writeBuffer utils.WriteBuffer) error {
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("IdentifyReplyCommandOutputUnitSummary"); pushErr != nil {
+ return pushErr
+ }
+
+ if popErr := writeBuffer.PopContext("IdentifyReplyCommandOutputUnitSummary"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *IdentifyReplyCommandOutputUnitSummary) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ buffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ m.Serialize(buffer)
+ return buffer.GetBox().String()
+}
diff --git a/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandTerminalLevels.go b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandTerminalLevels.go
new file mode 100644
index 0000000..04c07c4
--- /dev/null
+++ b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandTerminalLevels.go
@@ -0,0 +1,150 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// The data-structure of this message
+type IdentifyReplyCommandTerminalLevels struct {
+ *IdentifyReplyCommand
+}
+
+// The corresponding interface
+type IIdentifyReplyCommandTerminalLevels interface {
+ // GetLengthInBytes returns the length in bytes
+ GetLengthInBytes() uint16
+ // GetLengthInBits returns the length in bits
+ GetLengthInBits() uint16
+ // Serialize serializes this type
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+///////////////////////////////////////////////////////////
+// Accessors for discriminator values.
+///////////////////////////////////////////////////////////
+func (m *IdentifyReplyCommandTerminalLevels) Attribute() Attribute {
+ return Attribute_TerminalLevel
+}
+
+func (m *IdentifyReplyCommandTerminalLevels) GetAttribute() Attribute {
+ return Attribute_TerminalLevel
+}
+
+func (m *IdentifyReplyCommandTerminalLevels) InitializeParent(parent *IdentifyReplyCommand) {}
+
+///////////////////////////////////////////////////////////
+// Accessors for property fields.
+///////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////
+// Accessors for virtual fields.
+///////////////////////////////////////////////////////////
+
+// NewIdentifyReplyCommandTerminalLevels factory function for IdentifyReplyCommandTerminalLevels
+func NewIdentifyReplyCommandTerminalLevels() *IdentifyReplyCommand {
+ child := &IdentifyReplyCommandTerminalLevels{
+ IdentifyReplyCommand: NewIdentifyReplyCommand(),
+ }
+ child.Child = child
+ return child.IdentifyReplyCommand
+}
+
+func CastIdentifyReplyCommandTerminalLevels(structType interface{}) *IdentifyReplyCommandTerminalLevels {
+ castFunc := func(typ interface{}) *IdentifyReplyCommandTerminalLevels {
+ if casted, ok := typ.(IdentifyReplyCommandTerminalLevels); ok {
+ return &casted
+ }
+ if casted, ok := typ.(*IdentifyReplyCommandTerminalLevels); ok {
+ return casted
+ }
+ if casted, ok := typ.(IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandTerminalLevels(casted.Child)
+ }
+ if casted, ok := typ.(*IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandTerminalLevels(casted.Child)
+ }
+ return nil
+ }
+ return castFunc(structType)
+}
+
+func (m *IdentifyReplyCommandTerminalLevels) GetTypeName() string {
+ return "IdentifyReplyCommandTerminalLevels"
+}
+
+func (m *IdentifyReplyCommandTerminalLevels) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *IdentifyReplyCommandTerminalLevels) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ return lengthInBits
+}
+
+func (m *IdentifyReplyCommandTerminalLevels) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func IdentifyReplyCommandTerminalLevelsParse(readBuffer utils.ReadBuffer, attribute Attribute) (*IdentifyReplyCommand, error) {
+ if pullErr := readBuffer.PullContext("IdentifyReplyCommandTerminalLevels"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := readBuffer.GetPos()
+ _ = currentPos
+
+ if closeErr := readBuffer.CloseContext("IdentifyReplyCommandTerminalLevels"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &IdentifyReplyCommandTerminalLevels{
+ IdentifyReplyCommand: &IdentifyReplyCommand{},
+ }
+ _child.IdentifyReplyCommand.Child = _child
+ return _child.IdentifyReplyCommand, nil
+}
+
+func (m *IdentifyReplyCommandTerminalLevels) Serialize(writeBuffer utils.WriteBuffer) error {
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("IdentifyReplyCommandTerminalLevels"); pushErr != nil {
+ return pushErr
+ }
+
+ if popErr := writeBuffer.PopContext("IdentifyReplyCommandTerminalLevels"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *IdentifyReplyCommandTerminalLevels) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ buffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ m.Serialize(buffer)
+ return buffer.GetBox().String()
+}
diff --git a/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandType.go b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandType.go
new file mode 100644
index 0000000..2e50b94
--- /dev/null
+++ b/plc4go/internal/plc4go/cbus/readwrite/model/IdentifyReplyCommandType.go
@@ -0,0 +1,176 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+ "github.com/pkg/errors"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// The data-structure of this message
+type IdentifyReplyCommandType struct {
+ *IdentifyReplyCommand
+ UnitType string
+}
+
+// The corresponding interface
+type IIdentifyReplyCommandType interface {
+ // GetUnitType returns UnitType
+ GetUnitType() string
+ // GetLengthInBytes returns the length in bytes
+ GetLengthInBytes() uint16
+ // GetLengthInBits returns the length in bits
+ GetLengthInBits() uint16
+ // Serialize serializes this type
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+///////////////////////////////////////////////////////////
+// Accessors for discriminator values.
+///////////////////////////////////////////////////////////
+func (m *IdentifyReplyCommandType) Attribute() Attribute {
+ return Attribute_Type
+}
+
+func (m *IdentifyReplyCommandType) GetAttribute() Attribute {
+ return Attribute_Type
+}
+
+func (m *IdentifyReplyCommandType) InitializeParent(parent *IdentifyReplyCommand) {}
+
+///////////////////////////////////////////////////////////
+// Accessors for property fields.
+///////////////////////////////////////////////////////////
+func (m *IdentifyReplyCommandType) GetUnitType() string {
+ return m.UnitType
+}
+
+///////////////////////////////////////////////////////////
+// Accessors for virtual fields.
+///////////////////////////////////////////////////////////
+
+// NewIdentifyReplyCommandType factory function for IdentifyReplyCommandType
+func NewIdentifyReplyCommandType(unitType string) *IdentifyReplyCommand {
+ child := &IdentifyReplyCommandType{
+ UnitType: unitType,
+ IdentifyReplyCommand: NewIdentifyReplyCommand(),
+ }
+ child.Child = child
+ return child.IdentifyReplyCommand
+}
+
+func CastIdentifyReplyCommandType(structType interface{}) *IdentifyReplyCommandType {
+ castFunc := func(typ interface{}) *IdentifyReplyCommandType {
+ if casted, ok := typ.(IdentifyReplyCommandType); ok {
+ return &casted
+ }
+ if casted, ok := typ.(*IdentifyReplyCommandType); ok {
+ return casted
+ }
+ if casted, ok := typ.(IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandType(casted.Child)
+ }
+ if casted, ok := typ.(*IdentifyReplyCommand); ok {
+ return CastIdentifyReplyCommandType(casted.Child)
+ }
+ return nil
+ }
+ return castFunc(structType)
+}
+
+func (m *IdentifyReplyCommandType) GetTypeName() string {
+ return "IdentifyReplyCommandType"
+}
+
+func (m *IdentifyReplyCommandType) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *IdentifyReplyCommandType) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (unitType)
+ lengthInBits += 64
+
+ return lengthInBits
+}
+
+func (m *IdentifyReplyCommandType) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func IdentifyReplyCommandTypeParse(readBuffer utils.ReadBuffer, attribute Attribute) (*IdentifyReplyCommand, error) {
+ if pullErr := readBuffer.PullContext("IdentifyReplyCommandType"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := readBuffer.GetPos()
+ _ = currentPos
+
+ // Simple Field (unitType)
+ _unitType, _unitTypeErr := readBuffer.ReadString("unitType", uint32(64))
+ if _unitTypeErr != nil {
+ return nil, errors.Wrap(_unitTypeErr, "Error parsing 'unitType' field")
+ }
+ unitType := _unitType
+
+ if closeErr := readBuffer.CloseContext("IdentifyReplyCommandType"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &IdentifyReplyCommandType{
+ UnitType: unitType,
+ IdentifyReplyCommand: &IdentifyReplyCommand{},
+ }
+ _child.IdentifyReplyCommand.Child = _child
+ return _child.IdentifyReplyCommand, nil
+}
+
+func (m *IdentifyReplyCommandType) Serialize(writeBuffer utils.WriteBuffer) error {
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("IdentifyReplyCommandType"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (unitType)
+ unitType := string(m.UnitType)
+ _unitTypeErr := writeBuffer.WriteString("unitType", uint32(64), "UTF-8", (unitType))
+ if _unitTypeErr != nil {
+ return errors.Wrap(_unitTypeErr, "Error serializing 'unitType' field")
+ }
+
+ if popErr := writeBuffer.PopContext("IdentifyReplyCommandType"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *IdentifyReplyCommandType) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ buffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ m.Serialize(buffer)
+ return buffer.GetBox().String()
+}
diff --git a/plc4go/internal/plc4go/cbus/readwrite/model/UnitStatus.go b/plc4go/internal/plc4go/cbus/readwrite/model/UnitStatus.go
new file mode 100644
index 0000000..a991d8c
--- /dev/null
+++ b/plc4go/internal/plc4go/cbus/readwrite/model/UnitStatus.go
@@ -0,0 +1,129 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+ "github.com/pkg/errors"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+type UnitStatus uint8
+
+type IUnitStatus interface {
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+const (
+ UnitStatus_OK UnitStatus = 0
+ UnitStatus_NACK UnitStatus = 1
+ UnitStatus_NO_RESPONSE UnitStatus = 2
+)
+
+var UnitStatusValues []UnitStatus
+
+func init() {
+ _ = errors.New
+ UnitStatusValues = []UnitStatus{
+ UnitStatus_OK,
+ UnitStatus_NACK,
+ UnitStatus_NO_RESPONSE,
+ }
+}
+
+func UnitStatusByValue(value uint8) UnitStatus {
+ switch value {
+ case 0:
+ return UnitStatus_OK
+ case 1:
+ return UnitStatus_NACK
+ case 2:
+ return UnitStatus_NO_RESPONSE
+ }
+ return 0
+}
+
+func UnitStatusByName(value string) UnitStatus {
+ switch value {
+ case "OK":
+ return UnitStatus_OK
+ case "NACK":
+ return UnitStatus_NACK
+ case "NO_RESPONSE":
+ return UnitStatus_NO_RESPONSE
+ }
+ return 0
+}
+
+func UnitStatusKnows(value uint8) bool {
+ for _, typeValue := range UnitStatusValues {
+ if uint8(typeValue) == value {
+ return true
+ }
+ }
+ return false
+}
+
+func CastUnitStatus(structType interface{}) UnitStatus {
+ castFunc := func(typ interface{}) UnitStatus {
+ if sUnitStatus, ok := typ.(UnitStatus); ok {
+ return sUnitStatus
+ }
+ return 0
+ }
+ return castFunc(structType)
+}
+
+func (m UnitStatus) GetLengthInBits() uint16 {
+ return 8
+}
+
+func (m UnitStatus) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func UnitStatusParse(readBuffer utils.ReadBuffer) (UnitStatus, error) {
+ val, err := readBuffer.ReadUint8("UnitStatus", 8)
+ if err != nil {
+ return 0, nil
+ }
+ return UnitStatusByValue(val), nil
+}
+
+func (e UnitStatus) Serialize(writeBuffer utils.WriteBuffer) error {
+ return writeBuffer.WriteUint8("UnitStatus", 8, uint8(e), utils.WithAdditionalStringRepresentation(e.name()))
+}
+
+func (e UnitStatus) name() string {
+ switch e {
+ case UnitStatus_OK:
+ return "OK"
+ case UnitStatus_NACK:
+ return "NACK"
+ case UnitStatus_NO_RESPONSE:
+ return "NO_RESPONSE"
+ }
+ return ""
+}
+
+func (e UnitStatus) String() string {
+ return e.name()
+}
diff --git a/protocols/c-bus/src/main/resources/protocols/cbus/c-bus.mspec b/protocols/c-bus/src/main/resources/protocols/cbus/c-bus.mspec
index de870c4..ba44d32 100644
--- a/protocols/c-bus/src/main/resources/protocols/cbus/c-bus.mspec
+++ b/protocols/c-bus/src/main/resources/protocols/cbus/c-bus.mspec
@@ -231,6 +231,112 @@
['0x11' DSIStatus ['10']]
]
+[type IdentifyReplyCommand(Attribute attribute)
+ [typeSwitch attribute
+ ['Manufacturer' IdentifyReplyCommandManufacturer
+ [simple string 64 manufacturerName ]
+ ]
+ ['Type' IdentifyReplyCommandType
+ [simple string 64 unitType ]
+ ]
+ ['FirmwareVersion' IdentifyReplyCommandFirmwareVersion
+ [simple string 64 firmwareVersion ]
+ ]
+ ['Summary' IdentifyReplyCommandFirmwareSummary
+ [simple string 48 firmwareVersion ]
+ [simple byte unitServiceType ]
+ [simple string 32 version ]
+ ]
+ ['ExtendedDiagnosticSummary' IdentifyReplyCommandExtendedDiagnosticSummary
+ [simple Application lowApplication ]
+ [simple Application highApplication ]
+ [simple byte area ]
+ [simple uint 16 crc ]
+ [simple uint 32 serialNumber ]
+ [simple byte networkVoltage ]
+ [simple bit outputUnit ]
+ [simple bit enableChecksumAlarm ]
+ [reserved uint 1 '0' ]
+ [reserved uint 1 '0' ]
+ [reserved uint 1 '0' ]
+ [simple bit networkVoltageMarginal ]
+ [simple bit networkVoltageLow ]
+ [simple bit unitInLearnMode ]
+ [simple bit microPowerReset ]
+ [simple bit internalStackOverflow ]
+ [simple bit commsTxError ]
+ [simple bit microReset ]
+ [simple bit EEDataError ]
+ [simple bit EEChecksumError ]
+ [simple bit EEWriteError ]
+ [simple bit installationMMIError ]
+ ]
+ ['NetworkTerminalLevels' IdentifyReplyCommandNetworkTerminalLevels
+ //TODO: read dynamic
+ ]
+ ['TerminalLevel' IdentifyReplyCommandTerminalLevels
+ //TODO: read dynamic
+ ]
+ ['NetworkVoltage' IdentifyReplyCommandNetworkVoltage
+ [simple string 2 volts ]
+ [const byte dot 0x2C ]
+ [simple string 2 voltsDecimalPlace ]
+ [const byte v 0x56 ]
+ ]
+ ['GAVValuesCurrent' IdentifyReplyCommandGAVValuesCurrent
+ [array byte values count '16' ] // TODO: check datatype
+ ]
+ ['GAVValuesStored' IdentifyReplyCommandGAVValuesStored
+ [array byte values count '16' ] // TODO: check datatype
+ ]
+ ['GAVPhysicalAddresses' IdentifyReplyCommandGAVPhysicalAddresses
+ [array byte values count '16' ] // TODO: check datatype
+ ]
+ ['LogicalAssignment' IdentifyReplyCommandLogicalAssignment
+ //TODO: read dynamic
+ ]
+ ['Delays' IdentifyReplyCommandDelays
+ //TODO: read dynamic
+ ]
+ ['MinimumLevels' IdentifyReplyCommandMinimumLevels
+ //TODO: read dynamic
+ ]
+ ['MaximumLevels' IdentifyReplyCommandMaximumLevels
+ //TODO: read dynamic
+ ]
+ ['CurrentSenseLevels' IdentifyReplyCommandCurrentSenseLevels
+ //TODO: read dynamic
+ ]
+ ['OutputUnitSummary' IdentifyReplyCommandOutputUnitSummary
+ //TODO: read dynamic
+ ]
+ ['DSIStatus' IdentifyReplyCommandDSIStatus
+ [simple ChannelStatus channelStatus1 ]
+ [simple ChannelStatus channelStatus2 ]
+ [simple ChannelStatus channelStatus3 ]
+ [simple ChannelStatus channelStatus4 ]
+ [simple ChannelStatus channelStatus5 ]
+ [simple ChannelStatus channelStatus6 ]
+ [simple ChannelStatus channelStatus7 ]
+ [simple ChannelStatus channelStatus8 ]
+ [simple UnitStatus unitStatus ]
+ [simple byte dimmingUCRevisionNumber ]
+ ]
+ ]
+]
+
+[enum uint 8 ChannelStatus
+ ['0' OK ]
+ ['2' LAMP_FAULT ]
+ ['3' CURRENT_LIMIT_OR_SHORT ]
+]
+
+[enum uint 8 UnitStatus
+ ['0' OK ]
+ ['1' NACK ]
+ ['2' NO_RESPONSE ]
+]
+
[enum uint 8 CALCommandTypeContainer(CALCommandType commandType, uint 5 numBytes)
['0x08' CALCommandReset ['RESET', '0']]
['0x1A' CALCommandRecall ['RECALL', '0']]