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/07/19 15:04:54 UTC
[plc4x] 02/02: feat(cbus): implemented error reporting application
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
commit cc4f30d87e56475599ae8ba7e8dd8aec64cafcd6
Author: Sebastian Rühl <sr...@apache.org>
AuthorDate: Tue Jul 19 17:04:44 2022 +0200
feat(cbus): implemented error reporting application
---
plc4go/protocols/cbus/readwrite/ParserHelper.go | 7 +
plc4go/protocols/cbus/readwrite/XmlParserHelper.go | 7 +
.../cbus/readwrite/model/ApplicationId.go | 8 +
.../cbus/readwrite/model/ApplicationIdContainer.go | 2 +-
.../readwrite/model/ErrorReportingCommandType.go | 145 +++++++
.../model/ErrorReportingCommandTypeContainer.go | 214 ++++++++++
.../cbus/readwrite/model/ErrorReportingData.go | 245 +++++++++++
.../readwrite/model/ErrorReportingDataGeneric.go | 459 +++++++++++++++++++++
.../cbus/readwrite/model/ErrorReportingSeverity.go | 177 ++++++++
.../model/ErrorReportingSystemCategory.go | 238 +++++++++++
.../model/ErrorReportingSystemCategoryClass.go | 241 +++++++++++
.../model/ErrorReportingSystemCategoryType.go | 182 ++++++++
...gSystemCategoryTypeBuildingManagementSystems.go | 204 +++++++++
...eportingSystemCategoryTypeClimateControllers.go | 204 +++++++++
...stemCategoryTypeForBuildingManagementSystems.go | 241 +++++++++++
...rtingSystemCategoryTypeForClimateControllers.go | 241 +++++++++++
...rrorReportingSystemCategoryTypeForInputUnits.go | 241 +++++++++++
...rorReportingSystemCategoryTypeForOutputUnits.go | 241 +++++++++++
...orReportingSystemCategoryTypeForSupportUnits.go | 241 +++++++++++
.../ErrorReportingSystemCategoryTypeInputUnits.go | 204 +++++++++
.../ErrorReportingSystemCategoryTypeOutputUnits.go | 204 +++++++++
.../ErrorReportingSystemCategoryTypeReserved.go | 193 +++++++++
...ErrorReportingSystemCategoryTypeSupportUnits.go | 204 +++++++++
.../model/ErrorReportingSystemCategoryVariant.go | 145 +++++++
plc4go/protocols/cbus/readwrite/model/SALData.go | 2 +
.../cbus/readwrite/model/SALDataErrorReporting.go | 205 +++++++++
.../protocols/cbus/readwrite/model/StaticHelper.go | 10 +
.../java/cbus/readwrite/utils/StaticHelper.java | 11 +
.../org/apache/plc4x/java/cbus/ReferenceTest.java | 116 ++++++
.../src/main/resources/protocols/cbus/c-bus.mspec | 205 ++++++++-
30 files changed, 5035 insertions(+), 2 deletions(-)
diff --git a/plc4go/protocols/cbus/readwrite/ParserHelper.go b/plc4go/protocols/cbus/readwrite/ParserHelper.go
index f842b4617..d39b77f16 100644
--- a/plc4go/protocols/cbus/readwrite/ParserHelper.go
+++ b/plc4go/protocols/cbus/readwrite/ParserHelper.go
@@ -80,6 +80,8 @@ func (m CbusParserHelper) Parse(typeName string, arguments []string, io utils.Re
return model.CALDataOrSetParameterParse(io)
case "TemperatureBroadcastData":
return model.TemperatureBroadcastDataParse(io)
+ case "ErrorReportingSystemCategory":
+ return model.ErrorReportingSystemCategoryParse(io)
case "PanicStatus":
return model.PanicStatusParse(io)
case "IdentifyReplyCommandUnitSummary":
@@ -111,6 +113,9 @@ func (m CbusParserHelper) Parse(typeName string, arguments []string, io utils.Re
return model.ReplyNetworkParse(io)
case "SerialNumber":
return model.SerialNumberParse(io)
+ case "ErrorReportingSystemCategoryType":
+ errorReportingSystemCategoryClass, _ := model.ErrorReportingSystemCategoryClassByName(arguments[0])
+ return model.ErrorReportingSystemCategoryTypeParse(io, errorReportingSystemCategoryClass)
case "Confirmation":
return model.ConfirmationParse(io)
case "CBusPointToMultiPointCommand":
@@ -217,6 +222,8 @@ func (m CbusParserHelper) Parse(typeName string, arguments []string, io utils.Re
var cBusOptions model.CBusOptions
var requestContext model.RequestContext
return model.EncodedReplyParse(io, cBusOptions, requestContext)
+ case "ErrorReportingData":
+ return model.ErrorReportingDataParse(io)
case "UnitAddress":
return model.UnitAddressParse(io)
case "ExtendedFormatStatusReply":
diff --git a/plc4go/protocols/cbus/readwrite/XmlParserHelper.go b/plc4go/protocols/cbus/readwrite/XmlParserHelper.go
index fe878ee0d..0ad9d2310 100644
--- a/plc4go/protocols/cbus/readwrite/XmlParserHelper.go
+++ b/plc4go/protocols/cbus/readwrite/XmlParserHelper.go
@@ -93,6 +93,8 @@ func (m CbusXmlParserHelper) Parse(typeName string, xmlString string, parserArgu
return model.CALDataOrSetParameterParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
case "TemperatureBroadcastData":
return model.TemperatureBroadcastDataParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
+ case "ErrorReportingSystemCategory":
+ return model.ErrorReportingSystemCategoryParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
case "PanicStatus":
return model.PanicStatusParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
case "IdentifyReplyCommandUnitSummary":
@@ -128,6 +130,9 @@ func (m CbusXmlParserHelper) Parse(typeName string, xmlString string, parserArgu
return model.ReplyNetworkParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
case "SerialNumber":
return model.SerialNumberParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
+ case "ErrorReportingSystemCategoryType":
+ errorReportingSystemCategoryClass, _ := model.ErrorReportingSystemCategoryClassByName(parserArguments[0])
+ return model.ErrorReportingSystemCategoryTypeParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)), errorReportingSystemCategoryClass)
case "Confirmation":
return model.ConfirmationParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
case "CBusPointToMultiPointCommand":
@@ -244,6 +249,8 @@ func (m CbusXmlParserHelper) Parse(typeName string, xmlString string, parserArgu
// TODO: find a way to parse the sub types
var requestContext model.RequestContext
return model.EncodedReplyParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)), cBusOptions, requestContext)
+ case "ErrorReportingData":
+ return model.ErrorReportingDataParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
case "UnitAddress":
return model.UnitAddressParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
case "ExtendedFormatStatusReply":
diff --git a/plc4go/protocols/cbus/readwrite/model/ApplicationId.go b/plc4go/protocols/cbus/readwrite/model/ApplicationId.go
index a344c03cf..dd9528fa2 100644
--- a/plc4go/protocols/cbus/readwrite/model/ApplicationId.go
+++ b/plc4go/protocols/cbus/readwrite/model/ApplicationId.go
@@ -56,6 +56,7 @@ const (
ApplicationId_MEASUREMENT ApplicationId = 0x12
ApplicationId_TESTING ApplicationId = 0x13
ApplicationId_MEDIA_TRANSPORT_CONTROL ApplicationId = 0x14
+ ApplicationId_ERROR_REPORTING ApplicationId = 0x15
)
var ApplicationIdValues []ApplicationId
@@ -84,6 +85,7 @@ func init() {
ApplicationId_MEASUREMENT,
ApplicationId_TESTING,
ApplicationId_MEDIA_TRANSPORT_CONTROL,
+ ApplicationId_ERROR_REPORTING,
}
}
@@ -131,6 +133,8 @@ func ApplicationIdByValue(value uint8) (enum ApplicationId, ok bool) {
return ApplicationId_TESTING, true
case 0x14:
return ApplicationId_MEDIA_TRANSPORT_CONTROL, true
+ case 0x15:
+ return ApplicationId_ERROR_REPORTING, true
}
return 0, false
}
@@ -179,6 +183,8 @@ func ApplicationIdByName(value string) (enum ApplicationId, ok bool) {
return ApplicationId_TESTING, true
case "MEDIA_TRANSPORT_CONTROL":
return ApplicationId_MEDIA_TRANSPORT_CONTROL, true
+ case "ERROR_REPORTING":
+ return ApplicationId_ERROR_REPORTING, true
}
return 0, false
}
@@ -272,6 +278,8 @@ func (e ApplicationId) PLC4XEnumName() string {
return "TESTING"
case ApplicationId_MEDIA_TRANSPORT_CONTROL:
return "MEDIA_TRANSPORT_CONTROL"
+ case ApplicationId_ERROR_REPORTING:
+ return "ERROR_REPORTING"
}
return ""
}
diff --git a/plc4go/protocols/cbus/readwrite/model/ApplicationIdContainer.go b/plc4go/protocols/cbus/readwrite/model/ApplicationIdContainer.go
index bd885caad..2f36e0adb 100644
--- a/plc4go/protocols/cbus/readwrite/model/ApplicationIdContainer.go
+++ b/plc4go/protocols/cbus/readwrite/model/ApplicationIdContainer.go
@@ -2429,7 +2429,7 @@ func (e ApplicationIdContainer) ApplicationId() ApplicationId {
}
case 0xCE:
{ /* '0xCE' */
- return ApplicationId_RESERVED
+ return ApplicationId_ERROR_REPORTING
}
case 0xCF:
{ /* '0xCF' */
diff --git a/plc4go/protocols/cbus/readwrite/model/ErrorReportingCommandType.go b/plc4go/protocols/cbus/readwrite/model/ErrorReportingCommandType.go
new file mode 100644
index 000000000..5747d12f2
--- /dev/null
+++ b/plc4go/protocols/cbus/readwrite/model/ErrorReportingCommandType.go
@@ -0,0 +1,145 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/spi/utils"
+ "github.com/pkg/errors"
+ "github.com/rs/zerolog/log"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// ErrorReportingCommandType is an enum
+type ErrorReportingCommandType uint8
+
+type IErrorReportingCommandType interface {
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+const (
+ ErrorReportingCommandType_DEPRECATED ErrorReportingCommandType = 0x00
+ ErrorReportingCommandType_ERROR_REPORT ErrorReportingCommandType = 0x01
+ ErrorReportingCommandType_ACKNOWLEDGE ErrorReportingCommandType = 0x02
+ ErrorReportingCommandType_CLEAR_MOST_SEVERE ErrorReportingCommandType = 0x03
+)
+
+var ErrorReportingCommandTypeValues []ErrorReportingCommandType
+
+func init() {
+ _ = errors.New
+ ErrorReportingCommandTypeValues = []ErrorReportingCommandType{
+ ErrorReportingCommandType_DEPRECATED,
+ ErrorReportingCommandType_ERROR_REPORT,
+ ErrorReportingCommandType_ACKNOWLEDGE,
+ ErrorReportingCommandType_CLEAR_MOST_SEVERE,
+ }
+}
+
+func ErrorReportingCommandTypeByValue(value uint8) (enum ErrorReportingCommandType, ok bool) {
+ switch value {
+ case 0x00:
+ return ErrorReportingCommandType_DEPRECATED, true
+ case 0x01:
+ return ErrorReportingCommandType_ERROR_REPORT, true
+ case 0x02:
+ return ErrorReportingCommandType_ACKNOWLEDGE, true
+ case 0x03:
+ return ErrorReportingCommandType_CLEAR_MOST_SEVERE, true
+ }
+ return 0, false
+}
+
+func ErrorReportingCommandTypeByName(value string) (enum ErrorReportingCommandType, ok bool) {
+ switch value {
+ case "DEPRECATED":
+ return ErrorReportingCommandType_DEPRECATED, true
+ case "ERROR_REPORT":
+ return ErrorReportingCommandType_ERROR_REPORT, true
+ case "ACKNOWLEDGE":
+ return ErrorReportingCommandType_ACKNOWLEDGE, true
+ case "CLEAR_MOST_SEVERE":
+ return ErrorReportingCommandType_CLEAR_MOST_SEVERE, true
+ }
+ return 0, false
+}
+
+func ErrorReportingCommandTypeKnows(value uint8) bool {
+ for _, typeValue := range ErrorReportingCommandTypeValues {
+ if uint8(typeValue) == value {
+ return true
+ }
+ }
+ return false
+}
+
+func CastErrorReportingCommandType(structType interface{}) ErrorReportingCommandType {
+ castFunc := func(typ interface{}) ErrorReportingCommandType {
+ if sErrorReportingCommandType, ok := typ.(ErrorReportingCommandType); ok {
+ return sErrorReportingCommandType
+ }
+ return 0
+ }
+ return castFunc(structType)
+}
+
+func (m ErrorReportingCommandType) GetLengthInBits() uint16 {
+ return 4
+}
+
+func (m ErrorReportingCommandType) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func ErrorReportingCommandTypeParse(readBuffer utils.ReadBuffer) (ErrorReportingCommandType, error) {
+ val, err := readBuffer.ReadUint8("ErrorReportingCommandType", 4)
+ if err != nil {
+ return 0, errors.Wrap(err, "error reading ErrorReportingCommandType")
+ }
+ if enum, ok := ErrorReportingCommandTypeByValue(val); !ok {
+ log.Debug().Msgf("no value %x found for RequestType", val)
+ return ErrorReportingCommandType(val), nil
+ } else {
+ return enum, nil
+ }
+}
+
+func (e ErrorReportingCommandType) Serialize(writeBuffer utils.WriteBuffer) error {
+ return writeBuffer.WriteUint8("ErrorReportingCommandType", 4, uint8(e), utils.WithAdditionalStringRepresentation(e.PLC4XEnumName()))
+}
+
+// PLC4XEnumName returns the name that is used in code to identify this enum
+func (e ErrorReportingCommandType) PLC4XEnumName() string {
+ switch e {
+ case ErrorReportingCommandType_DEPRECATED:
+ return "DEPRECATED"
+ case ErrorReportingCommandType_ERROR_REPORT:
+ return "ERROR_REPORT"
+ case ErrorReportingCommandType_ACKNOWLEDGE:
+ return "ACKNOWLEDGE"
+ case ErrorReportingCommandType_CLEAR_MOST_SEVERE:
+ return "CLEAR_MOST_SEVERE"
+ }
+ return ""
+}
+
+func (e ErrorReportingCommandType) String() string {
+ return e.PLC4XEnumName()
+}
diff --git a/plc4go/protocols/cbus/readwrite/model/ErrorReportingCommandTypeContainer.go b/plc4go/protocols/cbus/readwrite/model/ErrorReportingCommandTypeContainer.go
new file mode 100644
index 000000000..c7932f805
--- /dev/null
+++ b/plc4go/protocols/cbus/readwrite/model/ErrorReportingCommandTypeContainer.go
@@ -0,0 +1,214 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/spi/utils"
+ "github.com/pkg/errors"
+ "github.com/rs/zerolog/log"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// ErrorReportingCommandTypeContainer is an enum
+type ErrorReportingCommandTypeContainer uint8
+
+type IErrorReportingCommandTypeContainer interface {
+ NumBytes() uint8
+ CommandType() ErrorReportingCommandType
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+const (
+ ErrorReportingCommandTypeContainer_ErrorReportingCommandDeprecated ErrorReportingCommandTypeContainer = 0x05
+ ErrorReportingCommandTypeContainer_ErrorReportingCommandErrorReport ErrorReportingCommandTypeContainer = 0x15
+ ErrorReportingCommandTypeContainer_ErrorReportingCommandAcknowledge ErrorReportingCommandTypeContainer = 0x25
+ ErrorReportingCommandTypeContainer_ErrorReportingCommandClearMostSevere ErrorReportingCommandTypeContainer = 0x35
+)
+
+var ErrorReportingCommandTypeContainerValues []ErrorReportingCommandTypeContainer
+
+func init() {
+ _ = errors.New
+ ErrorReportingCommandTypeContainerValues = []ErrorReportingCommandTypeContainer{
+ ErrorReportingCommandTypeContainer_ErrorReportingCommandDeprecated,
+ ErrorReportingCommandTypeContainer_ErrorReportingCommandErrorReport,
+ ErrorReportingCommandTypeContainer_ErrorReportingCommandAcknowledge,
+ ErrorReportingCommandTypeContainer_ErrorReportingCommandClearMostSevere,
+ }
+}
+
+func (e ErrorReportingCommandTypeContainer) NumBytes() uint8 {
+ switch e {
+ case 0x05:
+ { /* '0x05' */
+ return 5
+ }
+ case 0x15:
+ { /* '0x15' */
+ return 5
+ }
+ case 0x25:
+ { /* '0x25' */
+ return 5
+ }
+ case 0x35:
+ { /* '0x35' */
+ return 5
+ }
+ default:
+ {
+ return 0
+ }
+ }
+}
+
+func ErrorReportingCommandTypeContainerFirstEnumForFieldNumBytes(value uint8) (ErrorReportingCommandTypeContainer, error) {
+ for _, sizeValue := range ErrorReportingCommandTypeContainerValues {
+ if sizeValue.NumBytes() == value {
+ return sizeValue, nil
+ }
+ }
+ return 0, errors.Errorf("enum for %v describing NumBytes not found", value)
+}
+
+func (e ErrorReportingCommandTypeContainer) CommandType() ErrorReportingCommandType {
+ switch e {
+ case 0x05:
+ { /* '0x05' */
+ return ErrorReportingCommandType_DEPRECATED
+ }
+ case 0x15:
+ { /* '0x15' */
+ return ErrorReportingCommandType_ERROR_REPORT
+ }
+ case 0x25:
+ { /* '0x25' */
+ return ErrorReportingCommandType_ACKNOWLEDGE
+ }
+ case 0x35:
+ { /* '0x35' */
+ return ErrorReportingCommandType_CLEAR_MOST_SEVERE
+ }
+ default:
+ {
+ return 0
+ }
+ }
+}
+
+func ErrorReportingCommandTypeContainerFirstEnumForFieldCommandType(value ErrorReportingCommandType) (ErrorReportingCommandTypeContainer, error) {
+ for _, sizeValue := range ErrorReportingCommandTypeContainerValues {
+ if sizeValue.CommandType() == value {
+ return sizeValue, nil
+ }
+ }
+ return 0, errors.Errorf("enum for %v describing CommandType not found", value)
+}
+func ErrorReportingCommandTypeContainerByValue(value uint8) (enum ErrorReportingCommandTypeContainer, ok bool) {
+ switch value {
+ case 0x05:
+ return ErrorReportingCommandTypeContainer_ErrorReportingCommandDeprecated, true
+ case 0x15:
+ return ErrorReportingCommandTypeContainer_ErrorReportingCommandErrorReport, true
+ case 0x25:
+ return ErrorReportingCommandTypeContainer_ErrorReportingCommandAcknowledge, true
+ case 0x35:
+ return ErrorReportingCommandTypeContainer_ErrorReportingCommandClearMostSevere, true
+ }
+ return 0, false
+}
+
+func ErrorReportingCommandTypeContainerByName(value string) (enum ErrorReportingCommandTypeContainer, ok bool) {
+ switch value {
+ case "ErrorReportingCommandDeprecated":
+ return ErrorReportingCommandTypeContainer_ErrorReportingCommandDeprecated, true
+ case "ErrorReportingCommandErrorReport":
+ return ErrorReportingCommandTypeContainer_ErrorReportingCommandErrorReport, true
+ case "ErrorReportingCommandAcknowledge":
+ return ErrorReportingCommandTypeContainer_ErrorReportingCommandAcknowledge, true
+ case "ErrorReportingCommandClearMostSevere":
+ return ErrorReportingCommandTypeContainer_ErrorReportingCommandClearMostSevere, true
+ }
+ return 0, false
+}
+
+func ErrorReportingCommandTypeContainerKnows(value uint8) bool {
+ for _, typeValue := range ErrorReportingCommandTypeContainerValues {
+ if uint8(typeValue) == value {
+ return true
+ }
+ }
+ return false
+}
+
+func CastErrorReportingCommandTypeContainer(structType interface{}) ErrorReportingCommandTypeContainer {
+ castFunc := func(typ interface{}) ErrorReportingCommandTypeContainer {
+ if sErrorReportingCommandTypeContainer, ok := typ.(ErrorReportingCommandTypeContainer); ok {
+ return sErrorReportingCommandTypeContainer
+ }
+ return 0
+ }
+ return castFunc(structType)
+}
+
+func (m ErrorReportingCommandTypeContainer) GetLengthInBits() uint16 {
+ return 8
+}
+
+func (m ErrorReportingCommandTypeContainer) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func ErrorReportingCommandTypeContainerParse(readBuffer utils.ReadBuffer) (ErrorReportingCommandTypeContainer, error) {
+ val, err := readBuffer.ReadUint8("ErrorReportingCommandTypeContainer", 8)
+ if err != nil {
+ return 0, errors.Wrap(err, "error reading ErrorReportingCommandTypeContainer")
+ }
+ if enum, ok := ErrorReportingCommandTypeContainerByValue(val); !ok {
+ log.Debug().Msgf("no value %x found for RequestType", val)
+ return ErrorReportingCommandTypeContainer(val), nil
+ } else {
+ return enum, nil
+ }
+}
+
+func (e ErrorReportingCommandTypeContainer) Serialize(writeBuffer utils.WriteBuffer) error {
+ return writeBuffer.WriteUint8("ErrorReportingCommandTypeContainer", 8, uint8(e), utils.WithAdditionalStringRepresentation(e.PLC4XEnumName()))
+}
+
+// PLC4XEnumName returns the name that is used in code to identify this enum
+func (e ErrorReportingCommandTypeContainer) PLC4XEnumName() string {
+ switch e {
+ case ErrorReportingCommandTypeContainer_ErrorReportingCommandDeprecated:
+ return "ErrorReportingCommandDeprecated"
+ case ErrorReportingCommandTypeContainer_ErrorReportingCommandErrorReport:
+ return "ErrorReportingCommandErrorReport"
+ case ErrorReportingCommandTypeContainer_ErrorReportingCommandAcknowledge:
+ return "ErrorReportingCommandAcknowledge"
+ case ErrorReportingCommandTypeContainer_ErrorReportingCommandClearMostSevere:
+ return "ErrorReportingCommandClearMostSevere"
+ }
+ return ""
+}
+
+func (e ErrorReportingCommandTypeContainer) String() string {
+ return e.PLC4XEnumName()
+}
diff --git a/plc4go/protocols/cbus/readwrite/model/ErrorReportingData.go b/plc4go/protocols/cbus/readwrite/model/ErrorReportingData.go
new file mode 100644
index 000000000..db1cde2d4
--- /dev/null
+++ b/plc4go/protocols/cbus/readwrite/model/ErrorReportingData.go
@@ -0,0 +1,245 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/spi/utils"
+ "github.com/pkg/errors"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// ErrorReportingData is the corresponding interface of ErrorReportingData
+type ErrorReportingData interface {
+ utils.LengthAware
+ utils.Serializable
+ // GetCommandTypeContainer returns CommandTypeContainer (property field)
+ GetCommandTypeContainer() ErrorReportingCommandTypeContainer
+ // GetCommandType returns CommandType (virtual field)
+ GetCommandType() ErrorReportingCommandType
+}
+
+// ErrorReportingDataExactly can be used when we want exactly this type and not a type which fulfills ErrorReportingData.
+// This is useful for switch cases.
+type ErrorReportingDataExactly interface {
+ ErrorReportingData
+ isErrorReportingData() bool
+}
+
+// _ErrorReportingData is the data-structure of this message
+type _ErrorReportingData struct {
+ _ErrorReportingDataChildRequirements
+ CommandTypeContainer ErrorReportingCommandTypeContainer
+}
+
+type _ErrorReportingDataChildRequirements interface {
+ utils.Serializable
+ GetLengthInBits() uint16
+ GetLengthInBitsConditional(lastItem bool) uint16
+}
+
+type ErrorReportingDataParent interface {
+ SerializeParent(writeBuffer utils.WriteBuffer, child ErrorReportingData, serializeChildFunction func() error) error
+ GetTypeName() string
+}
+
+type ErrorReportingDataChild interface {
+ utils.Serializable
+ InitializeParent(parent ErrorReportingData, commandTypeContainer ErrorReportingCommandTypeContainer)
+ GetParent() *ErrorReportingData
+
+ GetTypeName() string
+ ErrorReportingData
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *_ErrorReportingData) GetCommandTypeContainer() ErrorReportingCommandTypeContainer {
+ return m.CommandTypeContainer
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *_ErrorReportingData) GetCommandType() ErrorReportingCommandType {
+ return CastErrorReportingCommandType(m.GetCommandTypeContainer().CommandType())
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewErrorReportingData factory function for _ErrorReportingData
+func NewErrorReportingData(commandTypeContainer ErrorReportingCommandTypeContainer) *_ErrorReportingData {
+ return &_ErrorReportingData{CommandTypeContainer: commandTypeContainer}
+}
+
+// Deprecated: use the interface for direct cast
+func CastErrorReportingData(structType interface{}) ErrorReportingData {
+ if casted, ok := structType.(ErrorReportingData); ok {
+ return casted
+ }
+ if casted, ok := structType.(*ErrorReportingData); ok {
+ return *casted
+ }
+ return nil
+}
+
+func (m *_ErrorReportingData) GetTypeName() string {
+ return "ErrorReportingData"
+}
+
+func (m *_ErrorReportingData) GetParentLengthInBits() uint16 {
+ lengthInBits := uint16(0)
+
+ // Simple field (commandTypeContainer)
+ lengthInBits += 8
+
+ // A virtual field doesn't have any in- or output.
+
+ return lengthInBits
+}
+
+func (m *_ErrorReportingData) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func ErrorReportingDataParse(readBuffer utils.ReadBuffer) (ErrorReportingData, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("ErrorReportingData"); pullErr != nil {
+ return nil, errors.Wrap(pullErr, "Error pulling for ErrorReportingData")
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Validation
+ if !(KnowsErrorReportingCommandTypeContainer(readBuffer)) {
+ return nil, errors.WithStack(utils.ParseAssertError{"no command type could be found"})
+ }
+
+ // Simple Field (commandTypeContainer)
+ if pullErr := readBuffer.PullContext("commandTypeContainer"); pullErr != nil {
+ return nil, errors.Wrap(pullErr, "Error pulling for commandTypeContainer")
+ }
+ _commandTypeContainer, _commandTypeContainerErr := ErrorReportingCommandTypeContainerParse(readBuffer)
+ if _commandTypeContainerErr != nil {
+ return nil, errors.Wrap(_commandTypeContainerErr, "Error parsing 'commandTypeContainer' field of ErrorReportingData")
+ }
+ commandTypeContainer := _commandTypeContainer
+ if closeErr := readBuffer.CloseContext("commandTypeContainer"); closeErr != nil {
+ return nil, errors.Wrap(closeErr, "Error closing for commandTypeContainer")
+ }
+
+ // Virtual field
+ _commandType := commandTypeContainer.CommandType()
+ commandType := ErrorReportingCommandType(_commandType)
+ _ = commandType
+
+ // Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type)
+ type ErrorReportingDataChildSerializeRequirement interface {
+ ErrorReportingData
+ InitializeParent(ErrorReportingData, ErrorReportingCommandTypeContainer)
+ GetParent() ErrorReportingData
+ }
+ var _childTemp interface{}
+ var _child ErrorReportingDataChildSerializeRequirement
+ var typeSwitchError error
+ switch {
+ case 0 == 0: // ErrorReportingDataGeneric
+ _childTemp, typeSwitchError = ErrorReportingDataGenericParse(readBuffer)
+ default:
+ typeSwitchError = errors.Errorf("Unmapped type for parameters [commandType=%v]", commandType)
+ }
+ if typeSwitchError != nil {
+ return nil, errors.Wrap(typeSwitchError, "Error parsing sub-type for type-switch of ErrorReportingData")
+ }
+ _child = _childTemp.(ErrorReportingDataChildSerializeRequirement)
+
+ if closeErr := readBuffer.CloseContext("ErrorReportingData"); closeErr != nil {
+ return nil, errors.Wrap(closeErr, "Error closing for ErrorReportingData")
+ }
+
+ // Finish initializing
+ _child.InitializeParent(_child, commandTypeContainer)
+ return _child, nil
+}
+
+func (pm *_ErrorReportingData) SerializeParent(writeBuffer utils.WriteBuffer, child ErrorReportingData, serializeChildFunction func() error) error {
+ // We redirect all calls through client as some methods are only implemented there
+ m := child
+ _ = m
+ positionAware := writeBuffer
+ _ = positionAware
+ if pushErr := writeBuffer.PushContext("ErrorReportingData"); pushErr != nil {
+ return errors.Wrap(pushErr, "Error pushing for ErrorReportingData")
+ }
+
+ // Simple Field (commandTypeContainer)
+ if pushErr := writeBuffer.PushContext("commandTypeContainer"); pushErr != nil {
+ return errors.Wrap(pushErr, "Error pushing for commandTypeContainer")
+ }
+ _commandTypeContainerErr := writeBuffer.WriteSerializable(m.GetCommandTypeContainer())
+ if popErr := writeBuffer.PopContext("commandTypeContainer"); popErr != nil {
+ return errors.Wrap(popErr, "Error popping for commandTypeContainer")
+ }
+ if _commandTypeContainerErr != nil {
+ return errors.Wrap(_commandTypeContainerErr, "Error serializing 'commandTypeContainer' field")
+ }
+ // Virtual field
+ if _commandTypeErr := writeBuffer.WriteVirtual("commandType", m.GetCommandType()); _commandTypeErr != nil {
+ return errors.Wrap(_commandTypeErr, "Error serializing 'commandType' field")
+ }
+
+ // 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("ErrorReportingData"); popErr != nil {
+ return errors.Wrap(popErr, "Error popping for ErrorReportingData")
+ }
+ return nil
+}
+
+func (m *_ErrorReportingData) isErrorReportingData() bool {
+ return true
+}
+
+func (m *_ErrorReportingData) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ writeBuffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ if err := writeBuffer.WriteSerializable(m); err != nil {
+ return err.Error()
+ }
+ return writeBuffer.GetBox().String()
+}
diff --git a/plc4go/protocols/cbus/readwrite/model/ErrorReportingDataGeneric.go b/plc4go/protocols/cbus/readwrite/model/ErrorReportingDataGeneric.go
new file mode 100644
index 000000000..cac57906b
--- /dev/null
+++ b/plc4go/protocols/cbus/readwrite/model/ErrorReportingDataGeneric.go
@@ -0,0 +1,459 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/spi/utils"
+ "github.com/pkg/errors"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// ErrorReportingDataGeneric is the corresponding interface of ErrorReportingDataGeneric
+type ErrorReportingDataGeneric interface {
+ utils.LengthAware
+ utils.Serializable
+ ErrorReportingData
+ // GetSystemCategory returns SystemCategory (property field)
+ GetSystemCategory() ErrorReportingSystemCategory
+ // GetMostRecent returns MostRecent (property field)
+ GetMostRecent() bool
+ // GetAcknowledge returns Acknowledge (property field)
+ GetAcknowledge() bool
+ // GetMostSevere returns MostSevere (property field)
+ GetMostSevere() bool
+ // GetSeverity returns Severity (property field)
+ GetSeverity() ErrorReportingSeverity
+ // GetDeviceId returns DeviceId (property field)
+ GetDeviceId() uint8
+ // GetErrorData1 returns ErrorData1 (property field)
+ GetErrorData1() uint8
+ // GetErrorData2 returns ErrorData2 (property field)
+ GetErrorData2() uint8
+ // GetIsMostSevereError returns IsMostSevereError (virtual field)
+ GetIsMostSevereError() bool
+ // GetIsMostRecentError returns IsMostRecentError (virtual field)
+ GetIsMostRecentError() bool
+ // GetIsMostRecentAndMostSevere returns IsMostRecentAndMostSevere (virtual field)
+ GetIsMostRecentAndMostSevere() bool
+}
+
+// ErrorReportingDataGenericExactly can be used when we want exactly this type and not a type which fulfills ErrorReportingDataGeneric.
+// This is useful for switch cases.
+type ErrorReportingDataGenericExactly interface {
+ ErrorReportingDataGeneric
+ isErrorReportingDataGeneric() bool
+}
+
+// _ErrorReportingDataGeneric is the data-structure of this message
+type _ErrorReportingDataGeneric struct {
+ *_ErrorReportingData
+ SystemCategory ErrorReportingSystemCategory
+ MostRecent bool
+ Acknowledge bool
+ MostSevere bool
+ Severity ErrorReportingSeverity
+ DeviceId uint8
+ ErrorData1 uint8
+ ErrorData2 uint8
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for discriminator values.
+///////////////////////
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+func (m *_ErrorReportingDataGeneric) InitializeParent(parent ErrorReportingData, commandTypeContainer ErrorReportingCommandTypeContainer) {
+ m.CommandTypeContainer = commandTypeContainer
+}
+
+func (m *_ErrorReportingDataGeneric) GetParent() ErrorReportingData {
+ return m._ErrorReportingData
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *_ErrorReportingDataGeneric) GetSystemCategory() ErrorReportingSystemCategory {
+ return m.SystemCategory
+}
+
+func (m *_ErrorReportingDataGeneric) GetMostRecent() bool {
+ return m.MostRecent
+}
+
+func (m *_ErrorReportingDataGeneric) GetAcknowledge() bool {
+ return m.Acknowledge
+}
+
+func (m *_ErrorReportingDataGeneric) GetMostSevere() bool {
+ return m.MostSevere
+}
+
+func (m *_ErrorReportingDataGeneric) GetSeverity() ErrorReportingSeverity {
+ return m.Severity
+}
+
+func (m *_ErrorReportingDataGeneric) GetDeviceId() uint8 {
+ return m.DeviceId
+}
+
+func (m *_ErrorReportingDataGeneric) GetErrorData1() uint8 {
+ return m.ErrorData1
+}
+
+func (m *_ErrorReportingDataGeneric) GetErrorData2() uint8 {
+ return m.ErrorData2
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *_ErrorReportingDataGeneric) GetIsMostSevereError() bool {
+ return bool(m.GetMostSevere())
+}
+
+func (m *_ErrorReportingDataGeneric) GetIsMostRecentError() bool {
+ return bool(m.GetMostRecent())
+}
+
+func (m *_ErrorReportingDataGeneric) GetIsMostRecentAndMostSevere() bool {
+ return bool(bool(m.GetIsMostRecentError()) && bool(m.GetIsMostSevereError()))
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewErrorReportingDataGeneric factory function for _ErrorReportingDataGeneric
+func NewErrorReportingDataGeneric(systemCategory ErrorReportingSystemCategory, mostRecent bool, acknowledge bool, mostSevere bool, severity ErrorReportingSeverity, deviceId uint8, errorData1 uint8, errorData2 uint8, commandTypeContainer ErrorReportingCommandTypeContainer) *_ErrorReportingDataGeneric {
+ _result := &_ErrorReportingDataGeneric{
+ SystemCategory: systemCategory,
+ MostRecent: mostRecent,
+ Acknowledge: acknowledge,
+ MostSevere: mostSevere,
+ Severity: severity,
+ DeviceId: deviceId,
+ ErrorData1: errorData1,
+ ErrorData2: errorData2,
+ _ErrorReportingData: NewErrorReportingData(commandTypeContainer),
+ }
+ _result._ErrorReportingData._ErrorReportingDataChildRequirements = _result
+ return _result
+}
+
+// Deprecated: use the interface for direct cast
+func CastErrorReportingDataGeneric(structType interface{}) ErrorReportingDataGeneric {
+ if casted, ok := structType.(ErrorReportingDataGeneric); ok {
+ return casted
+ }
+ if casted, ok := structType.(*ErrorReportingDataGeneric); ok {
+ return *casted
+ }
+ return nil
+}
+
+func (m *_ErrorReportingDataGeneric) GetTypeName() string {
+ return "ErrorReportingDataGeneric"
+}
+
+func (m *_ErrorReportingDataGeneric) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *_ErrorReportingDataGeneric) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (systemCategory)
+ lengthInBits += m.SystemCategory.GetLengthInBits()
+
+ // Simple field (mostRecent)
+ lengthInBits += 1
+
+ // Simple field (acknowledge)
+ lengthInBits += 1
+
+ // Simple field (mostSevere)
+ lengthInBits += 1
+
+ // A virtual field doesn't have any in- or output.
+
+ // A virtual field doesn't have any in- or output.
+
+ // A virtual field doesn't have any in- or output.
+
+ // Simple field (severity)
+ lengthInBits += 3
+
+ // Simple field (deviceId)
+ lengthInBits += 8
+
+ // Simple field (errorData1)
+ lengthInBits += 8
+
+ // Simple field (errorData2)
+ lengthInBits += 8
+
+ return lengthInBits
+}
+
+func (m *_ErrorReportingDataGeneric) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func ErrorReportingDataGenericParse(readBuffer utils.ReadBuffer) (ErrorReportingDataGeneric, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("ErrorReportingDataGeneric"); pullErr != nil {
+ return nil, errors.Wrap(pullErr, "Error pulling for ErrorReportingDataGeneric")
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (systemCategory)
+ if pullErr := readBuffer.PullContext("systemCategory"); pullErr != nil {
+ return nil, errors.Wrap(pullErr, "Error pulling for systemCategory")
+ }
+ _systemCategory, _systemCategoryErr := ErrorReportingSystemCategoryParse(readBuffer)
+ if _systemCategoryErr != nil {
+ return nil, errors.Wrap(_systemCategoryErr, "Error parsing 'systemCategory' field of ErrorReportingDataGeneric")
+ }
+ systemCategory := _systemCategory.(ErrorReportingSystemCategory)
+ if closeErr := readBuffer.CloseContext("systemCategory"); closeErr != nil {
+ return nil, errors.Wrap(closeErr, "Error closing for systemCategory")
+ }
+
+ // Simple Field (mostRecent)
+ _mostRecent, _mostRecentErr := readBuffer.ReadBit("mostRecent")
+ if _mostRecentErr != nil {
+ return nil, errors.Wrap(_mostRecentErr, "Error parsing 'mostRecent' field of ErrorReportingDataGeneric")
+ }
+ mostRecent := _mostRecent
+
+ // Simple Field (acknowledge)
+ _acknowledge, _acknowledgeErr := readBuffer.ReadBit("acknowledge")
+ if _acknowledgeErr != nil {
+ return nil, errors.Wrap(_acknowledgeErr, "Error parsing 'acknowledge' field of ErrorReportingDataGeneric")
+ }
+ acknowledge := _acknowledge
+
+ // Simple Field (mostSevere)
+ _mostSevere, _mostSevereErr := readBuffer.ReadBit("mostSevere")
+ if _mostSevereErr != nil {
+ return nil, errors.Wrap(_mostSevereErr, "Error parsing 'mostSevere' field of ErrorReportingDataGeneric")
+ }
+ mostSevere := _mostSevere
+
+ // Validation
+ if !(bool(mostRecent) || bool(mostSevere)) {
+ return nil, errors.WithStack(utils.ParseValidationError{"Invalid Error condition"})
+ }
+
+ // Virtual field
+ _isMostSevereError := mostSevere
+ isMostSevereError := bool(_isMostSevereError)
+ _ = isMostSevereError
+
+ // Virtual field
+ _isMostRecentError := mostRecent
+ isMostRecentError := bool(_isMostRecentError)
+ _ = isMostRecentError
+
+ // Virtual field
+ _isMostRecentAndMostSevere := bool(isMostRecentError) && bool(isMostSevereError)
+ isMostRecentAndMostSevere := bool(_isMostRecentAndMostSevere)
+ _ = isMostRecentAndMostSevere
+
+ // Simple Field (severity)
+ if pullErr := readBuffer.PullContext("severity"); pullErr != nil {
+ return nil, errors.Wrap(pullErr, "Error pulling for severity")
+ }
+ _severity, _severityErr := ErrorReportingSeverityParse(readBuffer)
+ if _severityErr != nil {
+ return nil, errors.Wrap(_severityErr, "Error parsing 'severity' field of ErrorReportingDataGeneric")
+ }
+ severity := _severity
+ if closeErr := readBuffer.CloseContext("severity"); closeErr != nil {
+ return nil, errors.Wrap(closeErr, "Error closing for severity")
+ }
+
+ // Simple Field (deviceId)
+ _deviceId, _deviceIdErr := readBuffer.ReadUint8("deviceId", 8)
+ if _deviceIdErr != nil {
+ return nil, errors.Wrap(_deviceIdErr, "Error parsing 'deviceId' field of ErrorReportingDataGeneric")
+ }
+ deviceId := _deviceId
+
+ // Simple Field (errorData1)
+ _errorData1, _errorData1Err := readBuffer.ReadUint8("errorData1", 8)
+ if _errorData1Err != nil {
+ return nil, errors.Wrap(_errorData1Err, "Error parsing 'errorData1' field of ErrorReportingDataGeneric")
+ }
+ errorData1 := _errorData1
+
+ // Simple Field (errorData2)
+ _errorData2, _errorData2Err := readBuffer.ReadUint8("errorData2", 8)
+ if _errorData2Err != nil {
+ return nil, errors.Wrap(_errorData2Err, "Error parsing 'errorData2' field of ErrorReportingDataGeneric")
+ }
+ errorData2 := _errorData2
+
+ if closeErr := readBuffer.CloseContext("ErrorReportingDataGeneric"); closeErr != nil {
+ return nil, errors.Wrap(closeErr, "Error closing for ErrorReportingDataGeneric")
+ }
+
+ // Create a partially initialized instance
+ _child := &_ErrorReportingDataGeneric{
+ SystemCategory: systemCategory,
+ MostRecent: mostRecent,
+ Acknowledge: acknowledge,
+ MostSevere: mostSevere,
+ Severity: severity,
+ DeviceId: deviceId,
+ ErrorData1: errorData1,
+ ErrorData2: errorData2,
+ _ErrorReportingData: &_ErrorReportingData{},
+ }
+ _child._ErrorReportingData._ErrorReportingDataChildRequirements = _child
+ return _child, nil
+}
+
+func (m *_ErrorReportingDataGeneric) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("ErrorReportingDataGeneric"); pushErr != nil {
+ return errors.Wrap(pushErr, "Error pushing for ErrorReportingDataGeneric")
+ }
+
+ // Simple Field (systemCategory)
+ if pushErr := writeBuffer.PushContext("systemCategory"); pushErr != nil {
+ return errors.Wrap(pushErr, "Error pushing for systemCategory")
+ }
+ _systemCategoryErr := writeBuffer.WriteSerializable(m.GetSystemCategory())
+ if popErr := writeBuffer.PopContext("systemCategory"); popErr != nil {
+ return errors.Wrap(popErr, "Error popping for systemCategory")
+ }
+ if _systemCategoryErr != nil {
+ return errors.Wrap(_systemCategoryErr, "Error serializing 'systemCategory' field")
+ }
+
+ // Simple Field (mostRecent)
+ mostRecent := bool(m.GetMostRecent())
+ _mostRecentErr := writeBuffer.WriteBit("mostRecent", (mostRecent))
+ if _mostRecentErr != nil {
+ return errors.Wrap(_mostRecentErr, "Error serializing 'mostRecent' field")
+ }
+
+ // Simple Field (acknowledge)
+ acknowledge := bool(m.GetAcknowledge())
+ _acknowledgeErr := writeBuffer.WriteBit("acknowledge", (acknowledge))
+ if _acknowledgeErr != nil {
+ return errors.Wrap(_acknowledgeErr, "Error serializing 'acknowledge' field")
+ }
+
+ // Simple Field (mostSevere)
+ mostSevere := bool(m.GetMostSevere())
+ _mostSevereErr := writeBuffer.WriteBit("mostSevere", (mostSevere))
+ if _mostSevereErr != nil {
+ return errors.Wrap(_mostSevereErr, "Error serializing 'mostSevere' field")
+ }
+ // Virtual field
+ if _isMostSevereErrorErr := writeBuffer.WriteVirtual("isMostSevereError", m.GetIsMostSevereError()); _isMostSevereErrorErr != nil {
+ return errors.Wrap(_isMostSevereErrorErr, "Error serializing 'isMostSevereError' field")
+ }
+ // Virtual field
+ if _isMostRecentErrorErr := writeBuffer.WriteVirtual("isMostRecentError", m.GetIsMostRecentError()); _isMostRecentErrorErr != nil {
+ return errors.Wrap(_isMostRecentErrorErr, "Error serializing 'isMostRecentError' field")
+ }
+ // Virtual field
+ if _isMostRecentAndMostSevereErr := writeBuffer.WriteVirtual("isMostRecentAndMostSevere", m.GetIsMostRecentAndMostSevere()); _isMostRecentAndMostSevereErr != nil {
+ return errors.Wrap(_isMostRecentAndMostSevereErr, "Error serializing 'isMostRecentAndMostSevere' field")
+ }
+
+ // Simple Field (severity)
+ if pushErr := writeBuffer.PushContext("severity"); pushErr != nil {
+ return errors.Wrap(pushErr, "Error pushing for severity")
+ }
+ _severityErr := writeBuffer.WriteSerializable(m.GetSeverity())
+ if popErr := writeBuffer.PopContext("severity"); popErr != nil {
+ return errors.Wrap(popErr, "Error popping for severity")
+ }
+ if _severityErr != nil {
+ return errors.Wrap(_severityErr, "Error serializing 'severity' field")
+ }
+
+ // Simple Field (deviceId)
+ deviceId := uint8(m.GetDeviceId())
+ _deviceIdErr := writeBuffer.WriteUint8("deviceId", 8, (deviceId))
+ if _deviceIdErr != nil {
+ return errors.Wrap(_deviceIdErr, "Error serializing 'deviceId' field")
+ }
+
+ // Simple Field (errorData1)
+ errorData1 := uint8(m.GetErrorData1())
+ _errorData1Err := writeBuffer.WriteUint8("errorData1", 8, (errorData1))
+ if _errorData1Err != nil {
+ return errors.Wrap(_errorData1Err, "Error serializing 'errorData1' field")
+ }
+
+ // Simple Field (errorData2)
+ errorData2 := uint8(m.GetErrorData2())
+ _errorData2Err := writeBuffer.WriteUint8("errorData2", 8, (errorData2))
+ if _errorData2Err != nil {
+ return errors.Wrap(_errorData2Err, "Error serializing 'errorData2' field")
+ }
+
+ if popErr := writeBuffer.PopContext("ErrorReportingDataGeneric"); popErr != nil {
+ return errors.Wrap(popErr, "Error popping for ErrorReportingDataGeneric")
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *_ErrorReportingDataGeneric) isErrorReportingDataGeneric() bool {
+ return true
+}
+
+func (m *_ErrorReportingDataGeneric) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ writeBuffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ if err := writeBuffer.WriteSerializable(m); err != nil {
+ return err.Error()
+ }
+ return writeBuffer.GetBox().String()
+}
diff --git a/plc4go/protocols/cbus/readwrite/model/ErrorReportingSeverity.go b/plc4go/protocols/cbus/readwrite/model/ErrorReportingSeverity.go
new file mode 100644
index 000000000..430822e42
--- /dev/null
+++ b/plc4go/protocols/cbus/readwrite/model/ErrorReportingSeverity.go
@@ -0,0 +1,177 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/spi/utils"
+ "github.com/pkg/errors"
+ "github.com/rs/zerolog/log"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// ErrorReportingSeverity is an enum
+type ErrorReportingSeverity uint8
+
+type IErrorReportingSeverity interface {
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+const (
+ ErrorReportingSeverity_ALL_OK ErrorReportingSeverity = 0x0
+ ErrorReportingSeverity_OK ErrorReportingSeverity = 0x1
+ ErrorReportingSeverity_MINOR_FAILURE ErrorReportingSeverity = 0x2
+ ErrorReportingSeverity_GENERAL_FAILURE ErrorReportingSeverity = 0x3
+ ErrorReportingSeverity_EXTREME_FAILURE ErrorReportingSeverity = 0x4
+ ErrorReportingSeverity_RESERVED_1 ErrorReportingSeverity = 0x5
+ ErrorReportingSeverity_RESERVED_2 ErrorReportingSeverity = 0x6
+ ErrorReportingSeverity_RESERVED_3 ErrorReportingSeverity = 0x7
+)
+
+var ErrorReportingSeverityValues []ErrorReportingSeverity
+
+func init() {
+ _ = errors.New
+ ErrorReportingSeverityValues = []ErrorReportingSeverity{
+ ErrorReportingSeverity_ALL_OK,
+ ErrorReportingSeverity_OK,
+ ErrorReportingSeverity_MINOR_FAILURE,
+ ErrorReportingSeverity_GENERAL_FAILURE,
+ ErrorReportingSeverity_EXTREME_FAILURE,
+ ErrorReportingSeverity_RESERVED_1,
+ ErrorReportingSeverity_RESERVED_2,
+ ErrorReportingSeverity_RESERVED_3,
+ }
+}
+
+func ErrorReportingSeverityByValue(value uint8) (enum ErrorReportingSeverity, ok bool) {
+ switch value {
+ case 0x0:
+ return ErrorReportingSeverity_ALL_OK, true
+ case 0x1:
+ return ErrorReportingSeverity_OK, true
+ case 0x2:
+ return ErrorReportingSeverity_MINOR_FAILURE, true
+ case 0x3:
+ return ErrorReportingSeverity_GENERAL_FAILURE, true
+ case 0x4:
+ return ErrorReportingSeverity_EXTREME_FAILURE, true
+ case 0x5:
+ return ErrorReportingSeverity_RESERVED_1, true
+ case 0x6:
+ return ErrorReportingSeverity_RESERVED_2, true
+ case 0x7:
+ return ErrorReportingSeverity_RESERVED_3, true
+ }
+ return 0, false
+}
+
+func ErrorReportingSeverityByName(value string) (enum ErrorReportingSeverity, ok bool) {
+ switch value {
+ case "ALL_OK":
+ return ErrorReportingSeverity_ALL_OK, true
+ case "OK":
+ return ErrorReportingSeverity_OK, true
+ case "MINOR_FAILURE":
+ return ErrorReportingSeverity_MINOR_FAILURE, true
+ case "GENERAL_FAILURE":
+ return ErrorReportingSeverity_GENERAL_FAILURE, true
+ case "EXTREME_FAILURE":
+ return ErrorReportingSeverity_EXTREME_FAILURE, true
+ case "RESERVED_1":
+ return ErrorReportingSeverity_RESERVED_1, true
+ case "RESERVED_2":
+ return ErrorReportingSeverity_RESERVED_2, true
+ case "RESERVED_3":
+ return ErrorReportingSeverity_RESERVED_3, true
+ }
+ return 0, false
+}
+
+func ErrorReportingSeverityKnows(value uint8) bool {
+ for _, typeValue := range ErrorReportingSeverityValues {
+ if uint8(typeValue) == value {
+ return true
+ }
+ }
+ return false
+}
+
+func CastErrorReportingSeverity(structType interface{}) ErrorReportingSeverity {
+ castFunc := func(typ interface{}) ErrorReportingSeverity {
+ if sErrorReportingSeverity, ok := typ.(ErrorReportingSeverity); ok {
+ return sErrorReportingSeverity
+ }
+ return 0
+ }
+ return castFunc(structType)
+}
+
+func (m ErrorReportingSeverity) GetLengthInBits() uint16 {
+ return 3
+}
+
+func (m ErrorReportingSeverity) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func ErrorReportingSeverityParse(readBuffer utils.ReadBuffer) (ErrorReportingSeverity, error) {
+ val, err := readBuffer.ReadUint8("ErrorReportingSeverity", 3)
+ if err != nil {
+ return 0, errors.Wrap(err, "error reading ErrorReportingSeverity")
+ }
+ if enum, ok := ErrorReportingSeverityByValue(val); !ok {
+ log.Debug().Msgf("no value %x found for RequestType", val)
+ return ErrorReportingSeverity(val), nil
+ } else {
+ return enum, nil
+ }
+}
+
+func (e ErrorReportingSeverity) Serialize(writeBuffer utils.WriteBuffer) error {
+ return writeBuffer.WriteUint8("ErrorReportingSeverity", 3, uint8(e), utils.WithAdditionalStringRepresentation(e.PLC4XEnumName()))
+}
+
+// PLC4XEnumName returns the name that is used in code to identify this enum
+func (e ErrorReportingSeverity) PLC4XEnumName() string {
+ switch e {
+ case ErrorReportingSeverity_ALL_OK:
+ return "ALL_OK"
+ case ErrorReportingSeverity_OK:
+ return "OK"
+ case ErrorReportingSeverity_MINOR_FAILURE:
+ return "MINOR_FAILURE"
+ case ErrorReportingSeverity_GENERAL_FAILURE:
+ return "GENERAL_FAILURE"
+ case ErrorReportingSeverity_EXTREME_FAILURE:
+ return "EXTREME_FAILURE"
+ case ErrorReportingSeverity_RESERVED_1:
+ return "RESERVED_1"
+ case ErrorReportingSeverity_RESERVED_2:
+ return "RESERVED_2"
+ case ErrorReportingSeverity_RESERVED_3:
+ return "RESERVED_3"
+ }
+ return ""
+}
+
+func (e ErrorReportingSeverity) String() string {
+ return e.PLC4XEnumName()
+}
diff --git a/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategory.go b/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategory.go
new file mode 100644
index 000000000..cb2ec1a85
--- /dev/null
+++ b/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategory.go
@@ -0,0 +1,238 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/spi/utils"
+ "github.com/pkg/errors"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// ErrorReportingSystemCategory is the corresponding interface of ErrorReportingSystemCategory
+type ErrorReportingSystemCategory interface {
+ utils.LengthAware
+ utils.Serializable
+ // GetSystemCategoryClass returns SystemCategoryClass (property field)
+ GetSystemCategoryClass() ErrorReportingSystemCategoryClass
+ // GetSystemCategoryType returns SystemCategoryType (property field)
+ GetSystemCategoryType() ErrorReportingSystemCategoryType
+ // GetSystemCategoryVariant returns SystemCategoryVariant (property field)
+ GetSystemCategoryVariant() ErrorReportingSystemCategoryVariant
+}
+
+// ErrorReportingSystemCategoryExactly can be used when we want exactly this type and not a type which fulfills ErrorReportingSystemCategory.
+// This is useful for switch cases.
+type ErrorReportingSystemCategoryExactly interface {
+ ErrorReportingSystemCategory
+ isErrorReportingSystemCategory() bool
+}
+
+// _ErrorReportingSystemCategory is the data-structure of this message
+type _ErrorReportingSystemCategory struct {
+ SystemCategoryClass ErrorReportingSystemCategoryClass
+ SystemCategoryType ErrorReportingSystemCategoryType
+ SystemCategoryVariant ErrorReportingSystemCategoryVariant
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *_ErrorReportingSystemCategory) GetSystemCategoryClass() ErrorReportingSystemCategoryClass {
+ return m.SystemCategoryClass
+}
+
+func (m *_ErrorReportingSystemCategory) GetSystemCategoryType() ErrorReportingSystemCategoryType {
+ return m.SystemCategoryType
+}
+
+func (m *_ErrorReportingSystemCategory) GetSystemCategoryVariant() ErrorReportingSystemCategoryVariant {
+ return m.SystemCategoryVariant
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewErrorReportingSystemCategory factory function for _ErrorReportingSystemCategory
+func NewErrorReportingSystemCategory(systemCategoryClass ErrorReportingSystemCategoryClass, systemCategoryType ErrorReportingSystemCategoryType, systemCategoryVariant ErrorReportingSystemCategoryVariant) *_ErrorReportingSystemCategory {
+ return &_ErrorReportingSystemCategory{SystemCategoryClass: systemCategoryClass, SystemCategoryType: systemCategoryType, SystemCategoryVariant: systemCategoryVariant}
+}
+
+// Deprecated: use the interface for direct cast
+func CastErrorReportingSystemCategory(structType interface{}) ErrorReportingSystemCategory {
+ if casted, ok := structType.(ErrorReportingSystemCategory); ok {
+ return casted
+ }
+ if casted, ok := structType.(*ErrorReportingSystemCategory); ok {
+ return *casted
+ }
+ return nil
+}
+
+func (m *_ErrorReportingSystemCategory) GetTypeName() string {
+ return "ErrorReportingSystemCategory"
+}
+
+func (m *_ErrorReportingSystemCategory) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *_ErrorReportingSystemCategory) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(0)
+
+ // Simple field (systemCategoryClass)
+ lengthInBits += 4
+
+ // Simple field (systemCategoryType)
+ lengthInBits += m.SystemCategoryType.GetLengthInBits()
+
+ // Simple field (systemCategoryVariant)
+ lengthInBits += 2
+
+ return lengthInBits
+}
+
+func (m *_ErrorReportingSystemCategory) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func ErrorReportingSystemCategoryParse(readBuffer utils.ReadBuffer) (ErrorReportingSystemCategory, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("ErrorReportingSystemCategory"); pullErr != nil {
+ return nil, errors.Wrap(pullErr, "Error pulling for ErrorReportingSystemCategory")
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (systemCategoryClass)
+ if pullErr := readBuffer.PullContext("systemCategoryClass"); pullErr != nil {
+ return nil, errors.Wrap(pullErr, "Error pulling for systemCategoryClass")
+ }
+ _systemCategoryClass, _systemCategoryClassErr := ErrorReportingSystemCategoryClassParse(readBuffer)
+ if _systemCategoryClassErr != nil {
+ return nil, errors.Wrap(_systemCategoryClassErr, "Error parsing 'systemCategoryClass' field of ErrorReportingSystemCategory")
+ }
+ systemCategoryClass := _systemCategoryClass
+ if closeErr := readBuffer.CloseContext("systemCategoryClass"); closeErr != nil {
+ return nil, errors.Wrap(closeErr, "Error closing for systemCategoryClass")
+ }
+
+ // Simple Field (systemCategoryType)
+ if pullErr := readBuffer.PullContext("systemCategoryType"); pullErr != nil {
+ return nil, errors.Wrap(pullErr, "Error pulling for systemCategoryType")
+ }
+ _systemCategoryType, _systemCategoryTypeErr := ErrorReportingSystemCategoryTypeParse(readBuffer, ErrorReportingSystemCategoryClass(systemCategoryClass))
+ if _systemCategoryTypeErr != nil {
+ return nil, errors.Wrap(_systemCategoryTypeErr, "Error parsing 'systemCategoryType' field of ErrorReportingSystemCategory")
+ }
+ systemCategoryType := _systemCategoryType.(ErrorReportingSystemCategoryType)
+ if closeErr := readBuffer.CloseContext("systemCategoryType"); closeErr != nil {
+ return nil, errors.Wrap(closeErr, "Error closing for systemCategoryType")
+ }
+
+ // Simple Field (systemCategoryVariant)
+ if pullErr := readBuffer.PullContext("systemCategoryVariant"); pullErr != nil {
+ return nil, errors.Wrap(pullErr, "Error pulling for systemCategoryVariant")
+ }
+ _systemCategoryVariant, _systemCategoryVariantErr := ErrorReportingSystemCategoryVariantParse(readBuffer)
+ if _systemCategoryVariantErr != nil {
+ return nil, errors.Wrap(_systemCategoryVariantErr, "Error parsing 'systemCategoryVariant' field of ErrorReportingSystemCategory")
+ }
+ systemCategoryVariant := _systemCategoryVariant
+ if closeErr := readBuffer.CloseContext("systemCategoryVariant"); closeErr != nil {
+ return nil, errors.Wrap(closeErr, "Error closing for systemCategoryVariant")
+ }
+
+ if closeErr := readBuffer.CloseContext("ErrorReportingSystemCategory"); closeErr != nil {
+ return nil, errors.Wrap(closeErr, "Error closing for ErrorReportingSystemCategory")
+ }
+
+ // Create the instance
+ return NewErrorReportingSystemCategory(systemCategoryClass, systemCategoryType, systemCategoryVariant), nil
+}
+
+func (m *_ErrorReportingSystemCategory) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ if pushErr := writeBuffer.PushContext("ErrorReportingSystemCategory"); pushErr != nil {
+ return errors.Wrap(pushErr, "Error pushing for ErrorReportingSystemCategory")
+ }
+
+ // Simple Field (systemCategoryClass)
+ if pushErr := writeBuffer.PushContext("systemCategoryClass"); pushErr != nil {
+ return errors.Wrap(pushErr, "Error pushing for systemCategoryClass")
+ }
+ _systemCategoryClassErr := writeBuffer.WriteSerializable(m.GetSystemCategoryClass())
+ if popErr := writeBuffer.PopContext("systemCategoryClass"); popErr != nil {
+ return errors.Wrap(popErr, "Error popping for systemCategoryClass")
+ }
+ if _systemCategoryClassErr != nil {
+ return errors.Wrap(_systemCategoryClassErr, "Error serializing 'systemCategoryClass' field")
+ }
+
+ // Simple Field (systemCategoryType)
+ if pushErr := writeBuffer.PushContext("systemCategoryType"); pushErr != nil {
+ return errors.Wrap(pushErr, "Error pushing for systemCategoryType")
+ }
+ _systemCategoryTypeErr := writeBuffer.WriteSerializable(m.GetSystemCategoryType())
+ if popErr := writeBuffer.PopContext("systemCategoryType"); popErr != nil {
+ return errors.Wrap(popErr, "Error popping for systemCategoryType")
+ }
+ if _systemCategoryTypeErr != nil {
+ return errors.Wrap(_systemCategoryTypeErr, "Error serializing 'systemCategoryType' field")
+ }
+
+ // Simple Field (systemCategoryVariant)
+ if pushErr := writeBuffer.PushContext("systemCategoryVariant"); pushErr != nil {
+ return errors.Wrap(pushErr, "Error pushing for systemCategoryVariant")
+ }
+ _systemCategoryVariantErr := writeBuffer.WriteSerializable(m.GetSystemCategoryVariant())
+ if popErr := writeBuffer.PopContext("systemCategoryVariant"); popErr != nil {
+ return errors.Wrap(popErr, "Error popping for systemCategoryVariant")
+ }
+ if _systemCategoryVariantErr != nil {
+ return errors.Wrap(_systemCategoryVariantErr, "Error serializing 'systemCategoryVariant' field")
+ }
+
+ if popErr := writeBuffer.PopContext("ErrorReportingSystemCategory"); popErr != nil {
+ return errors.Wrap(popErr, "Error popping for ErrorReportingSystemCategory")
+ }
+ return nil
+}
+
+func (m *_ErrorReportingSystemCategory) isErrorReportingSystemCategory() bool {
+ return true
+}
+
+func (m *_ErrorReportingSystemCategory) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ writeBuffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ if err := writeBuffer.WriteSerializable(m); err != nil {
+ return err.Error()
+ }
+ return writeBuffer.GetBox().String()
+}
diff --git a/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryClass.go b/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryClass.go
new file mode 100644
index 000000000..109e43d60
--- /dev/null
+++ b/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryClass.go
@@ -0,0 +1,241 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/spi/utils"
+ "github.com/pkg/errors"
+ "github.com/rs/zerolog/log"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// ErrorReportingSystemCategoryClass is an enum
+type ErrorReportingSystemCategoryClass uint8
+
+type IErrorReportingSystemCategoryClass interface {
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+const (
+ ErrorReportingSystemCategoryClass_RESERVED_0 ErrorReportingSystemCategoryClass = 0x0
+ ErrorReportingSystemCategoryClass_RESERVED_1 ErrorReportingSystemCategoryClass = 0x1
+ ErrorReportingSystemCategoryClass_RESERVED_2 ErrorReportingSystemCategoryClass = 0x2
+ ErrorReportingSystemCategoryClass_RESERVED_3 ErrorReportingSystemCategoryClass = 0x3
+ ErrorReportingSystemCategoryClass_RESERVED_4 ErrorReportingSystemCategoryClass = 0x4
+ ErrorReportingSystemCategoryClass_INPUT_UNITS ErrorReportingSystemCategoryClass = 0x5
+ ErrorReportingSystemCategoryClass_RESERVED_6 ErrorReportingSystemCategoryClass = 0x6
+ ErrorReportingSystemCategoryClass_RESERVED_7 ErrorReportingSystemCategoryClass = 0x7
+ ErrorReportingSystemCategoryClass_RESERVED_8 ErrorReportingSystemCategoryClass = 0x8
+ ErrorReportingSystemCategoryClass_SUPPORT_UNITS ErrorReportingSystemCategoryClass = 0x9
+ ErrorReportingSystemCategoryClass_RESERVED_10 ErrorReportingSystemCategoryClass = 0xA
+ ErrorReportingSystemCategoryClass_BUILDING_MANAGEMENT_SYSTEMS ErrorReportingSystemCategoryClass = 0xB
+ ErrorReportingSystemCategoryClass_RESERVED_12 ErrorReportingSystemCategoryClass = 0xC
+ ErrorReportingSystemCategoryClass_OUTPUT_UNITS ErrorReportingSystemCategoryClass = 0xD
+ ErrorReportingSystemCategoryClass_RESERVED_14 ErrorReportingSystemCategoryClass = 0xE
+ ErrorReportingSystemCategoryClass_CLIMATE_CONTROLLERS ErrorReportingSystemCategoryClass = 0xF
+)
+
+var ErrorReportingSystemCategoryClassValues []ErrorReportingSystemCategoryClass
+
+func init() {
+ _ = errors.New
+ ErrorReportingSystemCategoryClassValues = []ErrorReportingSystemCategoryClass{
+ ErrorReportingSystemCategoryClass_RESERVED_0,
+ ErrorReportingSystemCategoryClass_RESERVED_1,
+ ErrorReportingSystemCategoryClass_RESERVED_2,
+ ErrorReportingSystemCategoryClass_RESERVED_3,
+ ErrorReportingSystemCategoryClass_RESERVED_4,
+ ErrorReportingSystemCategoryClass_INPUT_UNITS,
+ ErrorReportingSystemCategoryClass_RESERVED_6,
+ ErrorReportingSystemCategoryClass_RESERVED_7,
+ ErrorReportingSystemCategoryClass_RESERVED_8,
+ ErrorReportingSystemCategoryClass_SUPPORT_UNITS,
+ ErrorReportingSystemCategoryClass_RESERVED_10,
+ ErrorReportingSystemCategoryClass_BUILDING_MANAGEMENT_SYSTEMS,
+ ErrorReportingSystemCategoryClass_RESERVED_12,
+ ErrorReportingSystemCategoryClass_OUTPUT_UNITS,
+ ErrorReportingSystemCategoryClass_RESERVED_14,
+ ErrorReportingSystemCategoryClass_CLIMATE_CONTROLLERS,
+ }
+}
+
+func ErrorReportingSystemCategoryClassByValue(value uint8) (enum ErrorReportingSystemCategoryClass, ok bool) {
+ switch value {
+ case 0x0:
+ return ErrorReportingSystemCategoryClass_RESERVED_0, true
+ case 0x1:
+ return ErrorReportingSystemCategoryClass_RESERVED_1, true
+ case 0x2:
+ return ErrorReportingSystemCategoryClass_RESERVED_2, true
+ case 0x3:
+ return ErrorReportingSystemCategoryClass_RESERVED_3, true
+ case 0x4:
+ return ErrorReportingSystemCategoryClass_RESERVED_4, true
+ case 0x5:
+ return ErrorReportingSystemCategoryClass_INPUT_UNITS, true
+ case 0x6:
+ return ErrorReportingSystemCategoryClass_RESERVED_6, true
+ case 0x7:
+ return ErrorReportingSystemCategoryClass_RESERVED_7, true
+ case 0x8:
+ return ErrorReportingSystemCategoryClass_RESERVED_8, true
+ case 0x9:
+ return ErrorReportingSystemCategoryClass_SUPPORT_UNITS, true
+ case 0xA:
+ return ErrorReportingSystemCategoryClass_RESERVED_10, true
+ case 0xB:
+ return ErrorReportingSystemCategoryClass_BUILDING_MANAGEMENT_SYSTEMS, true
+ case 0xC:
+ return ErrorReportingSystemCategoryClass_RESERVED_12, true
+ case 0xD:
+ return ErrorReportingSystemCategoryClass_OUTPUT_UNITS, true
+ case 0xE:
+ return ErrorReportingSystemCategoryClass_RESERVED_14, true
+ case 0xF:
+ return ErrorReportingSystemCategoryClass_CLIMATE_CONTROLLERS, true
+ }
+ return 0, false
+}
+
+func ErrorReportingSystemCategoryClassByName(value string) (enum ErrorReportingSystemCategoryClass, ok bool) {
+ switch value {
+ case "RESERVED_0":
+ return ErrorReportingSystemCategoryClass_RESERVED_0, true
+ case "RESERVED_1":
+ return ErrorReportingSystemCategoryClass_RESERVED_1, true
+ case "RESERVED_2":
+ return ErrorReportingSystemCategoryClass_RESERVED_2, true
+ case "RESERVED_3":
+ return ErrorReportingSystemCategoryClass_RESERVED_3, true
+ case "RESERVED_4":
+ return ErrorReportingSystemCategoryClass_RESERVED_4, true
+ case "INPUT_UNITS":
+ return ErrorReportingSystemCategoryClass_INPUT_UNITS, true
+ case "RESERVED_6":
+ return ErrorReportingSystemCategoryClass_RESERVED_6, true
+ case "RESERVED_7":
+ return ErrorReportingSystemCategoryClass_RESERVED_7, true
+ case "RESERVED_8":
+ return ErrorReportingSystemCategoryClass_RESERVED_8, true
+ case "SUPPORT_UNITS":
+ return ErrorReportingSystemCategoryClass_SUPPORT_UNITS, true
+ case "RESERVED_10":
+ return ErrorReportingSystemCategoryClass_RESERVED_10, true
+ case "BUILDING_MANAGEMENT_SYSTEMS":
+ return ErrorReportingSystemCategoryClass_BUILDING_MANAGEMENT_SYSTEMS, true
+ case "RESERVED_12":
+ return ErrorReportingSystemCategoryClass_RESERVED_12, true
+ case "OUTPUT_UNITS":
+ return ErrorReportingSystemCategoryClass_OUTPUT_UNITS, true
+ case "RESERVED_14":
+ return ErrorReportingSystemCategoryClass_RESERVED_14, true
+ case "CLIMATE_CONTROLLERS":
+ return ErrorReportingSystemCategoryClass_CLIMATE_CONTROLLERS, true
+ }
+ return 0, false
+}
+
+func ErrorReportingSystemCategoryClassKnows(value uint8) bool {
+ for _, typeValue := range ErrorReportingSystemCategoryClassValues {
+ if uint8(typeValue) == value {
+ return true
+ }
+ }
+ return false
+}
+
+func CastErrorReportingSystemCategoryClass(structType interface{}) ErrorReportingSystemCategoryClass {
+ castFunc := func(typ interface{}) ErrorReportingSystemCategoryClass {
+ if sErrorReportingSystemCategoryClass, ok := typ.(ErrorReportingSystemCategoryClass); ok {
+ return sErrorReportingSystemCategoryClass
+ }
+ return 0
+ }
+ return castFunc(structType)
+}
+
+func (m ErrorReportingSystemCategoryClass) GetLengthInBits() uint16 {
+ return 4
+}
+
+func (m ErrorReportingSystemCategoryClass) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func ErrorReportingSystemCategoryClassParse(readBuffer utils.ReadBuffer) (ErrorReportingSystemCategoryClass, error) {
+ val, err := readBuffer.ReadUint8("ErrorReportingSystemCategoryClass", 4)
+ if err != nil {
+ return 0, errors.Wrap(err, "error reading ErrorReportingSystemCategoryClass")
+ }
+ if enum, ok := ErrorReportingSystemCategoryClassByValue(val); !ok {
+ log.Debug().Msgf("no value %x found for RequestType", val)
+ return ErrorReportingSystemCategoryClass(val), nil
+ } else {
+ return enum, nil
+ }
+}
+
+func (e ErrorReportingSystemCategoryClass) Serialize(writeBuffer utils.WriteBuffer) error {
+ return writeBuffer.WriteUint8("ErrorReportingSystemCategoryClass", 4, uint8(e), utils.WithAdditionalStringRepresentation(e.PLC4XEnumName()))
+}
+
+// PLC4XEnumName returns the name that is used in code to identify this enum
+func (e ErrorReportingSystemCategoryClass) PLC4XEnumName() string {
+ switch e {
+ case ErrorReportingSystemCategoryClass_RESERVED_0:
+ return "RESERVED_0"
+ case ErrorReportingSystemCategoryClass_RESERVED_1:
+ return "RESERVED_1"
+ case ErrorReportingSystemCategoryClass_RESERVED_2:
+ return "RESERVED_2"
+ case ErrorReportingSystemCategoryClass_RESERVED_3:
+ return "RESERVED_3"
+ case ErrorReportingSystemCategoryClass_RESERVED_4:
+ return "RESERVED_4"
+ case ErrorReportingSystemCategoryClass_INPUT_UNITS:
+ return "INPUT_UNITS"
+ case ErrorReportingSystemCategoryClass_RESERVED_6:
+ return "RESERVED_6"
+ case ErrorReportingSystemCategoryClass_RESERVED_7:
+ return "RESERVED_7"
+ case ErrorReportingSystemCategoryClass_RESERVED_8:
+ return "RESERVED_8"
+ case ErrorReportingSystemCategoryClass_SUPPORT_UNITS:
+ return "SUPPORT_UNITS"
+ case ErrorReportingSystemCategoryClass_RESERVED_10:
+ return "RESERVED_10"
+ case ErrorReportingSystemCategoryClass_BUILDING_MANAGEMENT_SYSTEMS:
+ return "BUILDING_MANAGEMENT_SYSTEMS"
+ case ErrorReportingSystemCategoryClass_RESERVED_12:
+ return "RESERVED_12"
+ case ErrorReportingSystemCategoryClass_OUTPUT_UNITS:
+ return "OUTPUT_UNITS"
+ case ErrorReportingSystemCategoryClass_RESERVED_14:
+ return "RESERVED_14"
+ case ErrorReportingSystemCategoryClass_CLIMATE_CONTROLLERS:
+ return "CLIMATE_CONTROLLERS"
+ }
+ return ""
+}
+
+func (e ErrorReportingSystemCategoryClass) String() string {
+ return e.PLC4XEnumName()
+}
diff --git a/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryType.go b/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryType.go
new file mode 100644
index 000000000..d3d8ded72
--- /dev/null
+++ b/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryType.go
@@ -0,0 +1,182 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/spi/utils"
+ "github.com/pkg/errors"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// ErrorReportingSystemCategoryType is the corresponding interface of ErrorReportingSystemCategoryType
+type ErrorReportingSystemCategoryType interface {
+ utils.LengthAware
+ utils.Serializable
+ // GetErrorReportingSystemCategoryClass returns ErrorReportingSystemCategoryClass (discriminator field)
+ GetErrorReportingSystemCategoryClass() ErrorReportingSystemCategoryClass
+}
+
+// ErrorReportingSystemCategoryTypeExactly can be used when we want exactly this type and not a type which fulfills ErrorReportingSystemCategoryType.
+// This is useful for switch cases.
+type ErrorReportingSystemCategoryTypeExactly interface {
+ ErrorReportingSystemCategoryType
+ isErrorReportingSystemCategoryType() bool
+}
+
+// _ErrorReportingSystemCategoryType is the data-structure of this message
+type _ErrorReportingSystemCategoryType struct {
+ _ErrorReportingSystemCategoryTypeChildRequirements
+}
+
+type _ErrorReportingSystemCategoryTypeChildRequirements interface {
+ utils.Serializable
+ GetLengthInBits() uint16
+ GetLengthInBitsConditional(lastItem bool) uint16
+ GetErrorReportingSystemCategoryClass() ErrorReportingSystemCategoryClass
+}
+
+type ErrorReportingSystemCategoryTypeParent interface {
+ SerializeParent(writeBuffer utils.WriteBuffer, child ErrorReportingSystemCategoryType, serializeChildFunction func() error) error
+ GetTypeName() string
+}
+
+type ErrorReportingSystemCategoryTypeChild interface {
+ utils.Serializable
+ InitializeParent(parent ErrorReportingSystemCategoryType)
+ GetParent() *ErrorReportingSystemCategoryType
+
+ GetTypeName() string
+ ErrorReportingSystemCategoryType
+}
+
+// NewErrorReportingSystemCategoryType factory function for _ErrorReportingSystemCategoryType
+func NewErrorReportingSystemCategoryType() *_ErrorReportingSystemCategoryType {
+ return &_ErrorReportingSystemCategoryType{}
+}
+
+// Deprecated: use the interface for direct cast
+func CastErrorReportingSystemCategoryType(structType interface{}) ErrorReportingSystemCategoryType {
+ if casted, ok := structType.(ErrorReportingSystemCategoryType); ok {
+ return casted
+ }
+ if casted, ok := structType.(*ErrorReportingSystemCategoryType); ok {
+ return *casted
+ }
+ return nil
+}
+
+func (m *_ErrorReportingSystemCategoryType) GetTypeName() string {
+ return "ErrorReportingSystemCategoryType"
+}
+
+func (m *_ErrorReportingSystemCategoryType) GetParentLengthInBits() uint16 {
+ lengthInBits := uint16(0)
+
+ return lengthInBits
+}
+
+func (m *_ErrorReportingSystemCategoryType) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func ErrorReportingSystemCategoryTypeParse(readBuffer utils.ReadBuffer, errorReportingSystemCategoryClass ErrorReportingSystemCategoryClass) (ErrorReportingSystemCategoryType, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("ErrorReportingSystemCategoryType"); pullErr != nil {
+ return nil, errors.Wrap(pullErr, "Error pulling for ErrorReportingSystemCategoryType")
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type)
+ type ErrorReportingSystemCategoryTypeChildSerializeRequirement interface {
+ ErrorReportingSystemCategoryType
+ InitializeParent(ErrorReportingSystemCategoryType)
+ GetParent() ErrorReportingSystemCategoryType
+ }
+ var _childTemp interface{}
+ var _child ErrorReportingSystemCategoryTypeChildSerializeRequirement
+ var typeSwitchError error
+ switch {
+ case errorReportingSystemCategoryClass == ErrorReportingSystemCategoryClass_INPUT_UNITS: // ErrorReportingSystemCategoryTypeInputUnits
+ _childTemp, typeSwitchError = ErrorReportingSystemCategoryTypeInputUnitsParse(readBuffer, errorReportingSystemCategoryClass)
+ case errorReportingSystemCategoryClass == ErrorReportingSystemCategoryClass_SUPPORT_UNITS: // ErrorReportingSystemCategoryTypeSupportUnits
+ _childTemp, typeSwitchError = ErrorReportingSystemCategoryTypeSupportUnitsParse(readBuffer, errorReportingSystemCategoryClass)
+ case errorReportingSystemCategoryClass == ErrorReportingSystemCategoryClass_BUILDING_MANAGEMENT_SYSTEMS: // ErrorReportingSystemCategoryTypeBuildingManagementSystems
+ _childTemp, typeSwitchError = ErrorReportingSystemCategoryTypeBuildingManagementSystemsParse(readBuffer, errorReportingSystemCategoryClass)
+ case errorReportingSystemCategoryClass == ErrorReportingSystemCategoryClass_OUTPUT_UNITS: // ErrorReportingSystemCategoryTypeOutputUnits
+ _childTemp, typeSwitchError = ErrorReportingSystemCategoryTypeOutputUnitsParse(readBuffer, errorReportingSystemCategoryClass)
+ case errorReportingSystemCategoryClass == ErrorReportingSystemCategoryClass_CLIMATE_CONTROLLERS: // ErrorReportingSystemCategoryTypeClimateControllers
+ _childTemp, typeSwitchError = ErrorReportingSystemCategoryTypeClimateControllersParse(readBuffer, errorReportingSystemCategoryClass)
+ case 0 == 0: // ErrorReportingSystemCategoryTypeReserved
+ _childTemp, typeSwitchError = ErrorReportingSystemCategoryTypeReservedParse(readBuffer, errorReportingSystemCategoryClass)
+ default:
+ typeSwitchError = errors.Errorf("Unmapped type for parameters [errorReportingSystemCategoryClass=%v]", errorReportingSystemCategoryClass)
+ }
+ if typeSwitchError != nil {
+ return nil, errors.Wrap(typeSwitchError, "Error parsing sub-type for type-switch of ErrorReportingSystemCategoryType")
+ }
+ _child = _childTemp.(ErrorReportingSystemCategoryTypeChildSerializeRequirement)
+
+ if closeErr := readBuffer.CloseContext("ErrorReportingSystemCategoryType"); closeErr != nil {
+ return nil, errors.Wrap(closeErr, "Error closing for ErrorReportingSystemCategoryType")
+ }
+
+ // Finish initializing
+ _child.InitializeParent(_child)
+ return _child, nil
+}
+
+func (pm *_ErrorReportingSystemCategoryType) SerializeParent(writeBuffer utils.WriteBuffer, child ErrorReportingSystemCategoryType, serializeChildFunction func() error) error {
+ // We redirect all calls through client as some methods are only implemented there
+ m := child
+ _ = m
+ positionAware := writeBuffer
+ _ = positionAware
+ if pushErr := writeBuffer.PushContext("ErrorReportingSystemCategoryType"); pushErr != nil {
+ return errors.Wrap(pushErr, "Error pushing for ErrorReportingSystemCategoryType")
+ }
+
+ // 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("ErrorReportingSystemCategoryType"); popErr != nil {
+ return errors.Wrap(popErr, "Error popping for ErrorReportingSystemCategoryType")
+ }
+ return nil
+}
+
+func (m *_ErrorReportingSystemCategoryType) isErrorReportingSystemCategoryType() bool {
+ return true
+}
+
+func (m *_ErrorReportingSystemCategoryType) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ writeBuffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ if err := writeBuffer.WriteSerializable(m); err != nil {
+ return err.Error()
+ }
+ return writeBuffer.GetBox().String()
+}
diff --git a/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeBuildingManagementSystems.go b/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeBuildingManagementSystems.go
new file mode 100644
index 000000000..9ba099c7b
--- /dev/null
+++ b/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeBuildingManagementSystems.go
@@ -0,0 +1,204 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/spi/utils"
+ "github.com/pkg/errors"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// ErrorReportingSystemCategoryTypeBuildingManagementSystems is the corresponding interface of ErrorReportingSystemCategoryTypeBuildingManagementSystems
+type ErrorReportingSystemCategoryTypeBuildingManagementSystems interface {
+ utils.LengthAware
+ utils.Serializable
+ ErrorReportingSystemCategoryType
+ // GetCategoryForType returns CategoryForType (property field)
+ GetCategoryForType() ErrorReportingSystemCategoryTypeForBuildingManagementSystems
+}
+
+// ErrorReportingSystemCategoryTypeBuildingManagementSystemsExactly can be used when we want exactly this type and not a type which fulfills ErrorReportingSystemCategoryTypeBuildingManagementSystems.
+// This is useful for switch cases.
+type ErrorReportingSystemCategoryTypeBuildingManagementSystemsExactly interface {
+ ErrorReportingSystemCategoryTypeBuildingManagementSystems
+ isErrorReportingSystemCategoryTypeBuildingManagementSystems() bool
+}
+
+// _ErrorReportingSystemCategoryTypeBuildingManagementSystems is the data-structure of this message
+type _ErrorReportingSystemCategoryTypeBuildingManagementSystems struct {
+ *_ErrorReportingSystemCategoryType
+ CategoryForType ErrorReportingSystemCategoryTypeForBuildingManagementSystems
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for discriminator values.
+///////////////////////
+
+func (m *_ErrorReportingSystemCategoryTypeBuildingManagementSystems) GetErrorReportingSystemCategoryClass() ErrorReportingSystemCategoryClass {
+ return ErrorReportingSystemCategoryClass_BUILDING_MANAGEMENT_SYSTEMS
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+func (m *_ErrorReportingSystemCategoryTypeBuildingManagementSystems) InitializeParent(parent ErrorReportingSystemCategoryType) {
+}
+
+func (m *_ErrorReportingSystemCategoryTypeBuildingManagementSystems) GetParent() ErrorReportingSystemCategoryType {
+ return m._ErrorReportingSystemCategoryType
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *_ErrorReportingSystemCategoryTypeBuildingManagementSystems) GetCategoryForType() ErrorReportingSystemCategoryTypeForBuildingManagementSystems {
+ return m.CategoryForType
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewErrorReportingSystemCategoryTypeBuildingManagementSystems factory function for _ErrorReportingSystemCategoryTypeBuildingManagementSystems
+func NewErrorReportingSystemCategoryTypeBuildingManagementSystems(categoryForType ErrorReportingSystemCategoryTypeForBuildingManagementSystems) *_ErrorReportingSystemCategoryTypeBuildingManagementSystems {
+ _result := &_ErrorReportingSystemCategoryTypeBuildingManagementSystems{
+ CategoryForType: categoryForType,
+ _ErrorReportingSystemCategoryType: NewErrorReportingSystemCategoryType(),
+ }
+ _result._ErrorReportingSystemCategoryType._ErrorReportingSystemCategoryTypeChildRequirements = _result
+ return _result
+}
+
+// Deprecated: use the interface for direct cast
+func CastErrorReportingSystemCategoryTypeBuildingManagementSystems(structType interface{}) ErrorReportingSystemCategoryTypeBuildingManagementSystems {
+ if casted, ok := structType.(ErrorReportingSystemCategoryTypeBuildingManagementSystems); ok {
+ return casted
+ }
+ if casted, ok := structType.(*ErrorReportingSystemCategoryTypeBuildingManagementSystems); ok {
+ return *casted
+ }
+ return nil
+}
+
+func (m *_ErrorReportingSystemCategoryTypeBuildingManagementSystems) GetTypeName() string {
+ return "ErrorReportingSystemCategoryTypeBuildingManagementSystems"
+}
+
+func (m *_ErrorReportingSystemCategoryTypeBuildingManagementSystems) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *_ErrorReportingSystemCategoryTypeBuildingManagementSystems) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (categoryForType)
+ lengthInBits += 4
+
+ return lengthInBits
+}
+
+func (m *_ErrorReportingSystemCategoryTypeBuildingManagementSystems) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func ErrorReportingSystemCategoryTypeBuildingManagementSystemsParse(readBuffer utils.ReadBuffer, errorReportingSystemCategoryClass ErrorReportingSystemCategoryClass) (ErrorReportingSystemCategoryTypeBuildingManagementSystems, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("ErrorReportingSystemCategoryTypeBuildingManagementSystems"); pullErr != nil {
+ return nil, errors.Wrap(pullErr, "Error pulling for ErrorReportingSystemCategoryTypeBuildingManagementSystems")
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (categoryForType)
+ if pullErr := readBuffer.PullContext("categoryForType"); pullErr != nil {
+ return nil, errors.Wrap(pullErr, "Error pulling for categoryForType")
+ }
+ _categoryForType, _categoryForTypeErr := ErrorReportingSystemCategoryTypeForBuildingManagementSystemsParse(readBuffer)
+ if _categoryForTypeErr != nil {
+ return nil, errors.Wrap(_categoryForTypeErr, "Error parsing 'categoryForType' field of ErrorReportingSystemCategoryTypeBuildingManagementSystems")
+ }
+ categoryForType := _categoryForType
+ if closeErr := readBuffer.CloseContext("categoryForType"); closeErr != nil {
+ return nil, errors.Wrap(closeErr, "Error closing for categoryForType")
+ }
+
+ if closeErr := readBuffer.CloseContext("ErrorReportingSystemCategoryTypeBuildingManagementSystems"); closeErr != nil {
+ return nil, errors.Wrap(closeErr, "Error closing for ErrorReportingSystemCategoryTypeBuildingManagementSystems")
+ }
+
+ // Create a partially initialized instance
+ _child := &_ErrorReportingSystemCategoryTypeBuildingManagementSystems{
+ CategoryForType: categoryForType,
+ _ErrorReportingSystemCategoryType: &_ErrorReportingSystemCategoryType{},
+ }
+ _child._ErrorReportingSystemCategoryType._ErrorReportingSystemCategoryTypeChildRequirements = _child
+ return _child, nil
+}
+
+func (m *_ErrorReportingSystemCategoryTypeBuildingManagementSystems) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("ErrorReportingSystemCategoryTypeBuildingManagementSystems"); pushErr != nil {
+ return errors.Wrap(pushErr, "Error pushing for ErrorReportingSystemCategoryTypeBuildingManagementSystems")
+ }
+
+ // Simple Field (categoryForType)
+ if pushErr := writeBuffer.PushContext("categoryForType"); pushErr != nil {
+ return errors.Wrap(pushErr, "Error pushing for categoryForType")
+ }
+ _categoryForTypeErr := writeBuffer.WriteSerializable(m.GetCategoryForType())
+ if popErr := writeBuffer.PopContext("categoryForType"); popErr != nil {
+ return errors.Wrap(popErr, "Error popping for categoryForType")
+ }
+ if _categoryForTypeErr != nil {
+ return errors.Wrap(_categoryForTypeErr, "Error serializing 'categoryForType' field")
+ }
+
+ if popErr := writeBuffer.PopContext("ErrorReportingSystemCategoryTypeBuildingManagementSystems"); popErr != nil {
+ return errors.Wrap(popErr, "Error popping for ErrorReportingSystemCategoryTypeBuildingManagementSystems")
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *_ErrorReportingSystemCategoryTypeBuildingManagementSystems) isErrorReportingSystemCategoryTypeBuildingManagementSystems() bool {
+ return true
+}
+
+func (m *_ErrorReportingSystemCategoryTypeBuildingManagementSystems) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ writeBuffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ if err := writeBuffer.WriteSerializable(m); err != nil {
+ return err.Error()
+ }
+ return writeBuffer.GetBox().String()
+}
diff --git a/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeClimateControllers.go b/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeClimateControllers.go
new file mode 100644
index 000000000..9ad0ca52a
--- /dev/null
+++ b/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeClimateControllers.go
@@ -0,0 +1,204 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/spi/utils"
+ "github.com/pkg/errors"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// ErrorReportingSystemCategoryTypeClimateControllers is the corresponding interface of ErrorReportingSystemCategoryTypeClimateControllers
+type ErrorReportingSystemCategoryTypeClimateControllers interface {
+ utils.LengthAware
+ utils.Serializable
+ ErrorReportingSystemCategoryType
+ // GetCategoryForType returns CategoryForType (property field)
+ GetCategoryForType() ErrorReportingSystemCategoryTypeForClimateControllers
+}
+
+// ErrorReportingSystemCategoryTypeClimateControllersExactly can be used when we want exactly this type and not a type which fulfills ErrorReportingSystemCategoryTypeClimateControllers.
+// This is useful for switch cases.
+type ErrorReportingSystemCategoryTypeClimateControllersExactly interface {
+ ErrorReportingSystemCategoryTypeClimateControllers
+ isErrorReportingSystemCategoryTypeClimateControllers() bool
+}
+
+// _ErrorReportingSystemCategoryTypeClimateControllers is the data-structure of this message
+type _ErrorReportingSystemCategoryTypeClimateControllers struct {
+ *_ErrorReportingSystemCategoryType
+ CategoryForType ErrorReportingSystemCategoryTypeForClimateControllers
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for discriminator values.
+///////////////////////
+
+func (m *_ErrorReportingSystemCategoryTypeClimateControllers) GetErrorReportingSystemCategoryClass() ErrorReportingSystemCategoryClass {
+ return ErrorReportingSystemCategoryClass_CLIMATE_CONTROLLERS
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+func (m *_ErrorReportingSystemCategoryTypeClimateControllers) InitializeParent(parent ErrorReportingSystemCategoryType) {
+}
+
+func (m *_ErrorReportingSystemCategoryTypeClimateControllers) GetParent() ErrorReportingSystemCategoryType {
+ return m._ErrorReportingSystemCategoryType
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *_ErrorReportingSystemCategoryTypeClimateControllers) GetCategoryForType() ErrorReportingSystemCategoryTypeForClimateControllers {
+ return m.CategoryForType
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewErrorReportingSystemCategoryTypeClimateControllers factory function for _ErrorReportingSystemCategoryTypeClimateControllers
+func NewErrorReportingSystemCategoryTypeClimateControllers(categoryForType ErrorReportingSystemCategoryTypeForClimateControllers) *_ErrorReportingSystemCategoryTypeClimateControllers {
+ _result := &_ErrorReportingSystemCategoryTypeClimateControllers{
+ CategoryForType: categoryForType,
+ _ErrorReportingSystemCategoryType: NewErrorReportingSystemCategoryType(),
+ }
+ _result._ErrorReportingSystemCategoryType._ErrorReportingSystemCategoryTypeChildRequirements = _result
+ return _result
+}
+
+// Deprecated: use the interface for direct cast
+func CastErrorReportingSystemCategoryTypeClimateControllers(structType interface{}) ErrorReportingSystemCategoryTypeClimateControllers {
+ if casted, ok := structType.(ErrorReportingSystemCategoryTypeClimateControllers); ok {
+ return casted
+ }
+ if casted, ok := structType.(*ErrorReportingSystemCategoryTypeClimateControllers); ok {
+ return *casted
+ }
+ return nil
+}
+
+func (m *_ErrorReportingSystemCategoryTypeClimateControllers) GetTypeName() string {
+ return "ErrorReportingSystemCategoryTypeClimateControllers"
+}
+
+func (m *_ErrorReportingSystemCategoryTypeClimateControllers) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *_ErrorReportingSystemCategoryTypeClimateControllers) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (categoryForType)
+ lengthInBits += 4
+
+ return lengthInBits
+}
+
+func (m *_ErrorReportingSystemCategoryTypeClimateControllers) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func ErrorReportingSystemCategoryTypeClimateControllersParse(readBuffer utils.ReadBuffer, errorReportingSystemCategoryClass ErrorReportingSystemCategoryClass) (ErrorReportingSystemCategoryTypeClimateControllers, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("ErrorReportingSystemCategoryTypeClimateControllers"); pullErr != nil {
+ return nil, errors.Wrap(pullErr, "Error pulling for ErrorReportingSystemCategoryTypeClimateControllers")
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (categoryForType)
+ if pullErr := readBuffer.PullContext("categoryForType"); pullErr != nil {
+ return nil, errors.Wrap(pullErr, "Error pulling for categoryForType")
+ }
+ _categoryForType, _categoryForTypeErr := ErrorReportingSystemCategoryTypeForClimateControllersParse(readBuffer)
+ if _categoryForTypeErr != nil {
+ return nil, errors.Wrap(_categoryForTypeErr, "Error parsing 'categoryForType' field of ErrorReportingSystemCategoryTypeClimateControllers")
+ }
+ categoryForType := _categoryForType
+ if closeErr := readBuffer.CloseContext("categoryForType"); closeErr != nil {
+ return nil, errors.Wrap(closeErr, "Error closing for categoryForType")
+ }
+
+ if closeErr := readBuffer.CloseContext("ErrorReportingSystemCategoryTypeClimateControllers"); closeErr != nil {
+ return nil, errors.Wrap(closeErr, "Error closing for ErrorReportingSystemCategoryTypeClimateControllers")
+ }
+
+ // Create a partially initialized instance
+ _child := &_ErrorReportingSystemCategoryTypeClimateControllers{
+ CategoryForType: categoryForType,
+ _ErrorReportingSystemCategoryType: &_ErrorReportingSystemCategoryType{},
+ }
+ _child._ErrorReportingSystemCategoryType._ErrorReportingSystemCategoryTypeChildRequirements = _child
+ return _child, nil
+}
+
+func (m *_ErrorReportingSystemCategoryTypeClimateControllers) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("ErrorReportingSystemCategoryTypeClimateControllers"); pushErr != nil {
+ return errors.Wrap(pushErr, "Error pushing for ErrorReportingSystemCategoryTypeClimateControllers")
+ }
+
+ // Simple Field (categoryForType)
+ if pushErr := writeBuffer.PushContext("categoryForType"); pushErr != nil {
+ return errors.Wrap(pushErr, "Error pushing for categoryForType")
+ }
+ _categoryForTypeErr := writeBuffer.WriteSerializable(m.GetCategoryForType())
+ if popErr := writeBuffer.PopContext("categoryForType"); popErr != nil {
+ return errors.Wrap(popErr, "Error popping for categoryForType")
+ }
+ if _categoryForTypeErr != nil {
+ return errors.Wrap(_categoryForTypeErr, "Error serializing 'categoryForType' field")
+ }
+
+ if popErr := writeBuffer.PopContext("ErrorReportingSystemCategoryTypeClimateControllers"); popErr != nil {
+ return errors.Wrap(popErr, "Error popping for ErrorReportingSystemCategoryTypeClimateControllers")
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *_ErrorReportingSystemCategoryTypeClimateControllers) isErrorReportingSystemCategoryTypeClimateControllers() bool {
+ return true
+}
+
+func (m *_ErrorReportingSystemCategoryTypeClimateControllers) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ writeBuffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ if err := writeBuffer.WriteSerializable(m); err != nil {
+ return err.Error()
+ }
+ return writeBuffer.GetBox().String()
+}
diff --git a/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeForBuildingManagementSystems.go b/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeForBuildingManagementSystems.go
new file mode 100644
index 000000000..d5d70dc3b
--- /dev/null
+++ b/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeForBuildingManagementSystems.go
@@ -0,0 +1,241 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/spi/utils"
+ "github.com/pkg/errors"
+ "github.com/rs/zerolog/log"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// ErrorReportingSystemCategoryTypeForBuildingManagementSystems is an enum
+type ErrorReportingSystemCategoryTypeForBuildingManagementSystems uint8
+
+type IErrorReportingSystemCategoryTypeForBuildingManagementSystems interface {
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+const (
+ ErrorReportingSystemCategoryTypeForBuildingManagementSystems_BMS_DIAGNOSTIC_REPORTING ErrorReportingSystemCategoryTypeForBuildingManagementSystems = 0x0
+ ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_1 ErrorReportingSystemCategoryTypeForBuildingManagementSystems = 0x1
+ ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_2 ErrorReportingSystemCategoryTypeForBuildingManagementSystems = 0x2
+ ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_3 ErrorReportingSystemCategoryTypeForBuildingManagementSystems = 0x3
+ ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_4 ErrorReportingSystemCategoryTypeForBuildingManagementSystems = 0x4
+ ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_5 ErrorReportingSystemCategoryTypeForBuildingManagementSystems = 0x5
+ ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_6 ErrorReportingSystemCategoryTypeForBuildingManagementSystems = 0x6
+ ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_7 ErrorReportingSystemCategoryTypeForBuildingManagementSystems = 0x7
+ ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_8 ErrorReportingSystemCategoryTypeForBuildingManagementSystems = 0x8
+ ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_9 ErrorReportingSystemCategoryTypeForBuildingManagementSystems = 0x9
+ ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_10 ErrorReportingSystemCategoryTypeForBuildingManagementSystems = 0xA
+ ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_11 ErrorReportingSystemCategoryTypeForBuildingManagementSystems = 0xB
+ ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_12 ErrorReportingSystemCategoryTypeForBuildingManagementSystems = 0xC
+ ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_13 ErrorReportingSystemCategoryTypeForBuildingManagementSystems = 0xD
+ ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_14 ErrorReportingSystemCategoryTypeForBuildingManagementSystems = 0xE
+ ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_15 ErrorReportingSystemCategoryTypeForBuildingManagementSystems = 0xF
+)
+
+var ErrorReportingSystemCategoryTypeForBuildingManagementSystemsValues []ErrorReportingSystemCategoryTypeForBuildingManagementSystems
+
+func init() {
+ _ = errors.New
+ ErrorReportingSystemCategoryTypeForBuildingManagementSystemsValues = []ErrorReportingSystemCategoryTypeForBuildingManagementSystems{
+ ErrorReportingSystemCategoryTypeForBuildingManagementSystems_BMS_DIAGNOSTIC_REPORTING,
+ ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_1,
+ ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_2,
+ ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_3,
+ ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_4,
+ ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_5,
+ ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_6,
+ ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_7,
+ ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_8,
+ ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_9,
+ ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_10,
+ ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_11,
+ ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_12,
+ ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_13,
+ ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_14,
+ ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_15,
+ }
+}
+
+func ErrorReportingSystemCategoryTypeForBuildingManagementSystemsByValue(value uint8) (enum ErrorReportingSystemCategoryTypeForBuildingManagementSystems, ok bool) {
+ switch value {
+ case 0x0:
+ return ErrorReportingSystemCategoryTypeForBuildingManagementSystems_BMS_DIAGNOSTIC_REPORTING, true
+ case 0x1:
+ return ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_1, true
+ case 0x2:
+ return ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_2, true
+ case 0x3:
+ return ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_3, true
+ case 0x4:
+ return ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_4, true
+ case 0x5:
+ return ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_5, true
+ case 0x6:
+ return ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_6, true
+ case 0x7:
+ return ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_7, true
+ case 0x8:
+ return ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_8, true
+ case 0x9:
+ return ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_9, true
+ case 0xA:
+ return ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_10, true
+ case 0xB:
+ return ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_11, true
+ case 0xC:
+ return ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_12, true
+ case 0xD:
+ return ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_13, true
+ case 0xE:
+ return ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_14, true
+ case 0xF:
+ return ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_15, true
+ }
+ return 0, false
+}
+
+func ErrorReportingSystemCategoryTypeForBuildingManagementSystemsByName(value string) (enum ErrorReportingSystemCategoryTypeForBuildingManagementSystems, ok bool) {
+ switch value {
+ case "BMS_DIAGNOSTIC_REPORTING":
+ return ErrorReportingSystemCategoryTypeForBuildingManagementSystems_BMS_DIAGNOSTIC_REPORTING, true
+ case "RESERVED_1":
+ return ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_1, true
+ case "RESERVED_2":
+ return ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_2, true
+ case "RESERVED_3":
+ return ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_3, true
+ case "RESERVED_4":
+ return ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_4, true
+ case "RESERVED_5":
+ return ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_5, true
+ case "RESERVED_6":
+ return ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_6, true
+ case "RESERVED_7":
+ return ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_7, true
+ case "RESERVED_8":
+ return ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_8, true
+ case "RESERVED_9":
+ return ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_9, true
+ case "RESERVED_10":
+ return ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_10, true
+ case "RESERVED_11":
+ return ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_11, true
+ case "RESERVED_12":
+ return ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_12, true
+ case "RESERVED_13":
+ return ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_13, true
+ case "RESERVED_14":
+ return ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_14, true
+ case "RESERVED_15":
+ return ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_15, true
+ }
+ return 0, false
+}
+
+func ErrorReportingSystemCategoryTypeForBuildingManagementSystemsKnows(value uint8) bool {
+ for _, typeValue := range ErrorReportingSystemCategoryTypeForBuildingManagementSystemsValues {
+ if uint8(typeValue) == value {
+ return true
+ }
+ }
+ return false
+}
+
+func CastErrorReportingSystemCategoryTypeForBuildingManagementSystems(structType interface{}) ErrorReportingSystemCategoryTypeForBuildingManagementSystems {
+ castFunc := func(typ interface{}) ErrorReportingSystemCategoryTypeForBuildingManagementSystems {
+ if sErrorReportingSystemCategoryTypeForBuildingManagementSystems, ok := typ.(ErrorReportingSystemCategoryTypeForBuildingManagementSystems); ok {
+ return sErrorReportingSystemCategoryTypeForBuildingManagementSystems
+ }
+ return 0
+ }
+ return castFunc(structType)
+}
+
+func (m ErrorReportingSystemCategoryTypeForBuildingManagementSystems) GetLengthInBits() uint16 {
+ return 4
+}
+
+func (m ErrorReportingSystemCategoryTypeForBuildingManagementSystems) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func ErrorReportingSystemCategoryTypeForBuildingManagementSystemsParse(readBuffer utils.ReadBuffer) (ErrorReportingSystemCategoryTypeForBuildingManagementSystems, error) {
+ val, err := readBuffer.ReadUint8("ErrorReportingSystemCategoryTypeForBuildingManagementSystems", 4)
+ if err != nil {
+ return 0, errors.Wrap(err, "error reading ErrorReportingSystemCategoryTypeForBuildingManagementSystems")
+ }
+ if enum, ok := ErrorReportingSystemCategoryTypeForBuildingManagementSystemsByValue(val); !ok {
+ log.Debug().Msgf("no value %x found for RequestType", val)
+ return ErrorReportingSystemCategoryTypeForBuildingManagementSystems(val), nil
+ } else {
+ return enum, nil
+ }
+}
+
+func (e ErrorReportingSystemCategoryTypeForBuildingManagementSystems) Serialize(writeBuffer utils.WriteBuffer) error {
+ return writeBuffer.WriteUint8("ErrorReportingSystemCategoryTypeForBuildingManagementSystems", 4, uint8(e), utils.WithAdditionalStringRepresentation(e.PLC4XEnumName()))
+}
+
+// PLC4XEnumName returns the name that is used in code to identify this enum
+func (e ErrorReportingSystemCategoryTypeForBuildingManagementSystems) PLC4XEnumName() string {
+ switch e {
+ case ErrorReportingSystemCategoryTypeForBuildingManagementSystems_BMS_DIAGNOSTIC_REPORTING:
+ return "BMS_DIAGNOSTIC_REPORTING"
+ case ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_1:
+ return "RESERVED_1"
+ case ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_2:
+ return "RESERVED_2"
+ case ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_3:
+ return "RESERVED_3"
+ case ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_4:
+ return "RESERVED_4"
+ case ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_5:
+ return "RESERVED_5"
+ case ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_6:
+ return "RESERVED_6"
+ case ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_7:
+ return "RESERVED_7"
+ case ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_8:
+ return "RESERVED_8"
+ case ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_9:
+ return "RESERVED_9"
+ case ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_10:
+ return "RESERVED_10"
+ case ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_11:
+ return "RESERVED_11"
+ case ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_12:
+ return "RESERVED_12"
+ case ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_13:
+ return "RESERVED_13"
+ case ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_14:
+ return "RESERVED_14"
+ case ErrorReportingSystemCategoryTypeForBuildingManagementSystems_RESERVED_15:
+ return "RESERVED_15"
+ }
+ return ""
+}
+
+func (e ErrorReportingSystemCategoryTypeForBuildingManagementSystems) String() string {
+ return e.PLC4XEnumName()
+}
diff --git a/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeForClimateControllers.go b/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeForClimateControllers.go
new file mode 100644
index 000000000..ac7205dfc
--- /dev/null
+++ b/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeForClimateControllers.go
@@ -0,0 +1,241 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/spi/utils"
+ "github.com/pkg/errors"
+ "github.com/rs/zerolog/log"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// ErrorReportingSystemCategoryTypeForClimateControllers is an enum
+type ErrorReportingSystemCategoryTypeForClimateControllers uint8
+
+type IErrorReportingSystemCategoryTypeForClimateControllers interface {
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+const (
+ ErrorReportingSystemCategoryTypeForClimateControllers_AIR_CONDITIONING_SYSTEM ErrorReportingSystemCategoryTypeForClimateControllers = 0x0
+ ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_1 ErrorReportingSystemCategoryTypeForClimateControllers = 0x1
+ ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_2 ErrorReportingSystemCategoryTypeForClimateControllers = 0x2
+ ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_3 ErrorReportingSystemCategoryTypeForClimateControllers = 0x3
+ ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_4 ErrorReportingSystemCategoryTypeForClimateControllers = 0x4
+ ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_5 ErrorReportingSystemCategoryTypeForClimateControllers = 0x5
+ ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_6 ErrorReportingSystemCategoryTypeForClimateControllers = 0x6
+ ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_7 ErrorReportingSystemCategoryTypeForClimateControllers = 0x7
+ ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_8 ErrorReportingSystemCategoryTypeForClimateControllers = 0x8
+ ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_9 ErrorReportingSystemCategoryTypeForClimateControllers = 0x9
+ ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_10 ErrorReportingSystemCategoryTypeForClimateControllers = 0xA
+ ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_11 ErrorReportingSystemCategoryTypeForClimateControllers = 0xB
+ ErrorReportingSystemCategoryTypeForClimateControllers_GLOBAL_WARMING_MODULATOR ErrorReportingSystemCategoryTypeForClimateControllers = 0xC
+ ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_13 ErrorReportingSystemCategoryTypeForClimateControllers = 0xD
+ ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_14 ErrorReportingSystemCategoryTypeForClimateControllers = 0xE
+ ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_15 ErrorReportingSystemCategoryTypeForClimateControllers = 0xF
+)
+
+var ErrorReportingSystemCategoryTypeForClimateControllersValues []ErrorReportingSystemCategoryTypeForClimateControllers
+
+func init() {
+ _ = errors.New
+ ErrorReportingSystemCategoryTypeForClimateControllersValues = []ErrorReportingSystemCategoryTypeForClimateControllers{
+ ErrorReportingSystemCategoryTypeForClimateControllers_AIR_CONDITIONING_SYSTEM,
+ ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_1,
+ ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_2,
+ ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_3,
+ ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_4,
+ ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_5,
+ ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_6,
+ ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_7,
+ ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_8,
+ ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_9,
+ ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_10,
+ ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_11,
+ ErrorReportingSystemCategoryTypeForClimateControllers_GLOBAL_WARMING_MODULATOR,
+ ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_13,
+ ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_14,
+ ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_15,
+ }
+}
+
+func ErrorReportingSystemCategoryTypeForClimateControllersByValue(value uint8) (enum ErrorReportingSystemCategoryTypeForClimateControllers, ok bool) {
+ switch value {
+ case 0x0:
+ return ErrorReportingSystemCategoryTypeForClimateControllers_AIR_CONDITIONING_SYSTEM, true
+ case 0x1:
+ return ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_1, true
+ case 0x2:
+ return ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_2, true
+ case 0x3:
+ return ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_3, true
+ case 0x4:
+ return ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_4, true
+ case 0x5:
+ return ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_5, true
+ case 0x6:
+ return ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_6, true
+ case 0x7:
+ return ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_7, true
+ case 0x8:
+ return ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_8, true
+ case 0x9:
+ return ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_9, true
+ case 0xA:
+ return ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_10, true
+ case 0xB:
+ return ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_11, true
+ case 0xC:
+ return ErrorReportingSystemCategoryTypeForClimateControllers_GLOBAL_WARMING_MODULATOR, true
+ case 0xD:
+ return ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_13, true
+ case 0xE:
+ return ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_14, true
+ case 0xF:
+ return ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_15, true
+ }
+ return 0, false
+}
+
+func ErrorReportingSystemCategoryTypeForClimateControllersByName(value string) (enum ErrorReportingSystemCategoryTypeForClimateControllers, ok bool) {
+ switch value {
+ case "AIR_CONDITIONING_SYSTEM":
+ return ErrorReportingSystemCategoryTypeForClimateControllers_AIR_CONDITIONING_SYSTEM, true
+ case "RESERVED_1":
+ return ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_1, true
+ case "RESERVED_2":
+ return ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_2, true
+ case "RESERVED_3":
+ return ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_3, true
+ case "RESERVED_4":
+ return ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_4, true
+ case "RESERVED_5":
+ return ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_5, true
+ case "RESERVED_6":
+ return ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_6, true
+ case "RESERVED_7":
+ return ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_7, true
+ case "RESERVED_8":
+ return ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_8, true
+ case "RESERVED_9":
+ return ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_9, true
+ case "RESERVED_10":
+ return ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_10, true
+ case "RESERVED_11":
+ return ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_11, true
+ case "GLOBAL_WARMING_MODULATOR":
+ return ErrorReportingSystemCategoryTypeForClimateControllers_GLOBAL_WARMING_MODULATOR, true
+ case "RESERVED_13":
+ return ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_13, true
+ case "RESERVED_14":
+ return ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_14, true
+ case "RESERVED_15":
+ return ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_15, true
+ }
+ return 0, false
+}
+
+func ErrorReportingSystemCategoryTypeForClimateControllersKnows(value uint8) bool {
+ for _, typeValue := range ErrorReportingSystemCategoryTypeForClimateControllersValues {
+ if uint8(typeValue) == value {
+ return true
+ }
+ }
+ return false
+}
+
+func CastErrorReportingSystemCategoryTypeForClimateControllers(structType interface{}) ErrorReportingSystemCategoryTypeForClimateControllers {
+ castFunc := func(typ interface{}) ErrorReportingSystemCategoryTypeForClimateControllers {
+ if sErrorReportingSystemCategoryTypeForClimateControllers, ok := typ.(ErrorReportingSystemCategoryTypeForClimateControllers); ok {
+ return sErrorReportingSystemCategoryTypeForClimateControllers
+ }
+ return 0
+ }
+ return castFunc(structType)
+}
+
+func (m ErrorReportingSystemCategoryTypeForClimateControllers) GetLengthInBits() uint16 {
+ return 4
+}
+
+func (m ErrorReportingSystemCategoryTypeForClimateControllers) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func ErrorReportingSystemCategoryTypeForClimateControllersParse(readBuffer utils.ReadBuffer) (ErrorReportingSystemCategoryTypeForClimateControllers, error) {
+ val, err := readBuffer.ReadUint8("ErrorReportingSystemCategoryTypeForClimateControllers", 4)
+ if err != nil {
+ return 0, errors.Wrap(err, "error reading ErrorReportingSystemCategoryTypeForClimateControllers")
+ }
+ if enum, ok := ErrorReportingSystemCategoryTypeForClimateControllersByValue(val); !ok {
+ log.Debug().Msgf("no value %x found for RequestType", val)
+ return ErrorReportingSystemCategoryTypeForClimateControllers(val), nil
+ } else {
+ return enum, nil
+ }
+}
+
+func (e ErrorReportingSystemCategoryTypeForClimateControllers) Serialize(writeBuffer utils.WriteBuffer) error {
+ return writeBuffer.WriteUint8("ErrorReportingSystemCategoryTypeForClimateControllers", 4, uint8(e), utils.WithAdditionalStringRepresentation(e.PLC4XEnumName()))
+}
+
+// PLC4XEnumName returns the name that is used in code to identify this enum
+func (e ErrorReportingSystemCategoryTypeForClimateControllers) PLC4XEnumName() string {
+ switch e {
+ case ErrorReportingSystemCategoryTypeForClimateControllers_AIR_CONDITIONING_SYSTEM:
+ return "AIR_CONDITIONING_SYSTEM"
+ case ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_1:
+ return "RESERVED_1"
+ case ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_2:
+ return "RESERVED_2"
+ case ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_3:
+ return "RESERVED_3"
+ case ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_4:
+ return "RESERVED_4"
+ case ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_5:
+ return "RESERVED_5"
+ case ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_6:
+ return "RESERVED_6"
+ case ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_7:
+ return "RESERVED_7"
+ case ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_8:
+ return "RESERVED_8"
+ case ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_9:
+ return "RESERVED_9"
+ case ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_10:
+ return "RESERVED_10"
+ case ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_11:
+ return "RESERVED_11"
+ case ErrorReportingSystemCategoryTypeForClimateControllers_GLOBAL_WARMING_MODULATOR:
+ return "GLOBAL_WARMING_MODULATOR"
+ case ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_13:
+ return "RESERVED_13"
+ case ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_14:
+ return "RESERVED_14"
+ case ErrorReportingSystemCategoryTypeForClimateControllers_RESERVED_15:
+ return "RESERVED_15"
+ }
+ return ""
+}
+
+func (e ErrorReportingSystemCategoryTypeForClimateControllers) String() string {
+ return e.PLC4XEnumName()
+}
diff --git a/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeForInputUnits.go b/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeForInputUnits.go
new file mode 100644
index 000000000..ae5278325
--- /dev/null
+++ b/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeForInputUnits.go
@@ -0,0 +1,241 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/spi/utils"
+ "github.com/pkg/errors"
+ "github.com/rs/zerolog/log"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// ErrorReportingSystemCategoryTypeForInputUnits is an enum
+type ErrorReportingSystemCategoryTypeForInputUnits uint8
+
+type IErrorReportingSystemCategoryTypeForInputUnits interface {
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+const (
+ ErrorReportingSystemCategoryTypeForInputUnits_KEY_UNITS ErrorReportingSystemCategoryTypeForInputUnits = 0x0
+ ErrorReportingSystemCategoryTypeForInputUnits_TELECOMMAND_AND_REMOTE_ENTRY ErrorReportingSystemCategoryTypeForInputUnits = 0x1
+ ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_2 ErrorReportingSystemCategoryTypeForInputUnits = 0x2
+ ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_3 ErrorReportingSystemCategoryTypeForInputUnits = 0x3
+ ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_4 ErrorReportingSystemCategoryTypeForInputUnits = 0x4
+ ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_5 ErrorReportingSystemCategoryTypeForInputUnits = 0x5
+ ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_6 ErrorReportingSystemCategoryTypeForInputUnits = 0x6
+ ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_7 ErrorReportingSystemCategoryTypeForInputUnits = 0x7
+ ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_8 ErrorReportingSystemCategoryTypeForInputUnits = 0x8
+ ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_9 ErrorReportingSystemCategoryTypeForInputUnits = 0x9
+ ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_10 ErrorReportingSystemCategoryTypeForInputUnits = 0xA
+ ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_11 ErrorReportingSystemCategoryTypeForInputUnits = 0xB
+ ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_12 ErrorReportingSystemCategoryTypeForInputUnits = 0xC
+ ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_13 ErrorReportingSystemCategoryTypeForInputUnits = 0xD
+ ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_14 ErrorReportingSystemCategoryTypeForInputUnits = 0xE
+ ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_15 ErrorReportingSystemCategoryTypeForInputUnits = 0xF
+)
+
+var ErrorReportingSystemCategoryTypeForInputUnitsValues []ErrorReportingSystemCategoryTypeForInputUnits
+
+func init() {
+ _ = errors.New
+ ErrorReportingSystemCategoryTypeForInputUnitsValues = []ErrorReportingSystemCategoryTypeForInputUnits{
+ ErrorReportingSystemCategoryTypeForInputUnits_KEY_UNITS,
+ ErrorReportingSystemCategoryTypeForInputUnits_TELECOMMAND_AND_REMOTE_ENTRY,
+ ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_2,
+ ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_3,
+ ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_4,
+ ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_5,
+ ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_6,
+ ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_7,
+ ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_8,
+ ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_9,
+ ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_10,
+ ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_11,
+ ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_12,
+ ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_13,
+ ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_14,
+ ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_15,
+ }
+}
+
+func ErrorReportingSystemCategoryTypeForInputUnitsByValue(value uint8) (enum ErrorReportingSystemCategoryTypeForInputUnits, ok bool) {
+ switch value {
+ case 0x0:
+ return ErrorReportingSystemCategoryTypeForInputUnits_KEY_UNITS, true
+ case 0x1:
+ return ErrorReportingSystemCategoryTypeForInputUnits_TELECOMMAND_AND_REMOTE_ENTRY, true
+ case 0x2:
+ return ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_2, true
+ case 0x3:
+ return ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_3, true
+ case 0x4:
+ return ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_4, true
+ case 0x5:
+ return ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_5, true
+ case 0x6:
+ return ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_6, true
+ case 0x7:
+ return ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_7, true
+ case 0x8:
+ return ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_8, true
+ case 0x9:
+ return ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_9, true
+ case 0xA:
+ return ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_10, true
+ case 0xB:
+ return ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_11, true
+ case 0xC:
+ return ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_12, true
+ case 0xD:
+ return ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_13, true
+ case 0xE:
+ return ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_14, true
+ case 0xF:
+ return ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_15, true
+ }
+ return 0, false
+}
+
+func ErrorReportingSystemCategoryTypeForInputUnitsByName(value string) (enum ErrorReportingSystemCategoryTypeForInputUnits, ok bool) {
+ switch value {
+ case "KEY_UNITS":
+ return ErrorReportingSystemCategoryTypeForInputUnits_KEY_UNITS, true
+ case "TELECOMMAND_AND_REMOTE_ENTRY":
+ return ErrorReportingSystemCategoryTypeForInputUnits_TELECOMMAND_AND_REMOTE_ENTRY, true
+ case "RESERVED_2":
+ return ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_2, true
+ case "RESERVED_3":
+ return ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_3, true
+ case "RESERVED_4":
+ return ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_4, true
+ case "RESERVED_5":
+ return ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_5, true
+ case "RESERVED_6":
+ return ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_6, true
+ case "RESERVED_7":
+ return ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_7, true
+ case "RESERVED_8":
+ return ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_8, true
+ case "RESERVED_9":
+ return ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_9, true
+ case "RESERVED_10":
+ return ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_10, true
+ case "RESERVED_11":
+ return ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_11, true
+ case "RESERVED_12":
+ return ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_12, true
+ case "RESERVED_13":
+ return ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_13, true
+ case "RESERVED_14":
+ return ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_14, true
+ case "RESERVED_15":
+ return ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_15, true
+ }
+ return 0, false
+}
+
+func ErrorReportingSystemCategoryTypeForInputUnitsKnows(value uint8) bool {
+ for _, typeValue := range ErrorReportingSystemCategoryTypeForInputUnitsValues {
+ if uint8(typeValue) == value {
+ return true
+ }
+ }
+ return false
+}
+
+func CastErrorReportingSystemCategoryTypeForInputUnits(structType interface{}) ErrorReportingSystemCategoryTypeForInputUnits {
+ castFunc := func(typ interface{}) ErrorReportingSystemCategoryTypeForInputUnits {
+ if sErrorReportingSystemCategoryTypeForInputUnits, ok := typ.(ErrorReportingSystemCategoryTypeForInputUnits); ok {
+ return sErrorReportingSystemCategoryTypeForInputUnits
+ }
+ return 0
+ }
+ return castFunc(structType)
+}
+
+func (m ErrorReportingSystemCategoryTypeForInputUnits) GetLengthInBits() uint16 {
+ return 4
+}
+
+func (m ErrorReportingSystemCategoryTypeForInputUnits) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func ErrorReportingSystemCategoryTypeForInputUnitsParse(readBuffer utils.ReadBuffer) (ErrorReportingSystemCategoryTypeForInputUnits, error) {
+ val, err := readBuffer.ReadUint8("ErrorReportingSystemCategoryTypeForInputUnits", 4)
+ if err != nil {
+ return 0, errors.Wrap(err, "error reading ErrorReportingSystemCategoryTypeForInputUnits")
+ }
+ if enum, ok := ErrorReportingSystemCategoryTypeForInputUnitsByValue(val); !ok {
+ log.Debug().Msgf("no value %x found for RequestType", val)
+ return ErrorReportingSystemCategoryTypeForInputUnits(val), nil
+ } else {
+ return enum, nil
+ }
+}
+
+func (e ErrorReportingSystemCategoryTypeForInputUnits) Serialize(writeBuffer utils.WriteBuffer) error {
+ return writeBuffer.WriteUint8("ErrorReportingSystemCategoryTypeForInputUnits", 4, uint8(e), utils.WithAdditionalStringRepresentation(e.PLC4XEnumName()))
+}
+
+// PLC4XEnumName returns the name that is used in code to identify this enum
+func (e ErrorReportingSystemCategoryTypeForInputUnits) PLC4XEnumName() string {
+ switch e {
+ case ErrorReportingSystemCategoryTypeForInputUnits_KEY_UNITS:
+ return "KEY_UNITS"
+ case ErrorReportingSystemCategoryTypeForInputUnits_TELECOMMAND_AND_REMOTE_ENTRY:
+ return "TELECOMMAND_AND_REMOTE_ENTRY"
+ case ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_2:
+ return "RESERVED_2"
+ case ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_3:
+ return "RESERVED_3"
+ case ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_4:
+ return "RESERVED_4"
+ case ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_5:
+ return "RESERVED_5"
+ case ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_6:
+ return "RESERVED_6"
+ case ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_7:
+ return "RESERVED_7"
+ case ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_8:
+ return "RESERVED_8"
+ case ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_9:
+ return "RESERVED_9"
+ case ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_10:
+ return "RESERVED_10"
+ case ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_11:
+ return "RESERVED_11"
+ case ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_12:
+ return "RESERVED_12"
+ case ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_13:
+ return "RESERVED_13"
+ case ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_14:
+ return "RESERVED_14"
+ case ErrorReportingSystemCategoryTypeForInputUnits_RESERVED_15:
+ return "RESERVED_15"
+ }
+ return ""
+}
+
+func (e ErrorReportingSystemCategoryTypeForInputUnits) String() string {
+ return e.PLC4XEnumName()
+}
diff --git a/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeForOutputUnits.go b/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeForOutputUnits.go
new file mode 100644
index 000000000..49a655a65
--- /dev/null
+++ b/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeForOutputUnits.go
@@ -0,0 +1,241 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/spi/utils"
+ "github.com/pkg/errors"
+ "github.com/rs/zerolog/log"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// ErrorReportingSystemCategoryTypeForOutputUnits is an enum
+type ErrorReportingSystemCategoryTypeForOutputUnits uint8
+
+type IErrorReportingSystemCategoryTypeForOutputUnits interface {
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+const (
+ ErrorReportingSystemCategoryTypeForOutputUnits_LE_MONOBLOCK_DIMMERS ErrorReportingSystemCategoryTypeForOutputUnits = 0x0
+ ErrorReportingSystemCategoryTypeForOutputUnits_TE_MONOBLOCK_DIMMERS ErrorReportingSystemCategoryTypeForOutputUnits = 0x1
+ ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_2 ErrorReportingSystemCategoryTypeForOutputUnits = 0x2
+ ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_3 ErrorReportingSystemCategoryTypeForOutputUnits = 0x3
+ ErrorReportingSystemCategoryTypeForOutputUnits_RELAYS_AND_OTHER_ON_OFF_SWITCHING_DEVICES ErrorReportingSystemCategoryTypeForOutputUnits = 0x4
+ ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_5 ErrorReportingSystemCategoryTypeForOutputUnits = 0x5
+ ErrorReportingSystemCategoryTypeForOutputUnits_PWM_DIMMERS_INCLUDES_LED_CONTROL ErrorReportingSystemCategoryTypeForOutputUnits = 0x6
+ ErrorReportingSystemCategoryTypeForOutputUnits_SINEWAVE_MONOBLOCK_DIMMERS ErrorReportingSystemCategoryTypeForOutputUnits = 0x7
+ ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_8 ErrorReportingSystemCategoryTypeForOutputUnits = 0x8
+ ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_9 ErrorReportingSystemCategoryTypeForOutputUnits = 0x9
+ ErrorReportingSystemCategoryTypeForOutputUnits_DALI_DSI_AND_OTHER_BALLAST_CONTROL_GATEWAYS ErrorReportingSystemCategoryTypeForOutputUnits = 0xA
+ ErrorReportingSystemCategoryTypeForOutputUnits_MODULAR_DIMMERS ErrorReportingSystemCategoryTypeForOutputUnits = 0xB
+ ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_12 ErrorReportingSystemCategoryTypeForOutputUnits = 0xC
+ ErrorReportingSystemCategoryTypeForOutputUnits_UNIVERSAL_MONOBLOCK_DIMMERS ErrorReportingSystemCategoryTypeForOutputUnits = 0xD
+ ErrorReportingSystemCategoryTypeForOutputUnits_DEVICE_CONTROLLERS_IR_RS_232_etc ErrorReportingSystemCategoryTypeForOutputUnits = 0xE
+ ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_15 ErrorReportingSystemCategoryTypeForOutputUnits = 0xF
+)
+
+var ErrorReportingSystemCategoryTypeForOutputUnitsValues []ErrorReportingSystemCategoryTypeForOutputUnits
+
+func init() {
+ _ = errors.New
+ ErrorReportingSystemCategoryTypeForOutputUnitsValues = []ErrorReportingSystemCategoryTypeForOutputUnits{
+ ErrorReportingSystemCategoryTypeForOutputUnits_LE_MONOBLOCK_DIMMERS,
+ ErrorReportingSystemCategoryTypeForOutputUnits_TE_MONOBLOCK_DIMMERS,
+ ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_2,
+ ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_3,
+ ErrorReportingSystemCategoryTypeForOutputUnits_RELAYS_AND_OTHER_ON_OFF_SWITCHING_DEVICES,
+ ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_5,
+ ErrorReportingSystemCategoryTypeForOutputUnits_PWM_DIMMERS_INCLUDES_LED_CONTROL,
+ ErrorReportingSystemCategoryTypeForOutputUnits_SINEWAVE_MONOBLOCK_DIMMERS,
+ ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_8,
+ ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_9,
+ ErrorReportingSystemCategoryTypeForOutputUnits_DALI_DSI_AND_OTHER_BALLAST_CONTROL_GATEWAYS,
+ ErrorReportingSystemCategoryTypeForOutputUnits_MODULAR_DIMMERS,
+ ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_12,
+ ErrorReportingSystemCategoryTypeForOutputUnits_UNIVERSAL_MONOBLOCK_DIMMERS,
+ ErrorReportingSystemCategoryTypeForOutputUnits_DEVICE_CONTROLLERS_IR_RS_232_etc,
+ ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_15,
+ }
+}
+
+func ErrorReportingSystemCategoryTypeForOutputUnitsByValue(value uint8) (enum ErrorReportingSystemCategoryTypeForOutputUnits, ok bool) {
+ switch value {
+ case 0x0:
+ return ErrorReportingSystemCategoryTypeForOutputUnits_LE_MONOBLOCK_DIMMERS, true
+ case 0x1:
+ return ErrorReportingSystemCategoryTypeForOutputUnits_TE_MONOBLOCK_DIMMERS, true
+ case 0x2:
+ return ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_2, true
+ case 0x3:
+ return ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_3, true
+ case 0x4:
+ return ErrorReportingSystemCategoryTypeForOutputUnits_RELAYS_AND_OTHER_ON_OFF_SWITCHING_DEVICES, true
+ case 0x5:
+ return ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_5, true
+ case 0x6:
+ return ErrorReportingSystemCategoryTypeForOutputUnits_PWM_DIMMERS_INCLUDES_LED_CONTROL, true
+ case 0x7:
+ return ErrorReportingSystemCategoryTypeForOutputUnits_SINEWAVE_MONOBLOCK_DIMMERS, true
+ case 0x8:
+ return ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_8, true
+ case 0x9:
+ return ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_9, true
+ case 0xA:
+ return ErrorReportingSystemCategoryTypeForOutputUnits_DALI_DSI_AND_OTHER_BALLAST_CONTROL_GATEWAYS, true
+ case 0xB:
+ return ErrorReportingSystemCategoryTypeForOutputUnits_MODULAR_DIMMERS, true
+ case 0xC:
+ return ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_12, true
+ case 0xD:
+ return ErrorReportingSystemCategoryTypeForOutputUnits_UNIVERSAL_MONOBLOCK_DIMMERS, true
+ case 0xE:
+ return ErrorReportingSystemCategoryTypeForOutputUnits_DEVICE_CONTROLLERS_IR_RS_232_etc, true
+ case 0xF:
+ return ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_15, true
+ }
+ return 0, false
+}
+
+func ErrorReportingSystemCategoryTypeForOutputUnitsByName(value string) (enum ErrorReportingSystemCategoryTypeForOutputUnits, ok bool) {
+ switch value {
+ case "LE_MONOBLOCK_DIMMERS":
+ return ErrorReportingSystemCategoryTypeForOutputUnits_LE_MONOBLOCK_DIMMERS, true
+ case "TE_MONOBLOCK_DIMMERS":
+ return ErrorReportingSystemCategoryTypeForOutputUnits_TE_MONOBLOCK_DIMMERS, true
+ case "RESERVED_2":
+ return ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_2, true
+ case "RESERVED_3":
+ return ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_3, true
+ case "RELAYS_AND_OTHER_ON_OFF_SWITCHING_DEVICES":
+ return ErrorReportingSystemCategoryTypeForOutputUnits_RELAYS_AND_OTHER_ON_OFF_SWITCHING_DEVICES, true
+ case "RESERVED_5":
+ return ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_5, true
+ case "PWM_DIMMERS_INCLUDES_LED_CONTROL":
+ return ErrorReportingSystemCategoryTypeForOutputUnits_PWM_DIMMERS_INCLUDES_LED_CONTROL, true
+ case "SINEWAVE_MONOBLOCK_DIMMERS":
+ return ErrorReportingSystemCategoryTypeForOutputUnits_SINEWAVE_MONOBLOCK_DIMMERS, true
+ case "RESERVED_8":
+ return ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_8, true
+ case "RESERVED_9":
+ return ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_9, true
+ case "DALI_DSI_AND_OTHER_BALLAST_CONTROL_GATEWAYS":
+ return ErrorReportingSystemCategoryTypeForOutputUnits_DALI_DSI_AND_OTHER_BALLAST_CONTROL_GATEWAYS, true
+ case "MODULAR_DIMMERS":
+ return ErrorReportingSystemCategoryTypeForOutputUnits_MODULAR_DIMMERS, true
+ case "RESERVED_12":
+ return ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_12, true
+ case "UNIVERSAL_MONOBLOCK_DIMMERS":
+ return ErrorReportingSystemCategoryTypeForOutputUnits_UNIVERSAL_MONOBLOCK_DIMMERS, true
+ case "DEVICE_CONTROLLERS_IR_RS_232_etc":
+ return ErrorReportingSystemCategoryTypeForOutputUnits_DEVICE_CONTROLLERS_IR_RS_232_etc, true
+ case "RESERVED_15":
+ return ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_15, true
+ }
+ return 0, false
+}
+
+func ErrorReportingSystemCategoryTypeForOutputUnitsKnows(value uint8) bool {
+ for _, typeValue := range ErrorReportingSystemCategoryTypeForOutputUnitsValues {
+ if uint8(typeValue) == value {
+ return true
+ }
+ }
+ return false
+}
+
+func CastErrorReportingSystemCategoryTypeForOutputUnits(structType interface{}) ErrorReportingSystemCategoryTypeForOutputUnits {
+ castFunc := func(typ interface{}) ErrorReportingSystemCategoryTypeForOutputUnits {
+ if sErrorReportingSystemCategoryTypeForOutputUnits, ok := typ.(ErrorReportingSystemCategoryTypeForOutputUnits); ok {
+ return sErrorReportingSystemCategoryTypeForOutputUnits
+ }
+ return 0
+ }
+ return castFunc(structType)
+}
+
+func (m ErrorReportingSystemCategoryTypeForOutputUnits) GetLengthInBits() uint16 {
+ return 4
+}
+
+func (m ErrorReportingSystemCategoryTypeForOutputUnits) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func ErrorReportingSystemCategoryTypeForOutputUnitsParse(readBuffer utils.ReadBuffer) (ErrorReportingSystemCategoryTypeForOutputUnits, error) {
+ val, err := readBuffer.ReadUint8("ErrorReportingSystemCategoryTypeForOutputUnits", 4)
+ if err != nil {
+ return 0, errors.Wrap(err, "error reading ErrorReportingSystemCategoryTypeForOutputUnits")
+ }
+ if enum, ok := ErrorReportingSystemCategoryTypeForOutputUnitsByValue(val); !ok {
+ log.Debug().Msgf("no value %x found for RequestType", val)
+ return ErrorReportingSystemCategoryTypeForOutputUnits(val), nil
+ } else {
+ return enum, nil
+ }
+}
+
+func (e ErrorReportingSystemCategoryTypeForOutputUnits) Serialize(writeBuffer utils.WriteBuffer) error {
+ return writeBuffer.WriteUint8("ErrorReportingSystemCategoryTypeForOutputUnits", 4, uint8(e), utils.WithAdditionalStringRepresentation(e.PLC4XEnumName()))
+}
+
+// PLC4XEnumName returns the name that is used in code to identify this enum
+func (e ErrorReportingSystemCategoryTypeForOutputUnits) PLC4XEnumName() string {
+ switch e {
+ case ErrorReportingSystemCategoryTypeForOutputUnits_LE_MONOBLOCK_DIMMERS:
+ return "LE_MONOBLOCK_DIMMERS"
+ case ErrorReportingSystemCategoryTypeForOutputUnits_TE_MONOBLOCK_DIMMERS:
+ return "TE_MONOBLOCK_DIMMERS"
+ case ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_2:
+ return "RESERVED_2"
+ case ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_3:
+ return "RESERVED_3"
+ case ErrorReportingSystemCategoryTypeForOutputUnits_RELAYS_AND_OTHER_ON_OFF_SWITCHING_DEVICES:
+ return "RELAYS_AND_OTHER_ON_OFF_SWITCHING_DEVICES"
+ case ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_5:
+ return "RESERVED_5"
+ case ErrorReportingSystemCategoryTypeForOutputUnits_PWM_DIMMERS_INCLUDES_LED_CONTROL:
+ return "PWM_DIMMERS_INCLUDES_LED_CONTROL"
+ case ErrorReportingSystemCategoryTypeForOutputUnits_SINEWAVE_MONOBLOCK_DIMMERS:
+ return "SINEWAVE_MONOBLOCK_DIMMERS"
+ case ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_8:
+ return "RESERVED_8"
+ case ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_9:
+ return "RESERVED_9"
+ case ErrorReportingSystemCategoryTypeForOutputUnits_DALI_DSI_AND_OTHER_BALLAST_CONTROL_GATEWAYS:
+ return "DALI_DSI_AND_OTHER_BALLAST_CONTROL_GATEWAYS"
+ case ErrorReportingSystemCategoryTypeForOutputUnits_MODULAR_DIMMERS:
+ return "MODULAR_DIMMERS"
+ case ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_12:
+ return "RESERVED_12"
+ case ErrorReportingSystemCategoryTypeForOutputUnits_UNIVERSAL_MONOBLOCK_DIMMERS:
+ return "UNIVERSAL_MONOBLOCK_DIMMERS"
+ case ErrorReportingSystemCategoryTypeForOutputUnits_DEVICE_CONTROLLERS_IR_RS_232_etc:
+ return "DEVICE_CONTROLLERS_IR_RS_232_etc"
+ case ErrorReportingSystemCategoryTypeForOutputUnits_RESERVED_15:
+ return "RESERVED_15"
+ }
+ return ""
+}
+
+func (e ErrorReportingSystemCategoryTypeForOutputUnits) String() string {
+ return e.PLC4XEnumName()
+}
diff --git a/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeForSupportUnits.go b/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeForSupportUnits.go
new file mode 100644
index 000000000..be7e768b0
--- /dev/null
+++ b/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeForSupportUnits.go
@@ -0,0 +1,241 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/spi/utils"
+ "github.com/pkg/errors"
+ "github.com/rs/zerolog/log"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// ErrorReportingSystemCategoryTypeForSupportUnits is an enum
+type ErrorReportingSystemCategoryTypeForSupportUnits uint8
+
+type IErrorReportingSystemCategoryTypeForSupportUnits interface {
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+const (
+ ErrorReportingSystemCategoryTypeForSupportUnits_POWER_SUPPLIES ErrorReportingSystemCategoryTypeForSupportUnits = 0x0
+ ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_1 ErrorReportingSystemCategoryTypeForSupportUnits = 0x1
+ ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_2 ErrorReportingSystemCategoryTypeForSupportUnits = 0x2
+ ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_3 ErrorReportingSystemCategoryTypeForSupportUnits = 0x3
+ ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_4 ErrorReportingSystemCategoryTypeForSupportUnits = 0x4
+ ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_5 ErrorReportingSystemCategoryTypeForSupportUnits = 0x5
+ ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_6 ErrorReportingSystemCategoryTypeForSupportUnits = 0x6
+ ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_7 ErrorReportingSystemCategoryTypeForSupportUnits = 0x7
+ ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_8 ErrorReportingSystemCategoryTypeForSupportUnits = 0x8
+ ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_9 ErrorReportingSystemCategoryTypeForSupportUnits = 0x9
+ ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_10 ErrorReportingSystemCategoryTypeForSupportUnits = 0xA
+ ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_11 ErrorReportingSystemCategoryTypeForSupportUnits = 0xB
+ ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_12 ErrorReportingSystemCategoryTypeForSupportUnits = 0xC
+ ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_13 ErrorReportingSystemCategoryTypeForSupportUnits = 0xD
+ ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_14 ErrorReportingSystemCategoryTypeForSupportUnits = 0xE
+ ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_15 ErrorReportingSystemCategoryTypeForSupportUnits = 0xF
+)
+
+var ErrorReportingSystemCategoryTypeForSupportUnitsValues []ErrorReportingSystemCategoryTypeForSupportUnits
+
+func init() {
+ _ = errors.New
+ ErrorReportingSystemCategoryTypeForSupportUnitsValues = []ErrorReportingSystemCategoryTypeForSupportUnits{
+ ErrorReportingSystemCategoryTypeForSupportUnits_POWER_SUPPLIES,
+ ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_1,
+ ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_2,
+ ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_3,
+ ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_4,
+ ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_5,
+ ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_6,
+ ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_7,
+ ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_8,
+ ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_9,
+ ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_10,
+ ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_11,
+ ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_12,
+ ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_13,
+ ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_14,
+ ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_15,
+ }
+}
+
+func ErrorReportingSystemCategoryTypeForSupportUnitsByValue(value uint8) (enum ErrorReportingSystemCategoryTypeForSupportUnits, ok bool) {
+ switch value {
+ case 0x0:
+ return ErrorReportingSystemCategoryTypeForSupportUnits_POWER_SUPPLIES, true
+ case 0x1:
+ return ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_1, true
+ case 0x2:
+ return ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_2, true
+ case 0x3:
+ return ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_3, true
+ case 0x4:
+ return ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_4, true
+ case 0x5:
+ return ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_5, true
+ case 0x6:
+ return ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_6, true
+ case 0x7:
+ return ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_7, true
+ case 0x8:
+ return ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_8, true
+ case 0x9:
+ return ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_9, true
+ case 0xA:
+ return ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_10, true
+ case 0xB:
+ return ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_11, true
+ case 0xC:
+ return ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_12, true
+ case 0xD:
+ return ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_13, true
+ case 0xE:
+ return ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_14, true
+ case 0xF:
+ return ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_15, true
+ }
+ return 0, false
+}
+
+func ErrorReportingSystemCategoryTypeForSupportUnitsByName(value string) (enum ErrorReportingSystemCategoryTypeForSupportUnits, ok bool) {
+ switch value {
+ case "POWER_SUPPLIES":
+ return ErrorReportingSystemCategoryTypeForSupportUnits_POWER_SUPPLIES, true
+ case "RESERVED_1":
+ return ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_1, true
+ case "RESERVED_2":
+ return ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_2, true
+ case "RESERVED_3":
+ return ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_3, true
+ case "RESERVED_4":
+ return ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_4, true
+ case "RESERVED_5":
+ return ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_5, true
+ case "RESERVED_6":
+ return ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_6, true
+ case "RESERVED_7":
+ return ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_7, true
+ case "RESERVED_8":
+ return ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_8, true
+ case "RESERVED_9":
+ return ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_9, true
+ case "RESERVED_10":
+ return ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_10, true
+ case "RESERVED_11":
+ return ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_11, true
+ case "RESERVED_12":
+ return ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_12, true
+ case "RESERVED_13":
+ return ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_13, true
+ case "RESERVED_14":
+ return ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_14, true
+ case "RESERVED_15":
+ return ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_15, true
+ }
+ return 0, false
+}
+
+func ErrorReportingSystemCategoryTypeForSupportUnitsKnows(value uint8) bool {
+ for _, typeValue := range ErrorReportingSystemCategoryTypeForSupportUnitsValues {
+ if uint8(typeValue) == value {
+ return true
+ }
+ }
+ return false
+}
+
+func CastErrorReportingSystemCategoryTypeForSupportUnits(structType interface{}) ErrorReportingSystemCategoryTypeForSupportUnits {
+ castFunc := func(typ interface{}) ErrorReportingSystemCategoryTypeForSupportUnits {
+ if sErrorReportingSystemCategoryTypeForSupportUnits, ok := typ.(ErrorReportingSystemCategoryTypeForSupportUnits); ok {
+ return sErrorReportingSystemCategoryTypeForSupportUnits
+ }
+ return 0
+ }
+ return castFunc(structType)
+}
+
+func (m ErrorReportingSystemCategoryTypeForSupportUnits) GetLengthInBits() uint16 {
+ return 4
+}
+
+func (m ErrorReportingSystemCategoryTypeForSupportUnits) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func ErrorReportingSystemCategoryTypeForSupportUnitsParse(readBuffer utils.ReadBuffer) (ErrorReportingSystemCategoryTypeForSupportUnits, error) {
+ val, err := readBuffer.ReadUint8("ErrorReportingSystemCategoryTypeForSupportUnits", 4)
+ if err != nil {
+ return 0, errors.Wrap(err, "error reading ErrorReportingSystemCategoryTypeForSupportUnits")
+ }
+ if enum, ok := ErrorReportingSystemCategoryTypeForSupportUnitsByValue(val); !ok {
+ log.Debug().Msgf("no value %x found for RequestType", val)
+ return ErrorReportingSystemCategoryTypeForSupportUnits(val), nil
+ } else {
+ return enum, nil
+ }
+}
+
+func (e ErrorReportingSystemCategoryTypeForSupportUnits) Serialize(writeBuffer utils.WriteBuffer) error {
+ return writeBuffer.WriteUint8("ErrorReportingSystemCategoryTypeForSupportUnits", 4, uint8(e), utils.WithAdditionalStringRepresentation(e.PLC4XEnumName()))
+}
+
+// PLC4XEnumName returns the name that is used in code to identify this enum
+func (e ErrorReportingSystemCategoryTypeForSupportUnits) PLC4XEnumName() string {
+ switch e {
+ case ErrorReportingSystemCategoryTypeForSupportUnits_POWER_SUPPLIES:
+ return "POWER_SUPPLIES"
+ case ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_1:
+ return "RESERVED_1"
+ case ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_2:
+ return "RESERVED_2"
+ case ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_3:
+ return "RESERVED_3"
+ case ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_4:
+ return "RESERVED_4"
+ case ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_5:
+ return "RESERVED_5"
+ case ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_6:
+ return "RESERVED_6"
+ case ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_7:
+ return "RESERVED_7"
+ case ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_8:
+ return "RESERVED_8"
+ case ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_9:
+ return "RESERVED_9"
+ case ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_10:
+ return "RESERVED_10"
+ case ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_11:
+ return "RESERVED_11"
+ case ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_12:
+ return "RESERVED_12"
+ case ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_13:
+ return "RESERVED_13"
+ case ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_14:
+ return "RESERVED_14"
+ case ErrorReportingSystemCategoryTypeForSupportUnits_RESERVED_15:
+ return "RESERVED_15"
+ }
+ return ""
+}
+
+func (e ErrorReportingSystemCategoryTypeForSupportUnits) String() string {
+ return e.PLC4XEnumName()
+}
diff --git a/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeInputUnits.go b/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeInputUnits.go
new file mode 100644
index 000000000..b0138b165
--- /dev/null
+++ b/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeInputUnits.go
@@ -0,0 +1,204 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/spi/utils"
+ "github.com/pkg/errors"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// ErrorReportingSystemCategoryTypeInputUnits is the corresponding interface of ErrorReportingSystemCategoryTypeInputUnits
+type ErrorReportingSystemCategoryTypeInputUnits interface {
+ utils.LengthAware
+ utils.Serializable
+ ErrorReportingSystemCategoryType
+ // GetCategoryForType returns CategoryForType (property field)
+ GetCategoryForType() ErrorReportingSystemCategoryTypeForInputUnits
+}
+
+// ErrorReportingSystemCategoryTypeInputUnitsExactly can be used when we want exactly this type and not a type which fulfills ErrorReportingSystemCategoryTypeInputUnits.
+// This is useful for switch cases.
+type ErrorReportingSystemCategoryTypeInputUnitsExactly interface {
+ ErrorReportingSystemCategoryTypeInputUnits
+ isErrorReportingSystemCategoryTypeInputUnits() bool
+}
+
+// _ErrorReportingSystemCategoryTypeInputUnits is the data-structure of this message
+type _ErrorReportingSystemCategoryTypeInputUnits struct {
+ *_ErrorReportingSystemCategoryType
+ CategoryForType ErrorReportingSystemCategoryTypeForInputUnits
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for discriminator values.
+///////////////////////
+
+func (m *_ErrorReportingSystemCategoryTypeInputUnits) GetErrorReportingSystemCategoryClass() ErrorReportingSystemCategoryClass {
+ return ErrorReportingSystemCategoryClass_INPUT_UNITS
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+func (m *_ErrorReportingSystemCategoryTypeInputUnits) InitializeParent(parent ErrorReportingSystemCategoryType) {
+}
+
+func (m *_ErrorReportingSystemCategoryTypeInputUnits) GetParent() ErrorReportingSystemCategoryType {
+ return m._ErrorReportingSystemCategoryType
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *_ErrorReportingSystemCategoryTypeInputUnits) GetCategoryForType() ErrorReportingSystemCategoryTypeForInputUnits {
+ return m.CategoryForType
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewErrorReportingSystemCategoryTypeInputUnits factory function for _ErrorReportingSystemCategoryTypeInputUnits
+func NewErrorReportingSystemCategoryTypeInputUnits(categoryForType ErrorReportingSystemCategoryTypeForInputUnits) *_ErrorReportingSystemCategoryTypeInputUnits {
+ _result := &_ErrorReportingSystemCategoryTypeInputUnits{
+ CategoryForType: categoryForType,
+ _ErrorReportingSystemCategoryType: NewErrorReportingSystemCategoryType(),
+ }
+ _result._ErrorReportingSystemCategoryType._ErrorReportingSystemCategoryTypeChildRequirements = _result
+ return _result
+}
+
+// Deprecated: use the interface for direct cast
+func CastErrorReportingSystemCategoryTypeInputUnits(structType interface{}) ErrorReportingSystemCategoryTypeInputUnits {
+ if casted, ok := structType.(ErrorReportingSystemCategoryTypeInputUnits); ok {
+ return casted
+ }
+ if casted, ok := structType.(*ErrorReportingSystemCategoryTypeInputUnits); ok {
+ return *casted
+ }
+ return nil
+}
+
+func (m *_ErrorReportingSystemCategoryTypeInputUnits) GetTypeName() string {
+ return "ErrorReportingSystemCategoryTypeInputUnits"
+}
+
+func (m *_ErrorReportingSystemCategoryTypeInputUnits) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *_ErrorReportingSystemCategoryTypeInputUnits) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (categoryForType)
+ lengthInBits += 4
+
+ return lengthInBits
+}
+
+func (m *_ErrorReportingSystemCategoryTypeInputUnits) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func ErrorReportingSystemCategoryTypeInputUnitsParse(readBuffer utils.ReadBuffer, errorReportingSystemCategoryClass ErrorReportingSystemCategoryClass) (ErrorReportingSystemCategoryTypeInputUnits, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("ErrorReportingSystemCategoryTypeInputUnits"); pullErr != nil {
+ return nil, errors.Wrap(pullErr, "Error pulling for ErrorReportingSystemCategoryTypeInputUnits")
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (categoryForType)
+ if pullErr := readBuffer.PullContext("categoryForType"); pullErr != nil {
+ return nil, errors.Wrap(pullErr, "Error pulling for categoryForType")
+ }
+ _categoryForType, _categoryForTypeErr := ErrorReportingSystemCategoryTypeForInputUnitsParse(readBuffer)
+ if _categoryForTypeErr != nil {
+ return nil, errors.Wrap(_categoryForTypeErr, "Error parsing 'categoryForType' field of ErrorReportingSystemCategoryTypeInputUnits")
+ }
+ categoryForType := _categoryForType
+ if closeErr := readBuffer.CloseContext("categoryForType"); closeErr != nil {
+ return nil, errors.Wrap(closeErr, "Error closing for categoryForType")
+ }
+
+ if closeErr := readBuffer.CloseContext("ErrorReportingSystemCategoryTypeInputUnits"); closeErr != nil {
+ return nil, errors.Wrap(closeErr, "Error closing for ErrorReportingSystemCategoryTypeInputUnits")
+ }
+
+ // Create a partially initialized instance
+ _child := &_ErrorReportingSystemCategoryTypeInputUnits{
+ CategoryForType: categoryForType,
+ _ErrorReportingSystemCategoryType: &_ErrorReportingSystemCategoryType{},
+ }
+ _child._ErrorReportingSystemCategoryType._ErrorReportingSystemCategoryTypeChildRequirements = _child
+ return _child, nil
+}
+
+func (m *_ErrorReportingSystemCategoryTypeInputUnits) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("ErrorReportingSystemCategoryTypeInputUnits"); pushErr != nil {
+ return errors.Wrap(pushErr, "Error pushing for ErrorReportingSystemCategoryTypeInputUnits")
+ }
+
+ // Simple Field (categoryForType)
+ if pushErr := writeBuffer.PushContext("categoryForType"); pushErr != nil {
+ return errors.Wrap(pushErr, "Error pushing for categoryForType")
+ }
+ _categoryForTypeErr := writeBuffer.WriteSerializable(m.GetCategoryForType())
+ if popErr := writeBuffer.PopContext("categoryForType"); popErr != nil {
+ return errors.Wrap(popErr, "Error popping for categoryForType")
+ }
+ if _categoryForTypeErr != nil {
+ return errors.Wrap(_categoryForTypeErr, "Error serializing 'categoryForType' field")
+ }
+
+ if popErr := writeBuffer.PopContext("ErrorReportingSystemCategoryTypeInputUnits"); popErr != nil {
+ return errors.Wrap(popErr, "Error popping for ErrorReportingSystemCategoryTypeInputUnits")
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *_ErrorReportingSystemCategoryTypeInputUnits) isErrorReportingSystemCategoryTypeInputUnits() bool {
+ return true
+}
+
+func (m *_ErrorReportingSystemCategoryTypeInputUnits) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ writeBuffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ if err := writeBuffer.WriteSerializable(m); err != nil {
+ return err.Error()
+ }
+ return writeBuffer.GetBox().String()
+}
diff --git a/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeOutputUnits.go b/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeOutputUnits.go
new file mode 100644
index 000000000..3a9b8b81e
--- /dev/null
+++ b/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeOutputUnits.go
@@ -0,0 +1,204 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/spi/utils"
+ "github.com/pkg/errors"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// ErrorReportingSystemCategoryTypeOutputUnits is the corresponding interface of ErrorReportingSystemCategoryTypeOutputUnits
+type ErrorReportingSystemCategoryTypeOutputUnits interface {
+ utils.LengthAware
+ utils.Serializable
+ ErrorReportingSystemCategoryType
+ // GetCategoryForType returns CategoryForType (property field)
+ GetCategoryForType() ErrorReportingSystemCategoryTypeForOutputUnits
+}
+
+// ErrorReportingSystemCategoryTypeOutputUnitsExactly can be used when we want exactly this type and not a type which fulfills ErrorReportingSystemCategoryTypeOutputUnits.
+// This is useful for switch cases.
+type ErrorReportingSystemCategoryTypeOutputUnitsExactly interface {
+ ErrorReportingSystemCategoryTypeOutputUnits
+ isErrorReportingSystemCategoryTypeOutputUnits() bool
+}
+
+// _ErrorReportingSystemCategoryTypeOutputUnits is the data-structure of this message
+type _ErrorReportingSystemCategoryTypeOutputUnits struct {
+ *_ErrorReportingSystemCategoryType
+ CategoryForType ErrorReportingSystemCategoryTypeForOutputUnits
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for discriminator values.
+///////////////////////
+
+func (m *_ErrorReportingSystemCategoryTypeOutputUnits) GetErrorReportingSystemCategoryClass() ErrorReportingSystemCategoryClass {
+ return ErrorReportingSystemCategoryClass_OUTPUT_UNITS
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+func (m *_ErrorReportingSystemCategoryTypeOutputUnits) InitializeParent(parent ErrorReportingSystemCategoryType) {
+}
+
+func (m *_ErrorReportingSystemCategoryTypeOutputUnits) GetParent() ErrorReportingSystemCategoryType {
+ return m._ErrorReportingSystemCategoryType
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *_ErrorReportingSystemCategoryTypeOutputUnits) GetCategoryForType() ErrorReportingSystemCategoryTypeForOutputUnits {
+ return m.CategoryForType
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewErrorReportingSystemCategoryTypeOutputUnits factory function for _ErrorReportingSystemCategoryTypeOutputUnits
+func NewErrorReportingSystemCategoryTypeOutputUnits(categoryForType ErrorReportingSystemCategoryTypeForOutputUnits) *_ErrorReportingSystemCategoryTypeOutputUnits {
+ _result := &_ErrorReportingSystemCategoryTypeOutputUnits{
+ CategoryForType: categoryForType,
+ _ErrorReportingSystemCategoryType: NewErrorReportingSystemCategoryType(),
+ }
+ _result._ErrorReportingSystemCategoryType._ErrorReportingSystemCategoryTypeChildRequirements = _result
+ return _result
+}
+
+// Deprecated: use the interface for direct cast
+func CastErrorReportingSystemCategoryTypeOutputUnits(structType interface{}) ErrorReportingSystemCategoryTypeOutputUnits {
+ if casted, ok := structType.(ErrorReportingSystemCategoryTypeOutputUnits); ok {
+ return casted
+ }
+ if casted, ok := structType.(*ErrorReportingSystemCategoryTypeOutputUnits); ok {
+ return *casted
+ }
+ return nil
+}
+
+func (m *_ErrorReportingSystemCategoryTypeOutputUnits) GetTypeName() string {
+ return "ErrorReportingSystemCategoryTypeOutputUnits"
+}
+
+func (m *_ErrorReportingSystemCategoryTypeOutputUnits) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *_ErrorReportingSystemCategoryTypeOutputUnits) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (categoryForType)
+ lengthInBits += 4
+
+ return lengthInBits
+}
+
+func (m *_ErrorReportingSystemCategoryTypeOutputUnits) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func ErrorReportingSystemCategoryTypeOutputUnitsParse(readBuffer utils.ReadBuffer, errorReportingSystemCategoryClass ErrorReportingSystemCategoryClass) (ErrorReportingSystemCategoryTypeOutputUnits, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("ErrorReportingSystemCategoryTypeOutputUnits"); pullErr != nil {
+ return nil, errors.Wrap(pullErr, "Error pulling for ErrorReportingSystemCategoryTypeOutputUnits")
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (categoryForType)
+ if pullErr := readBuffer.PullContext("categoryForType"); pullErr != nil {
+ return nil, errors.Wrap(pullErr, "Error pulling for categoryForType")
+ }
+ _categoryForType, _categoryForTypeErr := ErrorReportingSystemCategoryTypeForOutputUnitsParse(readBuffer)
+ if _categoryForTypeErr != nil {
+ return nil, errors.Wrap(_categoryForTypeErr, "Error parsing 'categoryForType' field of ErrorReportingSystemCategoryTypeOutputUnits")
+ }
+ categoryForType := _categoryForType
+ if closeErr := readBuffer.CloseContext("categoryForType"); closeErr != nil {
+ return nil, errors.Wrap(closeErr, "Error closing for categoryForType")
+ }
+
+ if closeErr := readBuffer.CloseContext("ErrorReportingSystemCategoryTypeOutputUnits"); closeErr != nil {
+ return nil, errors.Wrap(closeErr, "Error closing for ErrorReportingSystemCategoryTypeOutputUnits")
+ }
+
+ // Create a partially initialized instance
+ _child := &_ErrorReportingSystemCategoryTypeOutputUnits{
+ CategoryForType: categoryForType,
+ _ErrorReportingSystemCategoryType: &_ErrorReportingSystemCategoryType{},
+ }
+ _child._ErrorReportingSystemCategoryType._ErrorReportingSystemCategoryTypeChildRequirements = _child
+ return _child, nil
+}
+
+func (m *_ErrorReportingSystemCategoryTypeOutputUnits) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("ErrorReportingSystemCategoryTypeOutputUnits"); pushErr != nil {
+ return errors.Wrap(pushErr, "Error pushing for ErrorReportingSystemCategoryTypeOutputUnits")
+ }
+
+ // Simple Field (categoryForType)
+ if pushErr := writeBuffer.PushContext("categoryForType"); pushErr != nil {
+ return errors.Wrap(pushErr, "Error pushing for categoryForType")
+ }
+ _categoryForTypeErr := writeBuffer.WriteSerializable(m.GetCategoryForType())
+ if popErr := writeBuffer.PopContext("categoryForType"); popErr != nil {
+ return errors.Wrap(popErr, "Error popping for categoryForType")
+ }
+ if _categoryForTypeErr != nil {
+ return errors.Wrap(_categoryForTypeErr, "Error serializing 'categoryForType' field")
+ }
+
+ if popErr := writeBuffer.PopContext("ErrorReportingSystemCategoryTypeOutputUnits"); popErr != nil {
+ return errors.Wrap(popErr, "Error popping for ErrorReportingSystemCategoryTypeOutputUnits")
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *_ErrorReportingSystemCategoryTypeOutputUnits) isErrorReportingSystemCategoryTypeOutputUnits() bool {
+ return true
+}
+
+func (m *_ErrorReportingSystemCategoryTypeOutputUnits) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ writeBuffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ if err := writeBuffer.WriteSerializable(m); err != nil {
+ return err.Error()
+ }
+ return writeBuffer.GetBox().String()
+}
diff --git a/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeReserved.go b/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeReserved.go
new file mode 100644
index 000000000..5589a313a
--- /dev/null
+++ b/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeReserved.go
@@ -0,0 +1,193 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/spi/utils"
+ "github.com/pkg/errors"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// ErrorReportingSystemCategoryTypeReserved is the corresponding interface of ErrorReportingSystemCategoryTypeReserved
+type ErrorReportingSystemCategoryTypeReserved interface {
+ utils.LengthAware
+ utils.Serializable
+ ErrorReportingSystemCategoryType
+ // GetReservedValue returns ReservedValue (property field)
+ GetReservedValue() uint8
+}
+
+// ErrorReportingSystemCategoryTypeReservedExactly can be used when we want exactly this type and not a type which fulfills ErrorReportingSystemCategoryTypeReserved.
+// This is useful for switch cases.
+type ErrorReportingSystemCategoryTypeReservedExactly interface {
+ ErrorReportingSystemCategoryTypeReserved
+ isErrorReportingSystemCategoryTypeReserved() bool
+}
+
+// _ErrorReportingSystemCategoryTypeReserved is the data-structure of this message
+type _ErrorReportingSystemCategoryTypeReserved struct {
+ *_ErrorReportingSystemCategoryType
+ ReservedValue uint8
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for discriminator values.
+///////////////////////
+
+func (m *_ErrorReportingSystemCategoryTypeReserved) GetErrorReportingSystemCategoryClass() ErrorReportingSystemCategoryClass {
+ return 0
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+func (m *_ErrorReportingSystemCategoryTypeReserved) InitializeParent(parent ErrorReportingSystemCategoryType) {
+}
+
+func (m *_ErrorReportingSystemCategoryTypeReserved) GetParent() ErrorReportingSystemCategoryType {
+ return m._ErrorReportingSystemCategoryType
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *_ErrorReportingSystemCategoryTypeReserved) GetReservedValue() uint8 {
+ return m.ReservedValue
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewErrorReportingSystemCategoryTypeReserved factory function for _ErrorReportingSystemCategoryTypeReserved
+func NewErrorReportingSystemCategoryTypeReserved(reservedValue uint8) *_ErrorReportingSystemCategoryTypeReserved {
+ _result := &_ErrorReportingSystemCategoryTypeReserved{
+ ReservedValue: reservedValue,
+ _ErrorReportingSystemCategoryType: NewErrorReportingSystemCategoryType(),
+ }
+ _result._ErrorReportingSystemCategoryType._ErrorReportingSystemCategoryTypeChildRequirements = _result
+ return _result
+}
+
+// Deprecated: use the interface for direct cast
+func CastErrorReportingSystemCategoryTypeReserved(structType interface{}) ErrorReportingSystemCategoryTypeReserved {
+ if casted, ok := structType.(ErrorReportingSystemCategoryTypeReserved); ok {
+ return casted
+ }
+ if casted, ok := structType.(*ErrorReportingSystemCategoryTypeReserved); ok {
+ return *casted
+ }
+ return nil
+}
+
+func (m *_ErrorReportingSystemCategoryTypeReserved) GetTypeName() string {
+ return "ErrorReportingSystemCategoryTypeReserved"
+}
+
+func (m *_ErrorReportingSystemCategoryTypeReserved) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *_ErrorReportingSystemCategoryTypeReserved) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (reservedValue)
+ lengthInBits += 4
+
+ return lengthInBits
+}
+
+func (m *_ErrorReportingSystemCategoryTypeReserved) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func ErrorReportingSystemCategoryTypeReservedParse(readBuffer utils.ReadBuffer, errorReportingSystemCategoryClass ErrorReportingSystemCategoryClass) (ErrorReportingSystemCategoryTypeReserved, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("ErrorReportingSystemCategoryTypeReserved"); pullErr != nil {
+ return nil, errors.Wrap(pullErr, "Error pulling for ErrorReportingSystemCategoryTypeReserved")
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (reservedValue)
+ _reservedValue, _reservedValueErr := readBuffer.ReadUint8("reservedValue", 4)
+ if _reservedValueErr != nil {
+ return nil, errors.Wrap(_reservedValueErr, "Error parsing 'reservedValue' field of ErrorReportingSystemCategoryTypeReserved")
+ }
+ reservedValue := _reservedValue
+
+ if closeErr := readBuffer.CloseContext("ErrorReportingSystemCategoryTypeReserved"); closeErr != nil {
+ return nil, errors.Wrap(closeErr, "Error closing for ErrorReportingSystemCategoryTypeReserved")
+ }
+
+ // Create a partially initialized instance
+ _child := &_ErrorReportingSystemCategoryTypeReserved{
+ ReservedValue: reservedValue,
+ _ErrorReportingSystemCategoryType: &_ErrorReportingSystemCategoryType{},
+ }
+ _child._ErrorReportingSystemCategoryType._ErrorReportingSystemCategoryTypeChildRequirements = _child
+ return _child, nil
+}
+
+func (m *_ErrorReportingSystemCategoryTypeReserved) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("ErrorReportingSystemCategoryTypeReserved"); pushErr != nil {
+ return errors.Wrap(pushErr, "Error pushing for ErrorReportingSystemCategoryTypeReserved")
+ }
+
+ // Simple Field (reservedValue)
+ reservedValue := uint8(m.GetReservedValue())
+ _reservedValueErr := writeBuffer.WriteUint8("reservedValue", 4, (reservedValue))
+ if _reservedValueErr != nil {
+ return errors.Wrap(_reservedValueErr, "Error serializing 'reservedValue' field")
+ }
+
+ if popErr := writeBuffer.PopContext("ErrorReportingSystemCategoryTypeReserved"); popErr != nil {
+ return errors.Wrap(popErr, "Error popping for ErrorReportingSystemCategoryTypeReserved")
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *_ErrorReportingSystemCategoryTypeReserved) isErrorReportingSystemCategoryTypeReserved() bool {
+ return true
+}
+
+func (m *_ErrorReportingSystemCategoryTypeReserved) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ writeBuffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ if err := writeBuffer.WriteSerializable(m); err != nil {
+ return err.Error()
+ }
+ return writeBuffer.GetBox().String()
+}
diff --git a/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeSupportUnits.go b/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeSupportUnits.go
new file mode 100644
index 000000000..b30a3ff25
--- /dev/null
+++ b/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeSupportUnits.go
@@ -0,0 +1,204 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/spi/utils"
+ "github.com/pkg/errors"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// ErrorReportingSystemCategoryTypeSupportUnits is the corresponding interface of ErrorReportingSystemCategoryTypeSupportUnits
+type ErrorReportingSystemCategoryTypeSupportUnits interface {
+ utils.LengthAware
+ utils.Serializable
+ ErrorReportingSystemCategoryType
+ // GetCategoryForType returns CategoryForType (property field)
+ GetCategoryForType() ErrorReportingSystemCategoryTypeForSupportUnits
+}
+
+// ErrorReportingSystemCategoryTypeSupportUnitsExactly can be used when we want exactly this type and not a type which fulfills ErrorReportingSystemCategoryTypeSupportUnits.
+// This is useful for switch cases.
+type ErrorReportingSystemCategoryTypeSupportUnitsExactly interface {
+ ErrorReportingSystemCategoryTypeSupportUnits
+ isErrorReportingSystemCategoryTypeSupportUnits() bool
+}
+
+// _ErrorReportingSystemCategoryTypeSupportUnits is the data-structure of this message
+type _ErrorReportingSystemCategoryTypeSupportUnits struct {
+ *_ErrorReportingSystemCategoryType
+ CategoryForType ErrorReportingSystemCategoryTypeForSupportUnits
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for discriminator values.
+///////////////////////
+
+func (m *_ErrorReportingSystemCategoryTypeSupportUnits) GetErrorReportingSystemCategoryClass() ErrorReportingSystemCategoryClass {
+ return ErrorReportingSystemCategoryClass_SUPPORT_UNITS
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+func (m *_ErrorReportingSystemCategoryTypeSupportUnits) InitializeParent(parent ErrorReportingSystemCategoryType) {
+}
+
+func (m *_ErrorReportingSystemCategoryTypeSupportUnits) GetParent() ErrorReportingSystemCategoryType {
+ return m._ErrorReportingSystemCategoryType
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *_ErrorReportingSystemCategoryTypeSupportUnits) GetCategoryForType() ErrorReportingSystemCategoryTypeForSupportUnits {
+ return m.CategoryForType
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewErrorReportingSystemCategoryTypeSupportUnits factory function for _ErrorReportingSystemCategoryTypeSupportUnits
+func NewErrorReportingSystemCategoryTypeSupportUnits(categoryForType ErrorReportingSystemCategoryTypeForSupportUnits) *_ErrorReportingSystemCategoryTypeSupportUnits {
+ _result := &_ErrorReportingSystemCategoryTypeSupportUnits{
+ CategoryForType: categoryForType,
+ _ErrorReportingSystemCategoryType: NewErrorReportingSystemCategoryType(),
+ }
+ _result._ErrorReportingSystemCategoryType._ErrorReportingSystemCategoryTypeChildRequirements = _result
+ return _result
+}
+
+// Deprecated: use the interface for direct cast
+func CastErrorReportingSystemCategoryTypeSupportUnits(structType interface{}) ErrorReportingSystemCategoryTypeSupportUnits {
+ if casted, ok := structType.(ErrorReportingSystemCategoryTypeSupportUnits); ok {
+ return casted
+ }
+ if casted, ok := structType.(*ErrorReportingSystemCategoryTypeSupportUnits); ok {
+ return *casted
+ }
+ return nil
+}
+
+func (m *_ErrorReportingSystemCategoryTypeSupportUnits) GetTypeName() string {
+ return "ErrorReportingSystemCategoryTypeSupportUnits"
+}
+
+func (m *_ErrorReportingSystemCategoryTypeSupportUnits) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *_ErrorReportingSystemCategoryTypeSupportUnits) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (categoryForType)
+ lengthInBits += 4
+
+ return lengthInBits
+}
+
+func (m *_ErrorReportingSystemCategoryTypeSupportUnits) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func ErrorReportingSystemCategoryTypeSupportUnitsParse(readBuffer utils.ReadBuffer, errorReportingSystemCategoryClass ErrorReportingSystemCategoryClass) (ErrorReportingSystemCategoryTypeSupportUnits, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("ErrorReportingSystemCategoryTypeSupportUnits"); pullErr != nil {
+ return nil, errors.Wrap(pullErr, "Error pulling for ErrorReportingSystemCategoryTypeSupportUnits")
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (categoryForType)
+ if pullErr := readBuffer.PullContext("categoryForType"); pullErr != nil {
+ return nil, errors.Wrap(pullErr, "Error pulling for categoryForType")
+ }
+ _categoryForType, _categoryForTypeErr := ErrorReportingSystemCategoryTypeForSupportUnitsParse(readBuffer)
+ if _categoryForTypeErr != nil {
+ return nil, errors.Wrap(_categoryForTypeErr, "Error parsing 'categoryForType' field of ErrorReportingSystemCategoryTypeSupportUnits")
+ }
+ categoryForType := _categoryForType
+ if closeErr := readBuffer.CloseContext("categoryForType"); closeErr != nil {
+ return nil, errors.Wrap(closeErr, "Error closing for categoryForType")
+ }
+
+ if closeErr := readBuffer.CloseContext("ErrorReportingSystemCategoryTypeSupportUnits"); closeErr != nil {
+ return nil, errors.Wrap(closeErr, "Error closing for ErrorReportingSystemCategoryTypeSupportUnits")
+ }
+
+ // Create a partially initialized instance
+ _child := &_ErrorReportingSystemCategoryTypeSupportUnits{
+ CategoryForType: categoryForType,
+ _ErrorReportingSystemCategoryType: &_ErrorReportingSystemCategoryType{},
+ }
+ _child._ErrorReportingSystemCategoryType._ErrorReportingSystemCategoryTypeChildRequirements = _child
+ return _child, nil
+}
+
+func (m *_ErrorReportingSystemCategoryTypeSupportUnits) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("ErrorReportingSystemCategoryTypeSupportUnits"); pushErr != nil {
+ return errors.Wrap(pushErr, "Error pushing for ErrorReportingSystemCategoryTypeSupportUnits")
+ }
+
+ // Simple Field (categoryForType)
+ if pushErr := writeBuffer.PushContext("categoryForType"); pushErr != nil {
+ return errors.Wrap(pushErr, "Error pushing for categoryForType")
+ }
+ _categoryForTypeErr := writeBuffer.WriteSerializable(m.GetCategoryForType())
+ if popErr := writeBuffer.PopContext("categoryForType"); popErr != nil {
+ return errors.Wrap(popErr, "Error popping for categoryForType")
+ }
+ if _categoryForTypeErr != nil {
+ return errors.Wrap(_categoryForTypeErr, "Error serializing 'categoryForType' field")
+ }
+
+ if popErr := writeBuffer.PopContext("ErrorReportingSystemCategoryTypeSupportUnits"); popErr != nil {
+ return errors.Wrap(popErr, "Error popping for ErrorReportingSystemCategoryTypeSupportUnits")
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *_ErrorReportingSystemCategoryTypeSupportUnits) isErrorReportingSystemCategoryTypeSupportUnits() bool {
+ return true
+}
+
+func (m *_ErrorReportingSystemCategoryTypeSupportUnits) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ writeBuffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ if err := writeBuffer.WriteSerializable(m); err != nil {
+ return err.Error()
+ }
+ return writeBuffer.GetBox().String()
+}
diff --git a/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryVariant.go b/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryVariant.go
new file mode 100644
index 000000000..90bed6a10
--- /dev/null
+++ b/plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryVariant.go
@@ -0,0 +1,145 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/spi/utils"
+ "github.com/pkg/errors"
+ "github.com/rs/zerolog/log"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// ErrorReportingSystemCategoryVariant is an enum
+type ErrorReportingSystemCategoryVariant uint8
+
+type IErrorReportingSystemCategoryVariant interface {
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+const (
+ ErrorReportingSystemCategoryVariant_RESERVED_0 ErrorReportingSystemCategoryVariant = 0x0
+ ErrorReportingSystemCategoryVariant_RESERVED_1 ErrorReportingSystemCategoryVariant = 0x1
+ ErrorReportingSystemCategoryVariant_RESERVED_2 ErrorReportingSystemCategoryVariant = 0x2
+ ErrorReportingSystemCategoryVariant_RESERVED_3 ErrorReportingSystemCategoryVariant = 0x3
+)
+
+var ErrorReportingSystemCategoryVariantValues []ErrorReportingSystemCategoryVariant
+
+func init() {
+ _ = errors.New
+ ErrorReportingSystemCategoryVariantValues = []ErrorReportingSystemCategoryVariant{
+ ErrorReportingSystemCategoryVariant_RESERVED_0,
+ ErrorReportingSystemCategoryVariant_RESERVED_1,
+ ErrorReportingSystemCategoryVariant_RESERVED_2,
+ ErrorReportingSystemCategoryVariant_RESERVED_3,
+ }
+}
+
+func ErrorReportingSystemCategoryVariantByValue(value uint8) (enum ErrorReportingSystemCategoryVariant, ok bool) {
+ switch value {
+ case 0x0:
+ return ErrorReportingSystemCategoryVariant_RESERVED_0, true
+ case 0x1:
+ return ErrorReportingSystemCategoryVariant_RESERVED_1, true
+ case 0x2:
+ return ErrorReportingSystemCategoryVariant_RESERVED_2, true
+ case 0x3:
+ return ErrorReportingSystemCategoryVariant_RESERVED_3, true
+ }
+ return 0, false
+}
+
+func ErrorReportingSystemCategoryVariantByName(value string) (enum ErrorReportingSystemCategoryVariant, ok bool) {
+ switch value {
+ case "RESERVED_0":
+ return ErrorReportingSystemCategoryVariant_RESERVED_0, true
+ case "RESERVED_1":
+ return ErrorReportingSystemCategoryVariant_RESERVED_1, true
+ case "RESERVED_2":
+ return ErrorReportingSystemCategoryVariant_RESERVED_2, true
+ case "RESERVED_3":
+ return ErrorReportingSystemCategoryVariant_RESERVED_3, true
+ }
+ return 0, false
+}
+
+func ErrorReportingSystemCategoryVariantKnows(value uint8) bool {
+ for _, typeValue := range ErrorReportingSystemCategoryVariantValues {
+ if uint8(typeValue) == value {
+ return true
+ }
+ }
+ return false
+}
+
+func CastErrorReportingSystemCategoryVariant(structType interface{}) ErrorReportingSystemCategoryVariant {
+ castFunc := func(typ interface{}) ErrorReportingSystemCategoryVariant {
+ if sErrorReportingSystemCategoryVariant, ok := typ.(ErrorReportingSystemCategoryVariant); ok {
+ return sErrorReportingSystemCategoryVariant
+ }
+ return 0
+ }
+ return castFunc(structType)
+}
+
+func (m ErrorReportingSystemCategoryVariant) GetLengthInBits() uint16 {
+ return 2
+}
+
+func (m ErrorReportingSystemCategoryVariant) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func ErrorReportingSystemCategoryVariantParse(readBuffer utils.ReadBuffer) (ErrorReportingSystemCategoryVariant, error) {
+ val, err := readBuffer.ReadUint8("ErrorReportingSystemCategoryVariant", 2)
+ if err != nil {
+ return 0, errors.Wrap(err, "error reading ErrorReportingSystemCategoryVariant")
+ }
+ if enum, ok := ErrorReportingSystemCategoryVariantByValue(val); !ok {
+ log.Debug().Msgf("no value %x found for RequestType", val)
+ return ErrorReportingSystemCategoryVariant(val), nil
+ } else {
+ return enum, nil
+ }
+}
+
+func (e ErrorReportingSystemCategoryVariant) Serialize(writeBuffer utils.WriteBuffer) error {
+ return writeBuffer.WriteUint8("ErrorReportingSystemCategoryVariant", 2, uint8(e), utils.WithAdditionalStringRepresentation(e.PLC4XEnumName()))
+}
+
+// PLC4XEnumName returns the name that is used in code to identify this enum
+func (e ErrorReportingSystemCategoryVariant) PLC4XEnumName() string {
+ switch e {
+ case ErrorReportingSystemCategoryVariant_RESERVED_0:
+ return "RESERVED_0"
+ case ErrorReportingSystemCategoryVariant_RESERVED_1:
+ return "RESERVED_1"
+ case ErrorReportingSystemCategoryVariant_RESERVED_2:
+ return "RESERVED_2"
+ case ErrorReportingSystemCategoryVariant_RESERVED_3:
+ return "RESERVED_3"
+ }
+ return ""
+}
+
+func (e ErrorReportingSystemCategoryVariant) String() string {
+ return e.PLC4XEnumName()
+}
diff --git a/plc4go/protocols/cbus/readwrite/model/SALData.go b/plc4go/protocols/cbus/readwrite/model/SALData.go
index b135d269e..f0885d7bf 100644
--- a/plc4go/protocols/cbus/readwrite/model/SALData.go
+++ b/plc4go/protocols/cbus/readwrite/model/SALData.go
@@ -182,6 +182,8 @@ func SALDataParse(readBuffer utils.ReadBuffer, applicationId ApplicationId) (SAL
_childTemp, typeSwitchError = SALDataTestingParse(readBuffer, applicationId)
case applicationId == ApplicationId_MEDIA_TRANSPORT_CONTROL: // SALDataMediaTransport
_childTemp, typeSwitchError = SALDataMediaTransportParse(readBuffer, applicationId)
+ case applicationId == ApplicationId_ERROR_REPORTING: // SALDataErrorReporting
+ _childTemp, typeSwitchError = SALDataErrorReportingParse(readBuffer, applicationId)
default:
typeSwitchError = errors.Errorf("Unmapped type for parameters [applicationId=%v]", applicationId)
}
diff --git a/plc4go/protocols/cbus/readwrite/model/SALDataErrorReporting.go b/plc4go/protocols/cbus/readwrite/model/SALDataErrorReporting.go
new file mode 100644
index 000000000..feaf2e4d4
--- /dev/null
+++ b/plc4go/protocols/cbus/readwrite/model/SALDataErrorReporting.go
@@ -0,0 +1,205 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/spi/utils"
+ "github.com/pkg/errors"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// SALDataErrorReporting is the corresponding interface of SALDataErrorReporting
+type SALDataErrorReporting interface {
+ utils.LengthAware
+ utils.Serializable
+ SALData
+ // GetErrorReportingData returns ErrorReportingData (property field)
+ GetErrorReportingData() ErrorReportingData
+}
+
+// SALDataErrorReportingExactly can be used when we want exactly this type and not a type which fulfills SALDataErrorReporting.
+// This is useful for switch cases.
+type SALDataErrorReportingExactly interface {
+ SALDataErrorReporting
+ isSALDataErrorReporting() bool
+}
+
+// _SALDataErrorReporting is the data-structure of this message
+type _SALDataErrorReporting struct {
+ *_SALData
+ ErrorReportingData ErrorReportingData
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for discriminator values.
+///////////////////////
+
+func (m *_SALDataErrorReporting) GetApplicationId() ApplicationId {
+ return ApplicationId_ERROR_REPORTING
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+func (m *_SALDataErrorReporting) InitializeParent(parent SALData, salData SALData) {
+ m.SalData = salData
+}
+
+func (m *_SALDataErrorReporting) GetParent() SALData {
+ return m._SALData
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *_SALDataErrorReporting) GetErrorReportingData() ErrorReportingData {
+ return m.ErrorReportingData
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewSALDataErrorReporting factory function for _SALDataErrorReporting
+func NewSALDataErrorReporting(errorReportingData ErrorReportingData, salData SALData) *_SALDataErrorReporting {
+ _result := &_SALDataErrorReporting{
+ ErrorReportingData: errorReportingData,
+ _SALData: NewSALData(salData),
+ }
+ _result._SALData._SALDataChildRequirements = _result
+ return _result
+}
+
+// Deprecated: use the interface for direct cast
+func CastSALDataErrorReporting(structType interface{}) SALDataErrorReporting {
+ if casted, ok := structType.(SALDataErrorReporting); ok {
+ return casted
+ }
+ if casted, ok := structType.(*SALDataErrorReporting); ok {
+ return *casted
+ }
+ return nil
+}
+
+func (m *_SALDataErrorReporting) GetTypeName() string {
+ return "SALDataErrorReporting"
+}
+
+func (m *_SALDataErrorReporting) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *_SALDataErrorReporting) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (errorReportingData)
+ lengthInBits += m.ErrorReportingData.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *_SALDataErrorReporting) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func SALDataErrorReportingParse(readBuffer utils.ReadBuffer, applicationId ApplicationId) (SALDataErrorReporting, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("SALDataErrorReporting"); pullErr != nil {
+ return nil, errors.Wrap(pullErr, "Error pulling for SALDataErrorReporting")
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (errorReportingData)
+ if pullErr := readBuffer.PullContext("errorReportingData"); pullErr != nil {
+ return nil, errors.Wrap(pullErr, "Error pulling for errorReportingData")
+ }
+ _errorReportingData, _errorReportingDataErr := ErrorReportingDataParse(readBuffer)
+ if _errorReportingDataErr != nil {
+ return nil, errors.Wrap(_errorReportingDataErr, "Error parsing 'errorReportingData' field of SALDataErrorReporting")
+ }
+ errorReportingData := _errorReportingData.(ErrorReportingData)
+ if closeErr := readBuffer.CloseContext("errorReportingData"); closeErr != nil {
+ return nil, errors.Wrap(closeErr, "Error closing for errorReportingData")
+ }
+
+ if closeErr := readBuffer.CloseContext("SALDataErrorReporting"); closeErr != nil {
+ return nil, errors.Wrap(closeErr, "Error closing for SALDataErrorReporting")
+ }
+
+ // Create a partially initialized instance
+ _child := &_SALDataErrorReporting{
+ ErrorReportingData: errorReportingData,
+ _SALData: &_SALData{},
+ }
+ _child._SALData._SALDataChildRequirements = _child
+ return _child, nil
+}
+
+func (m *_SALDataErrorReporting) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("SALDataErrorReporting"); pushErr != nil {
+ return errors.Wrap(pushErr, "Error pushing for SALDataErrorReporting")
+ }
+
+ // Simple Field (errorReportingData)
+ if pushErr := writeBuffer.PushContext("errorReportingData"); pushErr != nil {
+ return errors.Wrap(pushErr, "Error pushing for errorReportingData")
+ }
+ _errorReportingDataErr := writeBuffer.WriteSerializable(m.GetErrorReportingData())
+ if popErr := writeBuffer.PopContext("errorReportingData"); popErr != nil {
+ return errors.Wrap(popErr, "Error popping for errorReportingData")
+ }
+ if _errorReportingDataErr != nil {
+ return errors.Wrap(_errorReportingDataErr, "Error serializing 'errorReportingData' field")
+ }
+
+ if popErr := writeBuffer.PopContext("SALDataErrorReporting"); popErr != nil {
+ return errors.Wrap(popErr, "Error popping for SALDataErrorReporting")
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *_SALDataErrorReporting) isSALDataErrorReporting() bool {
+ return true
+}
+
+func (m *_SALDataErrorReporting) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ writeBuffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ if err := writeBuffer.WriteSerializable(m); err != nil {
+ return err.Error()
+ }
+ return writeBuffer.GetBox().String()
+}
diff --git a/plc4go/protocols/cbus/readwrite/model/StaticHelper.go b/plc4go/protocols/cbus/readwrite/model/StaticHelper.go
index bbff83e21..f74ea8166 100644
--- a/plc4go/protocols/cbus/readwrite/model/StaticHelper.go
+++ b/plc4go/protocols/cbus/readwrite/model/StaticHelper.go
@@ -241,3 +241,13 @@ func KnowsMeasurementCommandTypeContainer(readBuffer utils.ReadBuffer) bool {
}
return MeasurementCommandTypeContainerKnows(readUint8)
}
+
+func KnowsErrorReportingCommandTypeContainer(readBuffer utils.ReadBuffer) bool {
+ oldPos := readBuffer.GetPos()
+ defer readBuffer.Reset(oldPos)
+ readUint8, err := readBuffer.ReadUint8("", 8)
+ if err != nil {
+ return false
+ }
+ return ErrorReportingCommandTypeContainerKnows(readUint8)
+}
diff --git a/plc4j/drivers/c-bus/src/main/java/org/apache/plc4x/java/cbus/readwrite/utils/StaticHelper.java b/plc4j/drivers/c-bus/src/main/java/org/apache/plc4x/java/cbus/readwrite/utils/StaticHelper.java
index 84902edea..364e625d7 100644
--- a/plc4j/drivers/c-bus/src/main/java/org/apache/plc4x/java/cbus/readwrite/utils/StaticHelper.java
+++ b/plc4j/drivers/c-bus/src/main/java/org/apache/plc4x/java/cbus/readwrite/utils/StaticHelper.java
@@ -227,4 +227,15 @@ public class StaticHelper {
}
}
+ public static boolean knowsErrorReportingCommandTypeContainer(ReadBuffer readBuffer) {
+ int oldPos = readBuffer.getPos();
+ try {
+ return ErrorReportingCommandTypeContainer.isDefined(readBuffer.readUnsignedShort(8));
+ } catch (ParseException ignore) {
+ return false;
+ } finally {
+ readBuffer.reset(oldPos);
+ }
+ }
+
}
diff --git a/plc4j/drivers/c-bus/src/test/java/org/apache/plc4x/java/cbus/ReferenceTest.java b/plc4j/drivers/c-bus/src/test/java/org/apache/plc4x/java/cbus/ReferenceTest.java
index 7df8fa4ff..3e4aba180 100644
--- a/plc4j/drivers/c-bus/src/test/java/org/apache/plc4x/java/cbus/ReferenceTest.java
+++ b/plc4j/drivers/c-bus/src/test/java/org/apache/plc4x/java/cbus/ReferenceTest.java
@@ -1201,4 +1201,120 @@ public class ReferenceTest {
}
}
+
+ // from: https://updates.clipsal.com/ClipsalSoftwareDownload/DL/downloads/OpenCBus/Chapter%2034%20-%20C-Bus%20Error%20Reporting%20Application.pdf
+ @Nested
+ class ErrorReporting{
+
+ //34.13
+ @Nested
+ class Examples{
+
+ // 34.13.1
+ @Test
+ void AllOk() throws Exception {
+ byte[] bytes = "\\05CE0015FF20DE0000\r".getBytes(StandardCharsets.UTF_8);
+ ReadBufferByteBased readBufferByteBased = new ReadBufferByteBased(bytes);
+ cBusOptions = new CBusOptions(false, false, false, false, false, false, false, false, true);
+ CBusMessage msg = CBusMessage.staticParse(readBufferByteBased, false, requestContext, cBusOptions, bytes.length);
+ assertThat(msg).isNotNull();
+ System.out.println(msg);
+ System.out.println(((RequestCommand) ((CBusMessageToServer) msg).getRequest()).getCbusCommand());
+ assertMessageMatches(bytes, msg);
+ }
+
+ // 34.13.2
+ @Test
+ void MinorFailure() throws Exception {
+ byte[] bytes = "\\05CE0015882A6721B4\r".getBytes(StandardCharsets.UTF_8);
+ ReadBufferByteBased readBufferByteBased = new ReadBufferByteBased(bytes);
+ cBusOptions = new CBusOptions(false, false, false, false, false, false, false, false, true);
+ CBusMessage msg = CBusMessage.staticParse(readBufferByteBased, false, requestContext, cBusOptions, bytes.length);
+ assertThat(msg).isNotNull();
+ System.out.println(msg);
+ System.out.println(((RequestCommand) ((CBusMessageToServer) msg).getRequest()).getCbusCommand());
+ assertMessageMatches(bytes, msg);
+ }
+
+
+ // 34.13.3
+ @Nested
+ class GeneralFailureWhichGetsAcknowledged{
+ @Test
+ void Reporting() throws Exception {
+ byte[] bytes = "\\05CE00159023426633\r".getBytes(StandardCharsets.UTF_8);
+ ReadBufferByteBased readBufferByteBased = new ReadBufferByteBased(bytes);
+ cBusOptions = new CBusOptions(false, false, false, false, false, false, false, false, true);
+ CBusMessage msg = CBusMessage.staticParse(readBufferByteBased, false, requestContext, cBusOptions, bytes.length);
+ assertThat(msg).isNotNull();
+ System.out.println(msg);
+ System.out.println(((RequestCommand) ((CBusMessageToServer) msg).getRequest()).getCbusCommand());
+ assertMessageMatches(bytes, msg);
+ }
+
+ @Test
+ void Acknowledge() throws Exception {
+ byte[] bytes = "\\05CE00259033426633\r".getBytes(StandardCharsets.UTF_8);
+ ReadBufferByteBased readBufferByteBased = new ReadBufferByteBased(bytes);
+ cBusOptions = new CBusOptions(false, false, false, false, false, false, false, false, true);
+ CBusMessage msg = CBusMessage.staticParse(readBufferByteBased, false, requestContext, cBusOptions, bytes.length);
+ assertThat(msg).isNotNull();
+ System.out.println(msg);
+ System.out.println(((RequestCommand) ((CBusMessageToServer) msg).getRequest()).getCbusCommand());
+ assertMessageMatches(bytes, msg);
+ }
+ }
+
+ @Nested
+ class LatchedExtremeFailureWhichGetsCleared {
+ @Test
+ void mostRecent() throws Exception {
+ byte[] bytes = "\\05CE001569E1FE0100\r".getBytes(StandardCharsets.UTF_8);
+ ReadBufferByteBased readBufferByteBased = new ReadBufferByteBased(bytes);
+ cBusOptions = new CBusOptions(false, false, false, false, false, false, false, false, true);
+ CBusMessage msg = CBusMessage.staticParse(readBufferByteBased, false, requestContext, cBusOptions, bytes.length);
+ assertThat(msg).isNotNull();
+ System.out.println(msg);
+ System.out.println(((RequestCommand) ((CBusMessageToServer) msg).getRequest()).getCbusCommand());
+ assertMessageMatches(bytes, msg);
+ }
+
+ @Test
+ void mostSevere() throws Exception {
+ byte[] bytes = "\\05CE001569CCFE0102\r".getBytes(StandardCharsets.UTF_8);
+ ReadBufferByteBased readBufferByteBased = new ReadBufferByteBased(bytes);
+ cBusOptions = new CBusOptions(false, false, false, false, false, false, false, false, true);
+ CBusMessage msg = CBusMessage.staticParse(readBufferByteBased, false, requestContext, cBusOptions, bytes.length);
+ assertThat(msg).isNotNull();
+ System.out.println(msg);
+ System.out.println(((RequestCommand) ((CBusMessageToServer) msg).getRequest()).getCbusCommand());
+ assertMessageMatches(bytes, msg);
+ }
+
+ @Test
+ void clearMostSevere() throws Exception {
+ byte[] bytes = "\\05CE003569C9FE0102\r".getBytes(StandardCharsets.UTF_8);
+ ReadBufferByteBased readBufferByteBased = new ReadBufferByteBased(bytes);
+ cBusOptions = new CBusOptions(false, false, false, false, false, false, false, false, true);
+ CBusMessage msg = CBusMessage.staticParse(readBufferByteBased, false, requestContext, cBusOptions, bytes.length);
+ assertThat(msg).isNotNull();
+ System.out.println(msg);
+ System.out.println(((RequestCommand) ((CBusMessageToServer) msg).getRequest()).getCbusCommand());
+ assertMessageMatches(bytes, msg);
+ }
+
+ @Test
+ void newError() throws Exception {
+ byte[] bytes = "\\05CE001569E9FE0100\r".getBytes(StandardCharsets.UTF_8);
+ ReadBufferByteBased readBufferByteBased = new ReadBufferByteBased(bytes);
+ cBusOptions = new CBusOptions(false, false, false, false, false, false, false, false, true);
+ CBusMessage msg = CBusMessage.staticParse(readBufferByteBased, false, requestContext, cBusOptions, bytes.length);
+ assertThat(msg).isNotNull();
+ System.out.println(msg);
+ System.out.println(((RequestCommand) ((CBusMessageToServer) msg).getRequest()).getCbusCommand());
+ assertMessageMatches(bytes, msg);
+ }
+ }
+ }
+ }
}
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 44ebb46af..818aa5fc8 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
@@ -289,6 +289,7 @@
['0x12' MEASUREMENT ]
['0x13' TESTING ]
['0x14' MEDIA_TRANSPORT_CONTROL ]
+ ['0x15' ERROR_REPORTING ]
]
[enum uint 4 LightingCompatible
@@ -505,7 +506,7 @@
['0xCB' ENABLE_CONTROL_CB ['ENABLE_CONTROL' , 'YES_BUT_RESTRICTIONS']]
['0xCC' I_HAVE_NO_IDEA_CC ['RESERVED' , 'NA' ]] // This is the only value actually not defined in the spec.
['0xCD' AUDIO_AND_VIDEO_CD ['AUDIO_AND_VIDEO' , 'YES_BUT_RESTRICTIONS']]
- ['0xCE' ERROR_REPORTING_CE ['RESERVED' , 'NA' ]] // ERROR_REPORTING
+ ['0xCE' ERROR_REPORTING_CE ['ERROR_REPORTING' , 'NA' ]] // ERROR_REPORTING
['0xCF' RESERVED_CF ['RESERVED' , 'NA' ]]
['0xD0' SECURITY_D0 ['SECURITY' , 'NO' ]]
['0xD1' METERING_D1 ['METERING' , 'NO' ]]
@@ -1365,6 +1366,9 @@
['MEDIA_TRANSPORT_CONTROL' *MediaTransport
[simple MediaTransportControlData mediaTransportControlData]
]
+ ['ERROR_REPORTING' *ErrorReporting
+ [simple ErrorReportingData errorReportingData]
+ ]
]
// TODO: we need to check that we don't read the crc by accident
[optional SALData('applicationId') salData ]
@@ -3335,6 +3339,205 @@
['0xFF' CUSTOM ]
]
+[type ErrorReportingData
+ //TODO: golang doesn't like checking for null so we use that static call to check that the enum is known
+ [validation 'STATIC_CALL("knowsErrorReportingCommandTypeContainer", readBuffer)' "no command type could be found" shouldFail=false]
+ [simple ErrorReportingCommandTypeContainer commandTypeContainer ]
+ [virtual ErrorReportingCommandType commandType 'commandTypeContainer.commandType']
+ [typeSwitch commandType
+ [* *Generic
+ [simple ErrorReportingSystemCategory systemCategory ]
+ [simple bit mostRecent ]
+ [simple bit acknowledge ]
+ [simple bit mostSevere ]
+ [validation 'mostRecent || mostSevere' "Invalid Error condition"]
+ [virtual bit isMostSevereError 'mostSevere']
+ [virtual bit isMostRecentError 'mostRecent']
+ [virtual bit isMostRecentAndMostSevere 'isMostRecentError && isMostSevereError']
+ [simple ErrorReportingSeverity severity ]
+ [simple uint 8 deviceId ]
+ // TODO: maybe split them up according to appendix A
+ [simple uint 8 errorData1 ]
+ [simple uint 8 errorData2 ]
+ ]
+ ]
+]
+
+[enum uint 8 ErrorReportingCommandTypeContainer(ErrorReportingCommandType commandType, uint 5 numBytes)
+ ['0x05' ErrorReportingCommandDeprecated ['DEPRECATED', '5']]
+ ['0x15' ErrorReportingCommandErrorReport ['ERROR_REPORT', '5']]
+ ['0x25' ErrorReportingCommandAcknowledge ['ACKNOWLEDGE', '5']]
+ ['0x35' ErrorReportingCommandClearMostSevere ['CLEAR_MOST_SEVERE', '5']]
+]
+
+[enum uint 4 ErrorReportingCommandType
+ ['0x00' DEPRECATED ]
+ ['0x01' ERROR_REPORT ]
+ ['0x02' ACKNOWLEDGE ]
+ ['0x03' CLEAR_MOST_SEVERE ]
+]
+
+[enum uint 3 ErrorReportingSeverity
+ ['0x0' ALL_OK ]
+ ['0x1' OK ]
+ ['0x2' MINOR_FAILURE ]
+ ['0x3' GENERAL_FAILURE ]
+ ['0x4' EXTREME_FAILURE ]
+ ['0x5' RESERVED_1 ]
+ ['0x6' RESERVED_2 ]
+ ['0x7' RESERVED_3 ]
+]
+
+[type ErrorReportingSystemCategory
+ [simple ErrorReportingSystemCategoryClass systemCategoryClass ]
+ [simple ErrorReportingSystemCategoryType('systemCategoryClass') systemCategoryType ]
+ [simple ErrorReportingSystemCategoryVariant systemCategoryVariant ]
+]
+
+[enum uint 4 ErrorReportingSystemCategoryClass
+ ['0x0' RESERVED_0 ]
+ ['0x1' RESERVED_1 ]
+ ['0x2' RESERVED_2 ]
+ ['0x3' RESERVED_3 ]
+ ['0x4' RESERVED_4 ]
+ ['0x5' INPUT_UNITS ]
+ ['0x6' RESERVED_6 ]
+ ['0x7' RESERVED_7 ]
+ ['0x8' RESERVED_8 ]
+ ['0x9' SUPPORT_UNITS ]
+ ['0xA' RESERVED_10 ]
+ ['0xB' BUILDING_MANAGEMENT_SYSTEMS ]
+ ['0xC' RESERVED_12 ]
+ ['0xD' OUTPUT_UNITS ]
+ ['0xE' RESERVED_14 ]
+ ['0xF' CLIMATE_CONTROLLERS ]
+]
+
+[type ErrorReportingSystemCategoryType(ErrorReportingSystemCategoryClass errorReportingSystemCategoryClass)
+ [typeSwitch errorReportingSystemCategoryClass
+ ['INPUT_UNITS' *InputUnits
+ [simple ErrorReportingSystemCategoryTypeForInputUnits categoryForType ]
+ ]
+ ['SUPPORT_UNITS' *SupportUnits
+ [simple ErrorReportingSystemCategoryTypeForSupportUnits categoryForType ]
+ ]
+ ['BUILDING_MANAGEMENT_SYSTEMS' *BuildingManagementSystems
+ [simple ErrorReportingSystemCategoryTypeForBuildingManagementSystems categoryForType ]
+ ]
+ ['OUTPUT_UNITS' *OutputUnits
+ [simple ErrorReportingSystemCategoryTypeForOutputUnits categoryForType ]
+ ]
+ ['CLIMATE_CONTROLLERS' *ClimateControllers
+ [simple ErrorReportingSystemCategoryTypeForClimateControllers categoryForType ]
+ ]
+ [* *Reserved
+ [simple uint 4 reservedValue]
+ ]
+ ]
+]
+
+[enum uint 4 ErrorReportingSystemCategoryTypeForInputUnits
+ ['0x0' KEY_UNITS ]
+ ['0x1' TELECOMMAND_AND_REMOTE_ENTRY]
+ ['0x2' RESERVED_2 ]
+ ['0x3' RESERVED_3 ]
+ ['0x4' RESERVED_4 ]
+ ['0x5' RESERVED_5 ]
+ ['0x6' RESERVED_6 ]
+ ['0x7' RESERVED_7 ]
+ ['0x8' RESERVED_8 ]
+ ['0x9' RESERVED_9 ]
+ ['0xA' RESERVED_10 ]
+ ['0xB' RESERVED_11 ]
+ ['0xC' RESERVED_12 ]
+ ['0xD' RESERVED_13 ]
+ ['0xE' RESERVED_14 ]
+ ['0xF' RESERVED_15 ]
+]
+
+[enum uint 4 ErrorReportingSystemCategoryTypeForSupportUnits
+ ['0x0' POWER_SUPPLIES ]
+ ['0x1' RESERVED_1 ]
+ ['0x2' RESERVED_2 ]
+ ['0x3' RESERVED_3 ]
+ ['0x4' RESERVED_4 ]
+ ['0x5' RESERVED_5 ]
+ ['0x6' RESERVED_6 ]
+ ['0x7' RESERVED_7 ]
+ ['0x8' RESERVED_8 ]
+ ['0x9' RESERVED_9 ]
+ ['0xA' RESERVED_10 ]
+ ['0xB' RESERVED_11 ]
+ ['0xC' RESERVED_12 ]
+ ['0xD' RESERVED_13 ]
+ ['0xE' RESERVED_14 ]
+ ['0xF' RESERVED_15 ]
+]
+
+[enum uint 4 ErrorReportingSystemCategoryTypeForBuildingManagementSystems
+ ['0x0' BMS_DIAGNOSTIC_REPORTING ]
+ ['0x1' RESERVED_1 ]
+ ['0x2' RESERVED_2 ]
+ ['0x3' RESERVED_3 ]
+ ['0x4' RESERVED_4 ]
+ ['0x5' RESERVED_5 ]
+ ['0x6' RESERVED_6 ]
+ ['0x7' RESERVED_7 ]
+ ['0x8' RESERVED_8 ]
+ ['0x9' RESERVED_9 ]
+ ['0xA' RESERVED_10 ]
+ ['0xB' RESERVED_11 ]
+ ['0xC' RESERVED_12 ]
+ ['0xD' RESERVED_13 ]
+ ['0xE' RESERVED_14 ]
+ ['0xF' RESERVED_15 ]
+]
+
+[enum uint 4 ErrorReportingSystemCategoryTypeForOutputUnits
+ ['0x0' LE_MONOBLOCK_DIMMERS ]
+ ['0x1' TE_MONOBLOCK_DIMMERS ]
+ ['0x2' RESERVED_2 ]
+ ['0x3' RESERVED_3 ]
+ ['0x4' RELAYS_AND_OTHER_ON_OFF_SWITCHING_DEVICES ]
+ ['0x5' RESERVED_5 ]
+ ['0x6' PWM_DIMMERS_INCLUDES_LED_CONTROL ]
+ ['0x7' SINEWAVE_MONOBLOCK_DIMMERS ]
+ ['0x8' RESERVED_8 ]
+ ['0x9' RESERVED_9 ]
+ ['0xA' DALI_DSI_AND_OTHER_BALLAST_CONTROL_GATEWAYS ]
+ ['0xB' MODULAR_DIMMERS ]
+ ['0xC' RESERVED_12 ]
+ ['0xD' UNIVERSAL_MONOBLOCK_DIMMERS ]
+ ['0xE' DEVICE_CONTROLLERS_IR_RS_232_etc ]
+ ['0xF' RESERVED_15 ]
+]
+
+[enum uint 4 ErrorReportingSystemCategoryTypeForClimateControllers
+ ['0x0' AIR_CONDITIONING_SYSTEM ]
+ ['0x1' RESERVED_1 ]
+ ['0x2' RESERVED_2 ]
+ ['0x3' RESERVED_3 ]
+ ['0x4' RESERVED_4 ]
+ ['0x5' RESERVED_5 ]
+ ['0x6' RESERVED_6 ]
+ ['0x7' RESERVED_7 ]
+ ['0x8' RESERVED_8 ]
+ ['0x9' RESERVED_9 ]
+ ['0xA' RESERVED_10 ]
+ ['0xB' RESERVED_11 ]
+ ['0xC' GLOBAL_WARMING_MODULATOR ]
+ ['0xD' RESERVED_13 ]
+ ['0xE' RESERVED_14 ]
+ ['0xF' RESERVED_15 ]
+]
+
+[enum uint 2 ErrorReportingSystemCategoryVariant
+ ['0x0' RESERVED_0 ]
+ ['0x1' RESERVED_1 ]
+ ['0x2' RESERVED_2 ]
+ ['0x3' RESERVED_3 ]
+]
+
[type ReplyOrConfirmation(CBusOptions cBusOptions, uint 16 messageLength, RequestContext requestContext)
[peek byte peekedByte ]
[virtual bit isAlpha '(peekedByte >= 0x67) && (peekedByte <= 0x7A)' ]