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:52 UTC
[plc4x] branch develop updated (61edca454 -> cc4f30d87)
This is an automated email from the ASF dual-hosted git repository.
sruehl pushed a change to branch develop
in repository https://gitbox.apache.org/repos/asf/plc4x.git
from 61edca454 feat(cbus): implemented pools spa ponds fountains control application
new 238d80bef feat(cbus): implemented measurement application
new cc4f30d87 feat(cbus): implemented error reporting application
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
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 ++++++++++
.../{MeasurementData.go => ErrorReportingData.go} | 114 ++---
.../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 +++++++++
.../cbus/readwrite/model/SALDataMeasurement.go | 54 ++-
.../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 | 215 +++++++++-
31 files changed, 4900 insertions(+), 70 deletions(-)
create mode 100644 plc4go/protocols/cbus/readwrite/model/ErrorReportingCommandType.go
create mode 100644 plc4go/protocols/cbus/readwrite/model/ErrorReportingCommandTypeContainer.go
copy plc4go/protocols/cbus/readwrite/model/{MeasurementData.go => ErrorReportingData.go} (58%)
create mode 100644 plc4go/protocols/cbus/readwrite/model/ErrorReportingDataGeneric.go
create mode 100644 plc4go/protocols/cbus/readwrite/model/ErrorReportingSeverity.go
create mode 100644 plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategory.go
create mode 100644 plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryClass.go
create mode 100644 plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryType.go
create mode 100644 plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeBuildingManagementSystems.go
create mode 100644 plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeClimateControllers.go
create mode 100644 plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeForBuildingManagementSystems.go
create mode 100644 plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeForClimateControllers.go
create mode 100644 plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeForInputUnits.go
create mode 100644 plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeForOutputUnits.go
create mode 100644 plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeForSupportUnits.go
create mode 100644 plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeInputUnits.go
create mode 100644 plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeOutputUnits.go
create mode 100644 plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeReserved.go
create mode 100644 plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryTypeSupportUnits.go
create mode 100644 plc4go/protocols/cbus/readwrite/model/ErrorReportingSystemCategoryVariant.go
create mode 100644 plc4go/protocols/cbus/readwrite/model/SALDataErrorReporting.go
[plc4x] 01/02: feat(cbus): implemented measurement application
Posted by sr...@apache.org.
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 238d80befe526880228ac2cbf26cda038358c8f3
Author: Sebastian Rühl <sr...@apache.org>
AuthorDate: Tue Jul 19 16:12:33 2022 +0200
feat(cbus): implemented measurement application
---
.../cbus/readwrite/model/SALDataMeasurement.go | 54 +++++++++++++++++++---
.../src/main/resources/protocols/cbus/c-bus.mspec | 18 ++++----
2 files changed, 57 insertions(+), 15 deletions(-)
diff --git a/plc4go/protocols/cbus/readwrite/model/SALDataMeasurement.go b/plc4go/protocols/cbus/readwrite/model/SALDataMeasurement.go
index 49ec1b55b..da497f8a4 100644
--- a/plc4go/protocols/cbus/readwrite/model/SALDataMeasurement.go
+++ b/plc4go/protocols/cbus/readwrite/model/SALDataMeasurement.go
@@ -31,6 +31,8 @@ type SALDataMeasurement interface {
utils.LengthAware
utils.Serializable
SALData
+ // GetMeasurementData returns MeasurementData (property field)
+ GetMeasurementData() MeasurementData
}
// SALDataMeasurementExactly can be used when we want exactly this type and not a type which fulfills SALDataMeasurement.
@@ -43,6 +45,7 @@ type SALDataMeasurementExactly interface {
// _SALDataMeasurement is the data-structure of this message
type _SALDataMeasurement struct {
*_SALData
+ MeasurementData MeasurementData
}
///////////////////////////////////////////////////////////
@@ -67,10 +70,25 @@ func (m *_SALDataMeasurement) GetParent() SALData {
return m._SALData
}
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *_SALDataMeasurement) GetMeasurementData() MeasurementData {
+ return m.MeasurementData
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
// NewSALDataMeasurement factory function for _SALDataMeasurement
-func NewSALDataMeasurement(salData SALData) *_SALDataMeasurement {
+func NewSALDataMeasurement(measurementData MeasurementData, salData SALData) *_SALDataMeasurement {
_result := &_SALDataMeasurement{
- _SALData: NewSALData(salData),
+ MeasurementData: measurementData,
+ _SALData: NewSALData(salData),
}
_result._SALData._SALDataChildRequirements = _result
return _result
@@ -98,6 +116,9 @@ func (m *_SALDataMeasurement) GetLengthInBits() uint16 {
func (m *_SALDataMeasurement) GetLengthInBitsConditional(lastItem bool) uint16 {
lengthInBits := uint16(m.GetParentLengthInBits())
+ // Simple field (measurementData)
+ lengthInBits += m.MeasurementData.GetLengthInBits()
+
return lengthInBits
}
@@ -114,9 +135,17 @@ func SALDataMeasurementParse(readBuffer utils.ReadBuffer, applicationId Applicat
currentPos := positionAware.GetPos()
_ = currentPos
- // Validation
- if !(bool((1) == (2))) {
- return nil, errors.WithStack(utils.ParseValidationError{"MEASUREMENT Not yet implemented"})
+ // Simple Field (measurementData)
+ if pullErr := readBuffer.PullContext("measurementData"); pullErr != nil {
+ return nil, errors.Wrap(pullErr, "Error pulling for measurementData")
+ }
+ _measurementData, _measurementDataErr := MeasurementDataParse(readBuffer)
+ if _measurementDataErr != nil {
+ return nil, errors.Wrap(_measurementDataErr, "Error parsing 'measurementData' field of SALDataMeasurement")
+ }
+ measurementData := _measurementData.(MeasurementData)
+ if closeErr := readBuffer.CloseContext("measurementData"); closeErr != nil {
+ return nil, errors.Wrap(closeErr, "Error closing for measurementData")
}
if closeErr := readBuffer.CloseContext("SALDataMeasurement"); closeErr != nil {
@@ -125,7 +154,8 @@ func SALDataMeasurementParse(readBuffer utils.ReadBuffer, applicationId Applicat
// Create a partially initialized instance
_child := &_SALDataMeasurement{
- _SALData: &_SALData{},
+ MeasurementData: measurementData,
+ _SALData: &_SALData{},
}
_child._SALData._SALDataChildRequirements = _child
return _child, nil
@@ -139,6 +169,18 @@ func (m *_SALDataMeasurement) Serialize(writeBuffer utils.WriteBuffer) error {
return errors.Wrap(pushErr, "Error pushing for SALDataMeasurement")
}
+ // Simple Field (measurementData)
+ if pushErr := writeBuffer.PushContext("measurementData"); pushErr != nil {
+ return errors.Wrap(pushErr, "Error pushing for measurementData")
+ }
+ _measurementDataErr := writeBuffer.WriteSerializable(m.GetMeasurementData())
+ if popErr := writeBuffer.PopContext("measurementData"); popErr != nil {
+ return errors.Wrap(popErr, "Error popping for measurementData")
+ }
+ if _measurementDataErr != nil {
+ return errors.Wrap(_measurementDataErr, "Error serializing 'measurementData' field")
+ }
+
if popErr := writeBuffer.PopContext("SALDataMeasurement"); popErr != nil {
return errors.Wrap(popErr, "Error popping for SALDataMeasurement")
}
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 74cb2cf49..44ebb46af 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
@@ -1357,7 +1357,7 @@
[simple TelephonyData telephonyData]
]
['MEASUREMENT' *Measurement
- [validation '1==2' "MEASUREMENT Not yet implemented"] // TODO: implement me
+ [simple MeasurementData measurementData]
]
['TESTING' *Testing
[validation '1==2' "TESTING Not yet implemented"] // TODO: implement me
@@ -3282,6 +3282,14 @@
]
]
+[enum uint 8 MeasurementCommandTypeContainer(MeasurementCommandType commandType, uint 5 numBytes)
+ ['0x0E' MeasurementCommandChannelMeasurementData ['MEASUREMENT_EVENT', '6']]
+]
+
+[enum uint 4 MeasurementCommandType
+ ['0x00' MEASUREMENT_EVENT ]
+]
+
[enum uint 8 MeasurementUnits
['0x00' CELSIUS ]
['0x01' AMPS ]
@@ -3327,14 +3335,6 @@
['0xFF' CUSTOM ]
]
-[enum uint 8 MeasurementCommandTypeContainer(MeasurementCommandType commandType, uint 5 numBytes)
- ['0x0E' MeasurementCommandChannelMeasurementData ['MEASUREMENT_EVENT', '6']]
-]
-
-[enum uint 4 MeasurementCommandType
- ['0x00' MEASUREMENT_EVENT ]
-]
-
[type ReplyOrConfirmation(CBusOptions cBusOptions, uint 16 messageLength, RequestContext requestContext)
[peek byte peekedByte ]
[virtual bit isAlpha '(peekedByte >= 0x67) && (peekedByte <= 0x7A)' ]
[plc4x] 02/02: feat(cbus): implemented error reporting application
Posted by sr...@apache.org.
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)' ]