You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@plc4x.apache.org by cd...@apache.org on 2021/02/16 14:51:31 UTC
[plc4x] branch develop updated: - Implemented active Group Address
reads - Greatly refactored how the group-address reading works
This is an automated email from the ASF dual-hosted git repository.
cdutz pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/plc4x.git
The following commit(s) were added to refs/heads/develop by this push:
new 9b326b3 - Implemented active Group Address reads - Greatly refactored how the group-address reading works
9b326b3 is described below
commit 9b326b35d38abe7f07a9e8d9181a2317b8548808
Author: Christofer Dutz <ch...@c-ware.de>
AuthorDate: Tue Feb 16 15:51:22 2021 +0100
- Implemented active Group Address reads
- Greatly refactored how the group-address reading works
---
.../hello_world_plc4go_knx_read_group_address.go | 84 +
.../internal/plc4go/knxnetip/KnxNetIpConnection.go | 161 +-
plc4go/internal/plc4go/knxnetip/KnxNetIpReader.go | 499 +-
.../internal/plc4go/knxnetip/KnxNetIpSubscriber.go | 150 +-
plc4go/internal/plc4go/knxnetip/Utils.go | 56 +-
.../plc4go/knxnetip/readwrite/model/ApduData.go | 657 +-
.../readwrite/model/ApduDataGroupValueRead.go | 159 +-
.../readwrite/model/ApduDataGroupValueResponse.go | 213 +-
.../knxnetip/readwrite/model/KnxDatapoint.go | 22387 +++++++++----------
.../resources/protocols/knxnetip/knxnetip.mspec | 5 +-
protocols/knxnetip/src/main/xslt/knx-types.xsl | 13 +-
11 files changed, 11268 insertions(+), 13116 deletions(-)
diff --git a/plc4go/examples/knx/groupAddressRead/hello_world_plc4go_knx_read_group_address.go b/plc4go/examples/knx/groupAddressRead/hello_world_plc4go_knx_read_group_address.go
new file mode 100644
index 0000000..dbb2c1a
--- /dev/null
+++ b/plc4go/examples/knx/groupAddressRead/hello_world_plc4go_knx_read_group_address.go
@@ -0,0 +1,84 @@
+//
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+//
+package main
+
+import (
+ "fmt"
+ "github.com/apache/plc4x/plc4go/internal/plc4go/knxnetip"
+ "github.com/apache/plc4x/plc4go/internal/plc4go/spi/transports/udp"
+ "github.com/apache/plc4x/plc4go/pkg/plc4go"
+ "github.com/apache/plc4x/plc4go/pkg/plc4go/model"
+)
+
+func main() {
+ driverManager := plc4go.NewPlcDriverManager()
+ driverManager.RegisterDriver(knxnetip.NewKnxNetIpDriver())
+ driverManager.RegisterTransport(udp.NewUdpTransport())
+
+ // Get a connection to a remote PLC
+ crc := driverManager.GetConnection("knxnet-ip:udp://192.168.42.11")
+
+ // Wait for the driver to connect (or not)
+ connectionResult := <-crc
+ if connectionResult.Err != nil {
+ fmt.Printf("error connecting to PLC: %s", connectionResult.Err.Error())
+ return
+ }
+ connection := connectionResult.Connection
+
+ // Make sure the connection is closed at the end
+ defer connection.Close()
+
+ // Prepare a read-request
+ rrb := connection.ReadRequestBuilder()
+ rrb.AddItem("firstFlorTemperatures", "2/[1,2,4,6]/10:DPT_Value_Temp")
+ rrb.AddItem("secondFlorTemperatures", "3/[2,3,4,6]/10:DPT_Value_Temp")
+ readRequest, err := rrb.Build()
+ if err != nil {
+ fmt.Printf("error preparing read-request: %s", connectionResult.Err.Error())
+ return
+ }
+
+ // Execute a read-request
+ rrc := readRequest.Execute()
+
+ // Wait for the response to finish
+ rrr := <-rrc
+ if rrr.Err != nil {
+ fmt.Printf("error executing read-request: %s", rrr.Err.Error())
+ return
+ }
+
+ // Do something with the response
+ for _, fieldName := range rrr.Response.GetFieldNames() {
+ if rrr.Response.GetResponseCode(fieldName) != model.PlcResponseCode_OK {
+ fmt.Printf("error an non-ok return code for field %s: %s\n", fieldName, rrr.Response.GetResponseCode(fieldName).GetName())
+ continue
+ }
+
+ value := rrr.Response.GetValue(fieldName)
+ if value.GetStruct() != nil {
+ for address, structValue := range value.GetStruct() {
+ fmt.Printf("Got result for field %s with address: %s: %s\n", fieldName, address, structValue.GetString())
+ }
+ } else {
+ fmt.Printf("Got result for field %s: %s\n", fieldName, value.GetString())
+ }
+ }
+}
diff --git a/plc4go/internal/plc4go/knxnetip/KnxNetIpConnection.go b/plc4go/internal/plc4go/knxnetip/KnxNetIpConnection.go
index 6e7dce2..0819579 100644
--- a/plc4go/internal/plc4go/knxnetip/KnxNetIpConnection.go
+++ b/plc4go/internal/plc4go/knxnetip/KnxNetIpConnection.go
@@ -36,6 +36,7 @@ import (
log "github.com/sirupsen/logrus"
"math"
"net"
+ "reflect"
"strconv"
"strings"
"sync"
@@ -110,9 +111,6 @@ type KnxNetIpConnection struct {
connectionStateTimer *time.Ticker
quitConnectionStateTimer chan struct{}
subscribers []*KnxNetIpSubscriber
- leve3AddressCache map[uint16]*driverModel.KnxGroupAddress3Level
- leve2AddressCache map[uint16]*driverModel.KnxGroupAddress2Level
- leve1AddressCache map[uint16]*driverModel.KnxGroupAddressFreeLevel
valueCache map[uint16][]int8
valueCacheMutex sync.RWMutex
@@ -148,9 +146,6 @@ func NewKnxNetIpConnection(transportInstance transports.TransportInstance, optio
valueHandler: NewValueHandler(),
requestInterceptor: interceptors.NewSingleItemRequestInterceptor(),
subscribers: []*KnxNetIpSubscriber{},
- leve3AddressCache: map[uint16]*driverModel.KnxGroupAddress3Level{},
- leve2AddressCache: map[uint16]*driverModel.KnxGroupAddress2Level{},
- leve1AddressCache: map[uint16]*driverModel.KnxGroupAddressFreeLevel{},
valueCache: map[uint16][]int8{},
valueCacheMutex: sync.RWMutex{},
metadata: &ConnectionMetadata{},
@@ -413,6 +408,10 @@ func (m *KnxNetIpConnection) Ping() <-chan plc4go.PlcConnectionPingResult {
return result
}
+func (m *KnxNetIpConnection) ReadGroupAddress(groupAddress []int8, datapointType *driverModel.KnxDatapointType) <-chan KnxReadResult {
+ return m.sendGroupAddressReadRequest(groupAddress, datapointType)
+}
+
func (m *KnxNetIpConnection) ConnectToDevice(targetAddress driverModel.KnxAddress) <-chan *KnxDeviceConnection {
result := make(chan *KnxDeviceConnection)
@@ -833,6 +832,99 @@ func (m *KnxNetIpConnection) sendConnectionStateRequest() chan InternalResult {
return result
}
+func (m *KnxNetIpConnection) sendGroupAddressReadRequest(groupAddress []int8, datapointType *driverModel.KnxDatapointType) chan KnxReadResult {
+ result := make(chan KnxReadResult)
+
+ // Send the property read request and wait for a confirmation that this property is readable.
+ groupAddressReadRequest := driverModel.NewTunnelingRequest(
+ driverModel.NewTunnelingRequestDataBlock(0, 0),
+ driverModel.NewLDataReq(0, nil,
+ driverModel.NewLDataExtended(true, 6, 0,
+ m.ClientKnxAddress, groupAddress,
+ driverModel.NewApduDataContainer(
+ driverModel.NewApduDataGroupValueRead(), false, 0),
+ true, true, driverModel.CEMIPriority_LOW, false, false)))
+ err := m.sendRequest(
+ groupAddressReadRequest,
+ func(message interface{}) bool {
+ tunnelingRequest := driverModel.CastTunnelingRequest(message)
+ if tunnelingRequest == nil ||
+ tunnelingRequest.TunnelingRequestDataBlock.CommunicationChannelId != m.CommunicationChannelId {
+ return false
+ }
+ lDataInd := driverModel.CastLDataInd(tunnelingRequest.Cemi)
+ if lDataInd == nil {
+ return false
+ }
+ dataFrameExt := driverModel.CastLDataExtended(lDataInd.DataFrame)
+ if dataFrameExt == nil {
+ return false
+ }
+ dataContainer := driverModel.CastApduDataContainer(dataFrameExt.Apdu)
+ if dataContainer == nil {
+ return false
+ }
+ groupReadResponse := driverModel.CastApduDataGroupValueResponse(dataContainer.DataApdu)
+ if groupReadResponse == nil {
+ return false
+ }
+ // Check if it's a value response for the given group address
+ return dataFrameExt.GroupAddress && reflect.DeepEqual(dataFrameExt.DestinationAddress, groupAddress)
+ },
+ func(message interface{}) error {
+ tunnelingRequest := driverModel.CastTunnelingRequest(message)
+ lDataInd := driverModel.CastLDataInd(tunnelingRequest.Cemi)
+ dataFrameExt := driverModel.CastLDataExtended(lDataInd.DataFrame)
+ dataContainer := driverModel.CastApduDataContainer(dataFrameExt.Apdu)
+ groupReadResponse := driverModel.CastApduDataGroupValueResponse(dataContainer.DataApdu)
+
+ var payload []int8
+ payload = append(payload, groupReadResponse.DataFirstByte)
+ payload = append(payload, groupReadResponse.Data...)
+
+ // Make sure any subscribers are updated.
+ // TODO: Disabled as this could pollute the cache with stale data.
+ //destinationAddress := dataFrameExt.DestinationAddress
+ //m.handleValueCacheUpdate(destinationAddress, payload)
+
+ // Parse the response data.
+ rb := utils.NewReadBuffer(utils.Int8ArrayToByteArray(payload))
+ // If the size of the field is greater than 6, we have to skip the first byte
+ if datapointType.LengthInBits() > 6 {
+ _, _ = rb.ReadUint8(8)
+ }
+ if *datapointType == driverModel.KnxDatapointType_DPT_UNKNOWN {
+ // TODO: Set a sensible default here
+ }
+ plcValue, err := driverModel.KnxDatapointParse(rb, *datapointType)
+ if err != nil {
+ return err
+ }
+
+ // Return the value
+ result <- KnxReadResult{
+ returnCode: apiModel.PlcResponseCode_OK,
+ value: &plcValue,
+ numItems: 1,
+ }
+ return nil
+ },
+ func(err error) error {
+ result <- KnxReadResult{
+ returnCode: apiModel.PlcResponseCode_RESPONSE_PENDING,
+ value: nil,
+ numItems: 0,
+ }
+ return nil
+ },
+ m.defaultTtl)
+
+ if err != nil {
+ // close(result)
+ }
+ return result
+}
+
func (m *KnxNetIpConnection) sendDeviceConnectionRequest(targetAddress driverModel.KnxAddress) chan InternalResult {
result := make(chan InternalResult)
@@ -1530,43 +1622,12 @@ func (m *KnxNetIpConnection) handleIncomingTunnelingRequest(tunnelingRequest *dr
case *driverModel.ApduDataGroupValueWrite:
groupValueWrite := driverModel.CastApduDataGroupValueWrite(container.DataApdu)
if destinationAddress != nil {
- addressData := uint16(destinationAddress[0])<<8 | (uint16(destinationAddress[1]) & 0xFF)
- m.valueCacheMutex.RLock()
- val, ok := m.valueCache[addressData]
- m.valueCacheMutex.RUnlock()
- changed := false
-
var payload []int8
payload = append(payload, groupValueWrite.DataFirstByte)
payload = append(payload, groupValueWrite.Data...)
- if !ok || !m.sliceEqual(val, payload) {
- m.valueCacheMutex.Lock()
- m.valueCache[addressData] = payload
- m.valueCacheMutex.Unlock()
- // If this is a new value, we have to also provide the 3 different types of addresses.
- if !ok {
- arb := utils.NewReadBuffer(utils.Int8ArrayToUint8Array(destinationAddress))
- if address, err2 := driverModel.KnxGroupAddressParse(arb, 3); err2 == nil {
- m.leve3AddressCache[addressData] = driverModel.CastKnxGroupAddress3Level(address)
- } else {
- fmt.Printf("Error parsing Group Address %s", err2.Error())
- }
- arb.Reset()
- if address, err2 := driverModel.KnxGroupAddressParse(arb, 2); err2 == nil {
- m.leve2AddressCache[addressData] = driverModel.CastKnxGroupAddress2Level(address)
- }
- arb.Reset()
- if address, err2 := driverModel.KnxGroupAddressParse(arb, 1); err2 == nil {
- m.leve1AddressCache[addressData] = driverModel.CastKnxGroupAddressFreeLevel(address)
- }
- }
- changed = true
- }
- if m.subscribers != nil {
- for _, subscriber := range m.subscribers {
- subscriber.handleValueChange(lDataInd.DataFrame, changed)
- }
- }
+
+ m.handleValueCacheUpdate(destinationAddress, payload)
+ // TODO: Continue
}
default:
// If this is an individual address and it is targeted at us, we need to ack that.
@@ -1595,6 +1656,26 @@ func (m *KnxNetIpConnection) handleIncomingTunnelingRequest(tunnelingRequest *dr
}()
}
+func (m *KnxNetIpConnection) handleValueCacheUpdate(destinationAddress []int8, payload []int8) {
+ addressData := uint16(destinationAddress[0])<<8 | (uint16(destinationAddress[1]) & 0xFF)
+
+ m.valueCacheMutex.RLock()
+ val, ok := m.valueCache[addressData]
+ m.valueCacheMutex.RUnlock()
+ changed := false
+ if !ok || !m.sliceEqual(val, payload) {
+ m.valueCacheMutex.Lock()
+ m.valueCache[addressData] = payload
+ m.valueCacheMutex.Unlock()
+ changed = true
+ }
+ if m.subscribers != nil {
+ for _, subscriber := range m.subscribers {
+ subscriber.handleValueChange(destinationAddress, payload, changed)
+ }
+ }
+}
+
func (m *KnxNetIpConnection) getGroupAddressNumLevels() uint8 {
if val, ok := m.options["group-address-num-levels"]; ok {
groupAddressNumLevels, err := strconv.Atoi(val[0])
diff --git a/plc4go/internal/plc4go/knxnetip/KnxNetIpReader.go b/plc4go/internal/plc4go/knxnetip/KnxNetIpReader.go
index 221d60a..09dec82 100644
--- a/plc4go/internal/plc4go/knxnetip/KnxNetIpReader.go
+++ b/plc4go/internal/plc4go/knxnetip/KnxNetIpReader.go
@@ -19,242 +19,315 @@
package knxnetip
import (
- driverModel "github.com/apache/plc4x/plc4go/internal/plc4go/knxnetip/readwrite/model"
- "github.com/apache/plc4x/plc4go/internal/plc4go/spi"
- internalModel "github.com/apache/plc4x/plc4go/internal/plc4go/spi/model"
- "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
- internalValues "github.com/apache/plc4x/plc4go/internal/plc4go/spi/values"
- apiModel "github.com/apache/plc4x/plc4go/pkg/plc4go/model"
- apiValues "github.com/apache/plc4x/plc4go/pkg/plc4go/values"
- "time"
+ "errors"
+ driverModel "github.com/apache/plc4x/plc4go/internal/plc4go/knxnetip/readwrite/model"
+ "github.com/apache/plc4x/plc4go/internal/plc4go/spi"
+ internalModel "github.com/apache/plc4x/plc4go/internal/plc4go/spi/model"
+ "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+ internalValues "github.com/apache/plc4x/plc4go/internal/plc4go/spi/values"
+ apiModel "github.com/apache/plc4x/plc4go/pkg/plc4go/model"
+ apiValues "github.com/apache/plc4x/plc4go/pkg/plc4go/values"
+ "strconv"
+ "strings"
+ "time"
)
type KnxNetIpReader struct {
- connection *KnxNetIpConnection
- spi.PlcReader
+ connection *KnxNetIpConnection
+ spi.PlcReader
}
func NewKnxNetIpReader(connection *KnxNetIpConnection) *KnxNetIpReader {
- return &KnxNetIpReader{
- connection: connection,
- }
+ return &KnxNetIpReader{
+ connection: connection,
+ }
}
func (m KnxNetIpReader) Read(readRequest apiModel.PlcReadRequest) <-chan apiModel.PlcReadRequestResult {
- resultChan := make(chan apiModel.PlcReadRequestResult)
- go func() {
- responseCodes := map[string]apiModel.PlcResponseCode{}
- plcValues := map[string]apiValues.PlcValue{}
+ resultChan := make(chan apiModel.PlcReadRequestResult)
+ go func() {
+ responseCodes := map[string]apiModel.PlcResponseCode{}
+ plcValues := map[string]apiValues.PlcValue{}
- // Sort the fields in direct properties and memory addresses, which will have to be actively
- // read from the devices and group-addresses which will be locally processed from the local cache.
- deviceAddresses := map[driverModel.KnxAddress]map[string]KnxNetIpDeviceField{}
- groupAddresses := map[string]KnxNetIpGroupAddressField{}
- for _, fieldName := range readRequest.GetFieldNames() {
- // Get the knx field
- field, err := CastToKnxNetIpFieldFromPlcField(readRequest.GetField(fieldName))
- if err != nil {
- responseCodes[fieldName] = apiModel.PlcResponseCode_INVALID_ADDRESS
- plcValues[fieldName] = nil
- continue
- }
+ // Sort the fields in direct properties and memory addresses, which will have to be actively
+ // read from the devices and group-addresses which will be locally processed from the local cache.
+ deviceAddresses := map[driverModel.KnxAddress]map[string]KnxNetIpDeviceField{}
+ groupAddresses := map[string]KnxNetIpGroupAddressField{}
+ for _, fieldName := range readRequest.GetFieldNames() {
+ // Get the knx field
+ field, err := CastToKnxNetIpFieldFromPlcField(readRequest.GetField(fieldName))
+ if err != nil {
+ responseCodes[fieldName] = apiModel.PlcResponseCode_INVALID_ADDRESS
+ plcValues[fieldName] = nil
+ continue
+ }
- switch field.(type) {
- case KnxNetIpDevicePropertyAddressPlcField:
- propertyField := field.(KnxNetIpDevicePropertyAddressPlcField)
- knxAddress := propertyField.toKnxAddress()
- if knxAddress == nil {
- continue
- }
- if _, ok := deviceAddresses[*knxAddress]; !ok {
- deviceAddresses[*knxAddress] = map[string]KnxNetIpDeviceField{}
- }
- deviceAddresses[*knxAddress][fieldName] = propertyField
- case KnxNetIpDeviceMemoryAddressPlcField:
- memoryField := field.(KnxNetIpDeviceMemoryAddressPlcField)
- knxAddress := memoryField.toKnxAddress()
- if knxAddress == nil {
- continue
- }
- if _, ok := deviceAddresses[*knxAddress]; !ok {
- deviceAddresses[*knxAddress] = map[string]KnxNetIpDeviceField{}
- }
- deviceAddresses[*knxAddress][fieldName] = memoryField
- case KnxNetIpCommunicationObjectQueryField:
- responseCodes[fieldName] = apiModel.PlcResponseCode_INVALID_ADDRESS
- plcValues[fieldName] = nil
- continue
- case KnxNetIpGroupAddressField:
- groupAddressField := field.(KnxNetIpGroupAddressField)
- groupAddresses[fieldName] = groupAddressField
- default:
- responseCodes[fieldName] = apiModel.PlcResponseCode_INVALID_ADDRESS
- plcValues[fieldName] = nil
- }
- }
+ switch field.(type) {
+ case KnxNetIpDevicePropertyAddressPlcField:
+ propertyField := field.(KnxNetIpDevicePropertyAddressPlcField)
+ knxAddress := propertyField.toKnxAddress()
+ if knxAddress == nil {
+ continue
+ }
+ if _, ok := deviceAddresses[*knxAddress]; !ok {
+ deviceAddresses[*knxAddress] = map[string]KnxNetIpDeviceField{}
+ }
+ deviceAddresses[*knxAddress][fieldName] = propertyField
+ case KnxNetIpDeviceMemoryAddressPlcField:
+ memoryField := field.(KnxNetIpDeviceMemoryAddressPlcField)
+ knxAddress := memoryField.toKnxAddress()
+ if knxAddress == nil {
+ continue
+ }
+ if _, ok := deviceAddresses[*knxAddress]; !ok {
+ deviceAddresses[*knxAddress] = map[string]KnxNetIpDeviceField{}
+ }
+ deviceAddresses[*knxAddress][fieldName] = memoryField
+ case KnxNetIpCommunicationObjectQueryField:
+ responseCodes[fieldName] = apiModel.PlcResponseCode_INVALID_ADDRESS
+ plcValues[fieldName] = nil
+ continue
+ case KnxNetIpGroupAddressField:
+ groupAddressField := field.(KnxNetIpGroupAddressField)
+ groupAddresses[fieldName] = groupAddressField
+ default:
+ responseCodes[fieldName] = apiModel.PlcResponseCode_INVALID_ADDRESS
+ plcValues[fieldName] = nil
+ }
+ }
- // Process the direct properties.
- // Connect to each knx device and read all of the properties on that particular device.
- for deviceAddress, fields := range deviceAddresses {
- // Collect all the properties on this device
- for fieldName, field := range fields {
- switch field.(type) {
- case KnxNetIpDevicePropertyAddressPlcField:
- propertyField := field.(KnxNetIpDevicePropertyAddressPlcField)
+ // Process the direct properties.
+ // Connect to each knx device and read all of the properties on that particular device.
+ for deviceAddress, fields := range deviceAddresses {
+ // Collect all the properties on this device
+ for fieldName, field := range fields {
+ switch field.(type) {
+ case KnxNetIpDevicePropertyAddressPlcField:
+ propertyField := field.(KnxNetIpDevicePropertyAddressPlcField)
- results := m.connection.ReadDeviceProperty(deviceAddress, propertyField.ObjectId, propertyField.PropertyId)
- select {
- case result := <-results:
- responseCodes[fieldName] = result.returnCode
- if result.returnCode == apiModel.PlcResponseCode_OK {
- plcValues[fieldName] = *result.value
- } else {
- plcValues[fieldName] = nil
- }
- case <-time.After(m.connection.defaultTtl):
- responseCodes[fieldName] = apiModel.PlcResponseCode_REMOTE_BUSY
- plcValues[fieldName] = nil
- }
- case KnxNetIpDeviceMemoryAddressPlcField:
- memoryField := field.(KnxNetIpDeviceMemoryAddressPlcField)
- results := m.connection.ReadDeviceMemory(deviceAddress, memoryField.Address, memoryField.NumberOfElements, memoryField.FieldType)
- select {
- case result := <-results:
- responseCodes[fieldName] = result.returnCode
- if result.returnCode == apiModel.PlcResponseCode_OK {
- plcValues[fieldName] = *result.value
- } else {
- plcValues[fieldName] = nil
- }
- case <-time.After(m.connection.defaultTtl):
- responseCodes[fieldName] = apiModel.PlcResponseCode_REMOTE_BUSY
- plcValues[fieldName] = nil
- }
- }
- }
- }
+ results := m.connection.ReadDeviceProperty(deviceAddress, propertyField.ObjectId, propertyField.PropertyId)
+ select {
+ case result := <-results:
+ responseCodes[fieldName] = result.returnCode
+ if result.returnCode == apiModel.PlcResponseCode_OK {
+ plcValues[fieldName] = *result.value
+ } else {
+ plcValues[fieldName] = nil
+ }
+ case <-time.After(m.connection.defaultTtl):
+ responseCodes[fieldName] = apiModel.PlcResponseCode_REMOTE_BUSY
+ plcValues[fieldName] = nil
+ }
+ case KnxNetIpDeviceMemoryAddressPlcField:
+ memoryField := field.(KnxNetIpDeviceMemoryAddressPlcField)
+ results := m.connection.ReadDeviceMemory(deviceAddress, memoryField.Address, memoryField.NumberOfElements, memoryField.FieldType)
+ select {
+ case result := <-results:
+ responseCodes[fieldName] = result.returnCode
+ if result.returnCode == apiModel.PlcResponseCode_OK {
+ plcValues[fieldName] = *result.value
+ } else {
+ plcValues[fieldName] = nil
+ }
+ case <-time.After(m.connection.defaultTtl):
+ responseCodes[fieldName] = apiModel.PlcResponseCode_REMOTE_BUSY
+ plcValues[fieldName] = nil
+ }
+ }
+ }
+ }
- // Get the group address values from the cache
- for fieldName, field := range groupAddresses {
- responseCode, plcValue := m.readGroupAddress(field)
- responseCodes[fieldName] = responseCode
- plcValues[fieldName] = plcValue
- }
+ // Get the group address values from the cache
+ for fieldName, field := range groupAddresses {
+ responseCode, plcValue := m.readGroupAddress(field)
+ responseCodes[fieldName] = responseCode
+ plcValues[fieldName] = plcValue
+ }
- // Assemble the results
- result := internalModel.NewDefaultPlcReadResponse(readRequest, responseCodes, plcValues)
- resultChan <- apiModel.PlcReadRequestResult{
- Request: readRequest,
- Response: result,
- Err: nil,
- }
- }()
- return resultChan
+ // Assemble the results
+ result := internalModel.NewDefaultPlcReadResponse(readRequest, responseCodes, plcValues)
+ resultChan <- apiModel.PlcReadRequestResult{
+ Request: readRequest,
+ Response: result,
+ Err: nil,
+ }
+ }()
+ return resultChan
}
func (m KnxNetIpReader) readGroupAddress(field KnxNetIpGroupAddressField) (apiModel.PlcResponseCode, apiValues.PlcValue) {
- // Pattern fields can match more than one value, therefore we have to handle things differently
- if field.IsPatternField() {
- // Depending on the type of field, get the uint16 ids of all values that match the current field
- matchedAddresses := map[uint16]*driverModel.KnxGroupAddress{}
- switch field.(type) {
- case KnxNetIpGroupAddress3LevelPlcField:
- for key, value := range m.connection.leve3AddressCache {
- if field.matches(value.Parent) {
- matchedAddresses[key] = value.Parent
- }
- }
- case KnxNetIpGroupAddress2LevelPlcField:
- for key, value := range m.connection.leve2AddressCache {
- if field.matches(value.Parent) {
- matchedAddresses[key] = value.Parent
- }
- }
- case KnxNetIpGroupAddress1LevelPlcField:
- for key, value := range m.connection.leve1AddressCache {
- if field.matches(value.Parent) {
- matchedAddresses[key] = value.Parent
- }
- }
- }
+ rawAddresses, err := m.resolveAddresses(field)
+ if err != nil {
+ return apiModel.PlcResponseCode_INVALID_ADDRESS, nil
+ }
- // If not a single match was found, we'll return a "not found" message
- if len(matchedAddresses) == 0 {
- return apiModel.PlcResponseCode_NOT_FOUND, nil
- }
+ // First resolve any pattern to a list of fully qualified group addresses.
+ // Then check if any of them is available in the local value cache,
+ // if not send a group address read-request.
+ values := map[string]apiValues.PlcValue{}
+ returnCodes := map[string]apiModel.PlcResponseCode{}
+ for _, numericAddress := range rawAddresses {
+ // Create a string representation of this numeric address depending on the type of requested address
+ stringAddress := NumericGroupAddressToString(numericAddress, field)
- // Go through all of the values and create a plc-struct from them
- // where the string version of the address becomes the property name
- // and the property value is the corresponding value (Other wise it
- // would be impossible to know which of the fields the pattern matched
- // a given value belongs to)
- values := map[string]apiValues.PlcValue{}
- for numericAddress, address := range matchedAddresses {
- // Get the raw data from the cache
- m.connection.valueCacheMutex.RLock()
- int8s, _ := m.connection.valueCache[numericAddress]
- m.connection.valueCacheMutex.RUnlock()
+ // Try to get a value from the cache
+ m.connection.valueCacheMutex.RLock()
+ int8s, ok := m.connection.valueCache[numericAddress]
+ m.connection.valueCacheMutex.RUnlock()
- // If we don't have any field-type information, add the raw data
- if field.GetTypeName() == "" {
- values[GroupAddressToString(address)] =
- internalValues.NewPlcByteArray(utils.Int8ArrayToByteArray(int8s))
- } else {
- // Decode the data according to the fields type
- rb := utils.NewReadBuffer(utils.Int8ArrayToUint8Array(int8s))
- if field.GetFieldType() == nil {
- return apiModel.PlcResponseCode_INVALID_DATATYPE, nil
- }
- // If the size of the field is greater than 6, we have to skip the first byte
- if field.GetFieldType().LengthInBits() > 6 {
- _, _ = rb.ReadUint8(8)
- }
- plcValue, err := driverModel.KnxDatapointParse(rb, *field.GetFieldType())
- // If any of the values doesn't decode correctly, we can't return any
- if err != nil {
- return apiModel.PlcResponseCode_INVALID_DATA, nil
- }
- values[GroupAddressToString(address)] = plcValue
- }
- }
+ // If nothing was found in the cache, try to execute a group address read,
+ // Otherwise respond with values from the cache.
+ if !ok {
+ addr := []int8{int8(numericAddress >> 8), int8(numericAddress & 0xFF)}
+ rrc := m.connection.ReadGroupAddress(addr, field.GetFieldType())
+ select {
+ case readResult := <-rrc:
+ if readResult.value != nil {
+ values[stringAddress] = *readResult.value
+ returnCodes[stringAddress] = readResult.returnCode
+ } else {
+ values[stringAddress] = nil
+ returnCodes[stringAddress] = apiModel.PlcResponseCode_NOT_FOUND
+ }
+ }
+ } else {
+ // If we don't have any field-type information, add the raw data
+ if field.GetTypeName() == "" {
+ values[stringAddress] = internalValues.NewPlcByteArray(utils.Int8ArrayToByteArray(int8s))
+ } else {
+ // Decode the data according to the fields type
+ rb := utils.NewReadBuffer(utils.Int8ArrayToUint8Array(int8s))
+ if field.GetFieldType() == nil {
+ return apiModel.PlcResponseCode_INVALID_DATATYPE, nil
+ }
+ // If the size of the field is greater than 6, we have to skip the first byte
+ if field.GetFieldType().LengthInBits() > 6 {
+ _, _ = rb.ReadUint8(8)
+ }
+ plcValue, err := driverModel.KnxDatapointParse(rb, *field.GetFieldType())
+ // If any of the values doesn't decode correctly, we can't return any
+ if err != nil {
+ return apiModel.PlcResponseCode_INVALID_DATA, nil
+ }
+ values[stringAddress] = plcValue
+ }
+ }
+ }
- // Add it to the result
- return apiModel.PlcResponseCode_OK, internalValues.NewPlcStruct(values)
- } else {
- // If it's not a pattern field, we can access the cached value a lot simpler
-
- // Serialize the field to an uint16
- wb := utils.NewWriteBuffer()
- err := field.toGroupAddress().Serialize(*wb)
- if err != nil {
- return apiModel.PlcResponseCode_INVALID_ADDRESS, nil
- }
- rawAddress := wb.GetBytes()
- address := (uint16(rawAddress[0]) << 8) | uint16(rawAddress[1]&0xFF)
+ // If there is only one address to read, return this directly.
+ // Otherwise return a struct, with the keys being the string representations of the address.
+ if len(rawAddresses) == 1 {
+ stringAddress := NumericGroupAddressToString(rawAddresses[0], field)
+ return apiModel.PlcResponseCode_OK, values[stringAddress]
+ } else if len(rawAddresses) > 1 {
+ // Add it to the result
+ return apiModel.PlcResponseCode_OK, internalValues.NewPlcStruct(values)
+ } else {
+ // Add it to the result
+ return apiModel.PlcResponseCode_NOT_FOUND, nil
+ }
+}
- // Get the value form the cache
- m.connection.valueCacheMutex.RLock()
- int8s, ok := m.connection.valueCache[address]
- m.connection.valueCacheMutex.RUnlock()
- if !ok {
- return apiModel.PlcResponseCode_NOT_FOUND, nil
- }
+// If the given field is a field containing a pattern, resolve to all the possible addresses
+// it could be referring to.
+func (m KnxNetIpReader) resolveAddresses(field KnxNetIpGroupAddressField) ([]uint16, error) {
+ // Depending on the type of field, get the uint16 ids of all values that match the current field
+ var result []uint16
+ switch field.(type) {
+ case KnxNetIpGroupAddress3LevelPlcField:
+ address3LevelPlcField := field.(KnxNetIpGroupAddress3LevelPlcField)
+ mainSegmentValues, err := m.resoleSegment(address3LevelPlcField.MainGroup, 0, 31)
+ if err != nil {
+ return []uint16{}, err
+ }
+ middleSegmentValues, err := m.resoleSegment(address3LevelPlcField.MiddleGroup, 0, 7)
+ if err != nil {
+ return []uint16{}, err
+ }
+ subSegmentValues, err := m.resoleSegment(address3LevelPlcField.SubGroup, 0, 255)
+ if err != nil {
+ return []uint16{}, err
+ }
+ for _, main := range mainSegmentValues {
+ for _, middle := range middleSegmentValues {
+ for _, sub := range subSegmentValues {
+ result = append(result, main<<11|middle<<8|sub)
+ }
+ }
+ }
+ case KnxNetIpGroupAddress2LevelPlcField:
+ address2LevelPlcField := field.(KnxNetIpGroupAddress2LevelPlcField)
+ mainSegmentValues, err := m.resoleSegment(address2LevelPlcField.MainGroup, 0, 31)
+ if err != nil {
+ return []uint16{}, err
+ }
+ subSegmentValues, err := m.resoleSegment(address2LevelPlcField.SubGroup, 0, 2047)
+ if err != nil {
+ return []uint16{}, err
+ }
+ for _, main := range mainSegmentValues {
+ for _, sub := range subSegmentValues {
+ result = append(result, main<<11|sub)
+ }
+ }
+ case KnxNetIpGroupAddress1LevelPlcField:
+ address1LevelPlcField := field.(KnxNetIpGroupAddress1LevelPlcField)
+ mainSegmentValues, err := m.resoleSegment(address1LevelPlcField.MainGroup, 0, 65535)
+ if err != nil {
+ return []uint16{}, err
+ }
+ for _, main := range mainSegmentValues {
+ result = append(result, main)
+ }
+ }
+ return result, nil
+}
- // Decode the data according to the fields type
- rb := utils.NewReadBuffer(utils.Int8ArrayToUint8Array(int8s))
- if field.GetFieldType() == nil {
- return apiModel.PlcResponseCode_INVALID_DATATYPE, nil
- }
- // If the size of the field is greater than 6, we have to skip the first byte
- if field.GetFieldType().LengthInBits() > 6 {
- _, _ = rb.ReadUint8(8)
- }
- plcValue, err := driverModel.KnxDatapointParse(rb, *field.GetFieldType())
- if err != nil {
- return apiModel.PlcResponseCode_INVALID_DATA, nil
- }
+func (m KnxNetIpReader) resoleSegment(pattern string, minValue uint16, maxValue uint16) ([]uint16, error) {
+ var results []uint16
+ // A "*" simply matches everything
+ if pattern == "*" {
+ for i := minValue; i <= maxValue; i++ {
+ results = append(results, i)
+ }
+ } else if strings.HasPrefix(pattern, "[") && strings.HasSuffix(pattern, "]") {
+ // If the pattern starts and ends with square brackets, it's a list of values or range queries
+ // Multiple options are separated by ","
+ for _, segment := range strings.Split(pattern[1:len(pattern)-1], ",") {
+ // If the segment contains a "-", then it's a range query,
+ // otherwise it's just a normal value.
+ if strings.Contains(segment, "-") {
+ split := strings.Split(segment, "-")
+ if len(split) == 2 {
+ minValue, err := strconv.Atoi(split[0])
+ if err != nil {
+ return []uint16{}, errors.New("invalid address")
+ }
+ maxValue, err := strconv.Atoi(split[1])
+ if err != nil {
+ return []uint16{}, errors.New("invalid address")
+ }
+ for i := uint16(minValue); i <= uint16(maxValue); i++ {
+ results = append(results, i)
+ }
+ } else {
+ return []uint16{}, errors.New("invalid address")
+ }
+ } else {
+ value, err := strconv.Atoi(segment)
+ if err != nil {
+ return []uint16{}, errors.New("invalid address")
+ }
+ results = append(results, uint16(value))
+ }
+ }
+ } else {
+ value, err := strconv.Atoi(pattern)
+ if err != nil {
+ return []uint16{}, errors.New("invalid address")
+ }
+ results = append(results, uint16(value))
+ }
- // Add it to the result
- return apiModel.PlcResponseCode_OK, plcValue
- }
+ return results, nil
}
diff --git a/plc4go/internal/plc4go/knxnetip/KnxNetIpSubscriber.go b/plc4go/internal/plc4go/knxnetip/KnxNetIpSubscriber.go
index 967e632..4a530de 100644
--- a/plc4go/internal/plc4go/knxnetip/KnxNetIpSubscriber.go
+++ b/plc4go/internal/plc4go/knxnetip/KnxNetIpSubscriber.go
@@ -77,98 +77,76 @@ func (m *KnxNetIpSubscriber) Unsubscribe(unsubscriptionRequest apiModel.PlcUnsub
/*
* Callback for incoming value change events from the KNX bus
*/
-func (m *KnxNetIpSubscriber) handleValueChange(lDataFrame *driverModel.LDataFrame, changed bool) {
- var destinationAddress []int8
- var apdu *driverModel.Apdu
- switch lDataFrame.Child.(type) {
- case *driverModel.LDataExtended:
- dataFrame := driverModel.CastLDataExtended(lDataFrame)
- destinationAddress = dataFrame.DestinationAddress
- apdu = dataFrame.Apdu
+func (m *KnxNetIpSubscriber) handleValueChange(destinationAddress []int8, payload []int8, changed bool) {
+ // Decode the group-address according to the settings in the driver
+ // Group addresses can be 1, 2 or 3 levels (3 being the default)
+ garb := utils.NewReadBuffer(utils.Int8ArrayToUint8Array(destinationAddress))
+ groupAddress, err := driverModel.KnxGroupAddressParse(garb, m.connection.getGroupAddressNumLevels())
+ if err != nil {
+ return
}
- container := driverModel.CastApduDataContainer(apdu)
- if container == nil {
- return
- }
- groupValueWrite := driverModel.CastApduDataGroupValueWrite(container.DataApdu)
- if groupValueWrite == nil {
- return
- }
- if destinationAddress != nil {
- // Decode the group-address according to the settings in the driver
- // Group addresses can be 1, 2 or 3 levels (3 being the default)
- garb := utils.NewReadBuffer(utils.Int8ArrayToUint8Array(destinationAddress))
- groupAddress, err := driverModel.KnxGroupAddressParse(garb, m.connection.getGroupAddressNumLevels())
- if err != nil {
- return
- }
-
- // Go through all subscription-requests and process each separately
- for _, subscriptionRequest := range m.subscriptionRequests {
- fields := map[string]apiModel.PlcField{}
- types := map[string]internalModel.SubscriptionType{}
- intervals := map[string]time.Duration{}
- responseCodes := map[string]apiModel.PlcResponseCode{}
- addresses := map[string][]int8{}
- plcValues := map[string]values.PlcValue{}
+ // Go through all subscription-requests and process each separately
+ for _, subscriptionRequest := range m.subscriptionRequests {
+ fields := map[string]apiModel.PlcField{}
+ types := map[string]internalModel.SubscriptionType{}
+ intervals := map[string]time.Duration{}
+ responseCodes := map[string]apiModel.PlcResponseCode{}
+ addresses := map[string][]int8{}
+ plcValues := map[string]values.PlcValue{}
- // Check if this datagram matches any address in this subscription request
- // As depending on the address used for fields, the decoding is different, we need to decode on-demand here.
- for _, fieldName := range subscriptionRequest.GetFieldNames() {
- field, err := CastToKnxNetIpFieldFromPlcField(subscriptionRequest.GetField(fieldName))
- if err != nil {
- continue
+ // Check if this datagram matches any address in this subscription request
+ // As depending on the address used for fields, the decoding is different, we need to decode on-demand here.
+ for _, fieldName := range subscriptionRequest.GetFieldNames() {
+ field, err := CastToKnxNetIpFieldFromPlcField(subscriptionRequest.GetField(fieldName))
+ if err != nil {
+ continue
+ }
+ switch field.(type) {
+ case KnxNetIpGroupAddressField:
+ subscriptionType := subscriptionRequest.GetType(fieldName)
+ groupAddressField := field.(KnxNetIpGroupAddressField)
+ // If it matches, take the datatype of each matching field and try to decode the payload
+ if groupAddressField.matches(groupAddress) {
+ // If this is a CHANGE_OF_STATE field, filter out the events where the value actually hasn't changed.
+ if subscriptionType == internalModel.SUBSCRIPTION_CHANGE_OF_STATE && changed {
+ rb := utils.NewReadBuffer(utils.Int8ArrayToByteArray(payload))
+ if groupAddressField.GetFieldType() == nil {
+ responseCodes[fieldName] = apiModel.PlcResponseCode_INVALID_DATATYPE
+ plcValues[fieldName] = nil
+ continue
+ }
+ // If the size of the field is greater than 6, we have to skip the first byte
+ if groupAddressField.GetFieldType().LengthInBits() > 6 {
+ _, _ = rb.ReadUint8(8)
+ }
+ plcValue, err2 := driverModel.KnxDatapointParse(rb, *groupAddressField.GetFieldType())
+ fields[fieldName] = field
+ types[fieldName] = subscriptionRequest.GetType(fieldName)
+ intervals[fieldName] = subscriptionRequest.GetInterval(fieldName)
+ addresses[fieldName] = destinationAddress
+ if err2 == nil {
+ responseCodes[fieldName] = apiModel.PlcResponseCode_OK
+ plcValues[fieldName] = plcValue
+ } else {
+ // TODO: Do a little more here ...
+ responseCodes[fieldName] = apiModel.PlcResponseCode_INTERNAL_ERROR
+ plcValues[fieldName] = nil
+ }
+ }
}
- switch field.(type) {
- case KnxNetIpGroupAddressField:
- subscriptionType := subscriptionRequest.GetType(fieldName)
- groupAddressField := field.(KnxNetIpGroupAddressField)
- // If it matches, take the datatype of each matching field and try to decode the payload
- if groupAddressField.matches(groupAddress) {
- // If this is a CHANGE_OF_STATE field, filter out the events where the value actually hasn't changed.
- if subscriptionType == internalModel.SUBSCRIPTION_CHANGE_OF_STATE && changed {
- var payload []int8
- payload = append(payload, groupValueWrite.DataFirstByte)
- payload = append(payload, groupValueWrite.Data...)
- rb := utils.NewReadBuffer(utils.Int8ArrayToByteArray(payload))
- if groupAddressField.GetFieldType() == nil {
- responseCodes[fieldName] = apiModel.PlcResponseCode_INVALID_DATATYPE
- plcValues[fieldName] = nil
- continue
- }
- // If the size of the field is greater than 6, we have to skip the first byte
- if groupAddressField.GetFieldType().LengthInBits() > 6 {
- _, _ = rb.ReadUint8(8)
- }
- plcValue, err2 := driverModel.KnxDatapointParse(rb, *groupAddressField.GetFieldType())
- fields[fieldName] = field
- types[fieldName] = subscriptionRequest.GetType(fieldName)
- intervals[fieldName] = subscriptionRequest.GetInterval(fieldName)
- addresses[fieldName] = destinationAddress
- if err2 == nil {
- responseCodes[fieldName] = apiModel.PlcResponseCode_OK
- plcValues[fieldName] = plcValue
- } else {
- // TODO: Do a little more here ...
- responseCodes[fieldName] = apiModel.PlcResponseCode_INTERNAL_ERROR
- plcValues[fieldName] = nil
- }
- }
- }
- default:
- responseCodes[fieldName] = apiModel.PlcResponseCode_INVALID_ADDRESS
- plcValues[fieldName] = nil
- }
+ default:
+ responseCodes[fieldName] = apiModel.PlcResponseCode_INVALID_ADDRESS
+ plcValues[fieldName] = nil
}
+ }
- // Assemble a PlcSubscription event
- if len(plcValues) > 0 {
- event := NewKnxNetIpSubscriptionEvent(
- fields, types, intervals, responseCodes, addresses, plcValues)
- eventHandler := subscriptionRequest.GetEventHandler()
- eventHandler(event)
- }
+ // Assemble a PlcSubscription event
+ if len(plcValues) > 0 {
+ event := NewKnxNetIpSubscriptionEvent(
+ fields, types, intervals, responseCodes, addresses, plcValues)
+ eventHandler := subscriptionRequest.GetEventHandler()
+ eventHandler(event)
}
}
}
diff --git a/plc4go/internal/plc4go/knxnetip/Utils.go b/plc4go/internal/plc4go/knxnetip/Utils.go
index 110c9c7..54ef154 100644
--- a/plc4go/internal/plc4go/knxnetip/Utils.go
+++ b/plc4go/internal/plc4go/knxnetip/Utils.go
@@ -24,6 +24,25 @@ import (
"strconv"
)
+func NumericGroupAddressToString(numericAddress uint16, groupAddress KnxNetIpGroupAddressField) string {
+ if groupAddress != nil {
+ switch groupAddress.(type) {
+ case KnxNetIpGroupAddress3LevelPlcField:
+ main := numericAddress >> 11
+ middle := (numericAddress >> 8) & 0x07
+ sub := numericAddress & 0xFF
+ return strconv.Itoa(int(main)) + "/" + strconv.Itoa(int(middle)) + "/" + strconv.Itoa(int(sub))
+ case KnxNetIpGroupAddress2LevelPlcField:
+ main := numericAddress >> 11
+ sub := numericAddress & 0x07FF
+ return strconv.Itoa(int(main)) + "/" + strconv.Itoa(int(sub))
+ case KnxNetIpGroupAddress1LevelPlcField:
+ return strconv.Itoa(int(numericAddress))
+ }
+ }
+ return ""
+}
+
func GroupAddressToString(groupAddress *driverModel.KnxGroupAddress) string {
if groupAddress != nil {
switch groupAddress.Child.(type) {
@@ -58,26 +77,25 @@ func KnxAddressToInt8Array(knxAddress driverModel.KnxAddress) []int8 {
}
func Uint16ToKnxAddress(data uint16) *driverModel.KnxAddress {
- main := uint8(data >> 12)
- middle := uint8(data >> 8) & 0xF
- sub := uint8(data & 0xFF)
- knxAddress := driverModel.KnxAddress{
- MainGroup: main,
- MiddleGroup: middle,
- SubGroup: sub,
- }
- return &knxAddress
+ main := uint8(data >> 12)
+ middle := uint8(data>>8) & 0xF
+ sub := uint8(data & 0xFF)
+ knxAddress := driverModel.KnxAddress{
+ MainGroup: main,
+ MiddleGroup: middle,
+ SubGroup: sub,
+ }
+ return &knxAddress
}
func Uint16ToKnxGroupAddress(data uint16, numLevels uint8) *driverModel.KnxGroupAddress {
- rawData := make([]uint8, 2)
- rawData[0] = uint8(data >> 8)
- rawData[1] = uint8(data & 0xFF)
- readBuffer := utils.NewReadBuffer(rawData)
- knxGroupAddress, err := driverModel.KnxGroupAddressParse(readBuffer, numLevels)
- if err != nil {
- return nil
- }
- return knxGroupAddress
+ rawData := make([]uint8, 2)
+ rawData[0] = uint8(data >> 8)
+ rawData[1] = uint8(data & 0xFF)
+ readBuffer := utils.NewReadBuffer(rawData)
+ knxGroupAddress, err := driverModel.KnxGroupAddressParse(readBuffer, numLevels)
+ if err != nil {
+ return nil
+ }
+ return knxGroupAddress
}
-
diff --git a/plc4go/internal/plc4go/knxnetip/readwrite/model/ApduData.go b/plc4go/internal/plc4go/knxnetip/readwrite/model/ApduData.go
index 56ab5aa..e9bcf98 100644
--- a/plc4go/internal/plc4go/knxnetip/readwrite/model/ApduData.go
+++ b/plc4go/internal/plc4go/knxnetip/readwrite/model/ApduData.go
@@ -19,386 +19,385 @@
package model
import (
- "encoding/xml"
- "errors"
- "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
- "io"
- "reflect"
- "strings"
+ "encoding/xml"
+ "errors"
+ "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+ "io"
+ "reflect"
+ "strings"
)
// The data-structure of this message
type ApduData struct {
- Child IApduDataChild
- IApduData
- IApduDataParent
+ Child IApduDataChild
+ IApduData
+ IApduDataParent
}
// The corresponding interface
type IApduData interface {
- ApciType() uint8
- LengthInBytes() uint16
- LengthInBits() uint16
- Serialize(io utils.WriteBuffer) error
- xml.Marshaler
+ ApciType() uint8
+ LengthInBytes() uint16
+ LengthInBits() uint16
+ Serialize(io utils.WriteBuffer) error
+ xml.Marshaler
}
type IApduDataParent interface {
- SerializeParent(io utils.WriteBuffer, child IApduData, serializeChildFunction func() error) error
- GetTypeName() string
+ SerializeParent(io utils.WriteBuffer, child IApduData, serializeChildFunction func() error) error
+ GetTypeName() string
}
type IApduDataChild interface {
- Serialize(io utils.WriteBuffer) error
- InitializeParent(parent *ApduData)
- GetTypeName() string
- IApduData
+ Serialize(io utils.WriteBuffer) error
+ InitializeParent(parent *ApduData)
+ GetTypeName() string
+ IApduData
}
func NewApduData() *ApduData {
- return &ApduData{}
+ return &ApduData{}
}
func CastApduData(structType interface{}) *ApduData {
- castFunc := func(typ interface{}) *ApduData {
- if casted, ok := typ.(ApduData); ok {
- return &casted
- }
- if casted, ok := typ.(*ApduData); ok {
- return casted
- }
- return nil
- }
- return castFunc(structType)
+ castFunc := func(typ interface{}) *ApduData {
+ if casted, ok := typ.(ApduData); ok {
+ return &casted
+ }
+ if casted, ok := typ.(*ApduData); ok {
+ return casted
+ }
+ return nil
+ }
+ return castFunc(structType)
}
func (m *ApduData) GetTypeName() string {
- return "ApduData"
+ return "ApduData"
}
func (m *ApduData) LengthInBits() uint16 {
- lengthInBits := uint16(0)
+ lengthInBits := uint16(0)
- // Discriminator Field (apciType)
- lengthInBits += 4
+ // Discriminator Field (apciType)
+ lengthInBits += 4
- // Length of sub-type elements will be added by sub-type...
- lengthInBits += m.Child.LengthInBits()
+ // Length of sub-type elements will be added by sub-type...
+ lengthInBits += m.Child.LengthInBits()
- return lengthInBits
+ return lengthInBits
}
func (m *ApduData) LengthInBytes() uint16 {
- return m.LengthInBits() / 8
+ return m.LengthInBits() / 8
}
func ApduDataParse(io *utils.ReadBuffer, dataLength uint8) (*ApduData, error) {
- // Discriminator Field (apciType) (Used as input to a switch field)
- apciType, _apciTypeErr := io.ReadUint8(4)
- if _apciTypeErr != nil {
- return nil, errors.New("Error parsing 'apciType' field " + _apciTypeErr.Error())
- }
+ // Discriminator Field (apciType) (Used as input to a switch field)
+ apciType, _apciTypeErr := io.ReadUint8(4)
+ if _apciTypeErr != nil {
+ return nil, errors.New("Error parsing 'apciType' field " + _apciTypeErr.Error())
+ }
- // Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type)
- var _parent *ApduData
- var typeSwitchError error
- switch {
- case apciType == 0x0:
- _parent, typeSwitchError = ApduDataGroupValueReadParse(io)
- case apciType == 0x1:
- _parent, typeSwitchError = ApduDataGroupValueResponseParse(io)
- case apciType == 0x2:
- _parent, typeSwitchError = ApduDataGroupValueWriteParse(io, dataLength)
- case apciType == 0x3:
- _parent, typeSwitchError = ApduDataIndividualAddressWriteParse(io)
- case apciType == 0x4:
- _parent, typeSwitchError = ApduDataIndividualAddressReadParse(io)
- case apciType == 0x5:
- _parent, typeSwitchError = ApduDataIndividualAddressResponseParse(io)
- case apciType == 0x6:
- _parent, typeSwitchError = ApduDataAdcReadParse(io)
- case apciType == 0x7:
- _parent, typeSwitchError = ApduDataAdcResponseParse(io)
- case apciType == 0x8:
- _parent, typeSwitchError = ApduDataMemoryReadParse(io)
- case apciType == 0x9:
- _parent, typeSwitchError = ApduDataMemoryResponseParse(io)
- case apciType == 0xA:
- _parent, typeSwitchError = ApduDataMemoryWriteParse(io)
- case apciType == 0xB:
- _parent, typeSwitchError = ApduDataUserMessageParse(io)
- case apciType == 0xC:
- _parent, typeSwitchError = ApduDataDeviceDescriptorReadParse(io)
- case apciType == 0xD:
- _parent, typeSwitchError = ApduDataDeviceDescriptorResponseParse(io, dataLength)
- case apciType == 0xE:
- _parent, typeSwitchError = ApduDataRestartParse(io)
- case apciType == 0xF:
- _parent, typeSwitchError = ApduDataOtherParse(io, dataLength)
- }
- if typeSwitchError != nil {
- return nil, errors.New("Error parsing sub-type for type-switch. " + typeSwitchError.Error())
- }
+ // Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type)
+ var _parent *ApduData
+ var typeSwitchError error
+ switch {
+ case apciType == 0x0:
+ _parent, typeSwitchError = ApduDataGroupValueReadParse(io)
+ case apciType == 0x1:
+ _parent, typeSwitchError = ApduDataGroupValueResponseParse(io, dataLength)
+ case apciType == 0x2:
+ _parent, typeSwitchError = ApduDataGroupValueWriteParse(io, dataLength)
+ case apciType == 0x3:
+ _parent, typeSwitchError = ApduDataIndividualAddressWriteParse(io)
+ case apciType == 0x4:
+ _parent, typeSwitchError = ApduDataIndividualAddressReadParse(io)
+ case apciType == 0x5:
+ _parent, typeSwitchError = ApduDataIndividualAddressResponseParse(io)
+ case apciType == 0x6:
+ _parent, typeSwitchError = ApduDataAdcReadParse(io)
+ case apciType == 0x7:
+ _parent, typeSwitchError = ApduDataAdcResponseParse(io)
+ case apciType == 0x8:
+ _parent, typeSwitchError = ApduDataMemoryReadParse(io)
+ case apciType == 0x9:
+ _parent, typeSwitchError = ApduDataMemoryResponseParse(io)
+ case apciType == 0xA:
+ _parent, typeSwitchError = ApduDataMemoryWriteParse(io)
+ case apciType == 0xB:
+ _parent, typeSwitchError = ApduDataUserMessageParse(io)
+ case apciType == 0xC:
+ _parent, typeSwitchError = ApduDataDeviceDescriptorReadParse(io)
+ case apciType == 0xD:
+ _parent, typeSwitchError = ApduDataDeviceDescriptorResponseParse(io, dataLength)
+ case apciType == 0xE:
+ _parent, typeSwitchError = ApduDataRestartParse(io)
+ case apciType == 0xF:
+ _parent, typeSwitchError = ApduDataOtherParse(io, dataLength)
+ }
+ if typeSwitchError != nil {
+ return nil, errors.New("Error parsing sub-type for type-switch. " + typeSwitchError.Error())
+ }
- // Finish initializing
- _parent.Child.InitializeParent(_parent)
- return _parent, nil
+ // Finish initializing
+ _parent.Child.InitializeParent(_parent)
+ return _parent, nil
}
func (m *ApduData) Serialize(io utils.WriteBuffer) error {
- return m.Child.Serialize(io)
+ return m.Child.Serialize(io)
}
func (m *ApduData) SerializeParent(io utils.WriteBuffer, child IApduData, serializeChildFunction func() error) error {
- // Discriminator Field (apciType) (Used as input to a switch field)
- apciType := uint8(child.ApciType())
- _apciTypeErr := io.WriteUint8(4, (apciType))
- if _apciTypeErr != nil {
- return errors.New("Error serializing 'apciType' field " + _apciTypeErr.Error())
- }
+ // Discriminator Field (apciType) (Used as input to a switch field)
+ apciType := uint8(child.ApciType())
+ _apciTypeErr := io.WriteUint8(4, (apciType))
+ if _apciTypeErr != nil {
+ return errors.New("Error serializing 'apciType' field " + _apciTypeErr.Error())
+ }
- // Switch field (Depending on the discriminator values, passes the serialization to a sub-type)
- _typeSwitchErr := serializeChildFunction()
- if _typeSwitchErr != nil {
- return errors.New("Error serializing sub-type field " + _typeSwitchErr.Error())
- }
+ // Switch field (Depending on the discriminator values, passes the serialization to a sub-type)
+ _typeSwitchErr := serializeChildFunction()
+ if _typeSwitchErr != nil {
+ return errors.New("Error serializing sub-type field " + _typeSwitchErr.Error())
+ }
- return nil
+ return nil
}
func (m *ApduData) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
- var token xml.Token
- var err error
- for {
- token, err = d.Token()
- if err != nil {
- if err == io.EOF {
- return nil
- }
- return err
- }
- switch token.(type) {
- case xml.StartElement:
- tok := token.(xml.StartElement)
- switch tok.Name.Local {
- default:
- switch start.Attr[0].Value {
- case "org.apache.plc4x.java.knxnetip.readwrite.ApduDataGroupValueRead":
- var dt *ApduDataGroupValueRead
- if m.Child != nil {
- dt = m.Child.(*ApduDataGroupValueRead)
- }
- if err := d.DecodeElement(&dt, &tok); err != nil {
- return err
- }
- if m.Child == nil {
- dt.Parent = m
- m.Child = dt
- }
- case "org.apache.plc4x.java.knxnetip.readwrite.ApduDataGroupValueResponse":
- var dt *ApduDataGroupValueResponse
- if m.Child != nil {
- dt = m.Child.(*ApduDataGroupValueResponse)
- }
- if err := d.DecodeElement(&dt, &tok); err != nil {
- return err
- }
- if m.Child == nil {
- dt.Parent = m
- m.Child = dt
- }
- case "org.apache.plc4x.java.knxnetip.readwrite.ApduDataGroupValueWrite":
- var dt *ApduDataGroupValueWrite
- if m.Child != nil {
- dt = m.Child.(*ApduDataGroupValueWrite)
- }
- if err := d.DecodeElement(&dt, &tok); err != nil {
- return err
- }
- if m.Child == nil {
- dt.Parent = m
- m.Child = dt
- }
- case "org.apache.plc4x.java.knxnetip.readwrite.ApduDataIndividualAddressWrite":
- var dt *ApduDataIndividualAddressWrite
- if m.Child != nil {
- dt = m.Child.(*ApduDataIndividualAddressWrite)
- }
- if err := d.DecodeElement(&dt, &tok); err != nil {
- return err
- }
- if m.Child == nil {
- dt.Parent = m
- m.Child = dt
- }
- case "org.apache.plc4x.java.knxnetip.readwrite.ApduDataIndividualAddressRead":
- var dt *ApduDataIndividualAddressRead
- if m.Child != nil {
- dt = m.Child.(*ApduDataIndividualAddressRead)
- }
- if err := d.DecodeElement(&dt, &tok); err != nil {
- return err
- }
- if m.Child == nil {
- dt.Parent = m
- m.Child = dt
- }
- case "org.apache.plc4x.java.knxnetip.readwrite.ApduDataIndividualAddressResponse":
- var dt *ApduDataIndividualAddressResponse
- if m.Child != nil {
- dt = m.Child.(*ApduDataIndividualAddressResponse)
- }
- if err := d.DecodeElement(&dt, &tok); err != nil {
- return err
- }
- if m.Child == nil {
- dt.Parent = m
- m.Child = dt
- }
- case "org.apache.plc4x.java.knxnetip.readwrite.ApduDataAdcRead":
- var dt *ApduDataAdcRead
- if m.Child != nil {
- dt = m.Child.(*ApduDataAdcRead)
- }
- if err := d.DecodeElement(&dt, &tok); err != nil {
- return err
- }
- if m.Child == nil {
- dt.Parent = m
- m.Child = dt
- }
- case "org.apache.plc4x.java.knxnetip.readwrite.ApduDataAdcResponse":
- var dt *ApduDataAdcResponse
- if m.Child != nil {
- dt = m.Child.(*ApduDataAdcResponse)
- }
- if err := d.DecodeElement(&dt, &tok); err != nil {
- return err
- }
- if m.Child == nil {
- dt.Parent = m
- m.Child = dt
- }
- case "org.apache.plc4x.java.knxnetip.readwrite.ApduDataMemoryRead":
- var dt *ApduDataMemoryRead
- if m.Child != nil {
- dt = m.Child.(*ApduDataMemoryRead)
- }
- if err := d.DecodeElement(&dt, &tok); err != nil {
- return err
- }
- if m.Child == nil {
- dt.Parent = m
- m.Child = dt
- }
- case "org.apache.plc4x.java.knxnetip.readwrite.ApduDataMemoryResponse":
- var dt *ApduDataMemoryResponse
- if m.Child != nil {
- dt = m.Child.(*ApduDataMemoryResponse)
- }
- if err := d.DecodeElement(&dt, &tok); err != nil {
- return err
- }
- if m.Child == nil {
- dt.Parent = m
- m.Child = dt
- }
- case "org.apache.plc4x.java.knxnetip.readwrite.ApduDataMemoryWrite":
- var dt *ApduDataMemoryWrite
- if m.Child != nil {
- dt = m.Child.(*ApduDataMemoryWrite)
- }
- if err := d.DecodeElement(&dt, &tok); err != nil {
- return err
- }
- if m.Child == nil {
- dt.Parent = m
- m.Child = dt
- }
- case "org.apache.plc4x.java.knxnetip.readwrite.ApduDataUserMessage":
- var dt *ApduDataUserMessage
- if m.Child != nil {
- dt = m.Child.(*ApduDataUserMessage)
- }
- if err := d.DecodeElement(&dt, &tok); err != nil {
- return err
- }
- if m.Child == nil {
- dt.Parent = m
- m.Child = dt
- }
- case "org.apache.plc4x.java.knxnetip.readwrite.ApduDataDeviceDescriptorRead":
- var dt *ApduDataDeviceDescriptorRead
- if m.Child != nil {
- dt = m.Child.(*ApduDataDeviceDescriptorRead)
- }
- if err := d.DecodeElement(&dt, &tok); err != nil {
- return err
- }
- if m.Child == nil {
- dt.Parent = m
- m.Child = dt
- }
- case "org.apache.plc4x.java.knxnetip.readwrite.ApduDataDeviceDescriptorResponse":
- var dt *ApduDataDeviceDescriptorResponse
- if m.Child != nil {
- dt = m.Child.(*ApduDataDeviceDescriptorResponse)
- }
- if err := d.DecodeElement(&dt, &tok); err != nil {
- return err
- }
- if m.Child == nil {
- dt.Parent = m
- m.Child = dt
- }
- case "org.apache.plc4x.java.knxnetip.readwrite.ApduDataRestart":
- var dt *ApduDataRestart
- if m.Child != nil {
- dt = m.Child.(*ApduDataRestart)
- }
- if err := d.DecodeElement(&dt, &tok); err != nil {
- return err
- }
- if m.Child == nil {
- dt.Parent = m
- m.Child = dt
- }
- case "org.apache.plc4x.java.knxnetip.readwrite.ApduDataOther":
- var dt *ApduDataOther
- if m.Child != nil {
- dt = m.Child.(*ApduDataOther)
- }
- if err := d.DecodeElement(&dt, &tok); err != nil {
- return err
- }
- if m.Child == nil {
- dt.Parent = m
- m.Child = dt
- }
- }
- }
- }
- }
+ var token xml.Token
+ var err error
+ for {
+ token, err = d.Token()
+ if err != nil {
+ if err == io.EOF {
+ return nil
+ }
+ return err
+ }
+ switch token.(type) {
+ case xml.StartElement:
+ tok := token.(xml.StartElement)
+ switch tok.Name.Local {
+ default:
+ switch start.Attr[0].Value {
+ case "org.apache.plc4x.java.knxnetip.readwrite.ApduDataGroupValueRead":
+ var dt *ApduDataGroupValueRead
+ if m.Child != nil {
+ dt = m.Child.(*ApduDataGroupValueRead)
+ }
+ if err := d.DecodeElement(&dt, &tok); err != nil {
+ return err
+ }
+ if m.Child == nil {
+ dt.Parent = m
+ m.Child = dt
+ }
+ case "org.apache.plc4x.java.knxnetip.readwrite.ApduDataGroupValueResponse":
+ var dt *ApduDataGroupValueResponse
+ if m.Child != nil {
+ dt = m.Child.(*ApduDataGroupValueResponse)
+ }
+ if err := d.DecodeElement(&dt, &tok); err != nil {
+ return err
+ }
+ if m.Child == nil {
+ dt.Parent = m
+ m.Child = dt
+ }
+ case "org.apache.plc4x.java.knxnetip.readwrite.ApduDataGroupValueWrite":
+ var dt *ApduDataGroupValueWrite
+ if m.Child != nil {
+ dt = m.Child.(*ApduDataGroupValueWrite)
+ }
+ if err := d.DecodeElement(&dt, &tok); err != nil {
+ return err
+ }
+ if m.Child == nil {
+ dt.Parent = m
+ m.Child = dt
+ }
+ case "org.apache.plc4x.java.knxnetip.readwrite.ApduDataIndividualAddressWrite":
+ var dt *ApduDataIndividualAddressWrite
+ if m.Child != nil {
+ dt = m.Child.(*ApduDataIndividualAddressWrite)
+ }
+ if err := d.DecodeElement(&dt, &tok); err != nil {
+ return err
+ }
+ if m.Child == nil {
+ dt.Parent = m
+ m.Child = dt
+ }
+ case "org.apache.plc4x.java.knxnetip.readwrite.ApduDataIndividualAddressRead":
+ var dt *ApduDataIndividualAddressRead
+ if m.Child != nil {
+ dt = m.Child.(*ApduDataIndividualAddressRead)
+ }
+ if err := d.DecodeElement(&dt, &tok); err != nil {
+ return err
+ }
+ if m.Child == nil {
+ dt.Parent = m
+ m.Child = dt
+ }
+ case "org.apache.plc4x.java.knxnetip.readwrite.ApduDataIndividualAddressResponse":
+ var dt *ApduDataIndividualAddressResponse
+ if m.Child != nil {
+ dt = m.Child.(*ApduDataIndividualAddressResponse)
+ }
+ if err := d.DecodeElement(&dt, &tok); err != nil {
+ return err
+ }
+ if m.Child == nil {
+ dt.Parent = m
+ m.Child = dt
+ }
+ case "org.apache.plc4x.java.knxnetip.readwrite.ApduDataAdcRead":
+ var dt *ApduDataAdcRead
+ if m.Child != nil {
+ dt = m.Child.(*ApduDataAdcRead)
+ }
+ if err := d.DecodeElement(&dt, &tok); err != nil {
+ return err
+ }
+ if m.Child == nil {
+ dt.Parent = m
+ m.Child = dt
+ }
+ case "org.apache.plc4x.java.knxnetip.readwrite.ApduDataAdcResponse":
+ var dt *ApduDataAdcResponse
+ if m.Child != nil {
+ dt = m.Child.(*ApduDataAdcResponse)
+ }
+ if err := d.DecodeElement(&dt, &tok); err != nil {
+ return err
+ }
+ if m.Child == nil {
+ dt.Parent = m
+ m.Child = dt
+ }
+ case "org.apache.plc4x.java.knxnetip.readwrite.ApduDataMemoryRead":
+ var dt *ApduDataMemoryRead
+ if m.Child != nil {
+ dt = m.Child.(*ApduDataMemoryRead)
+ }
+ if err := d.DecodeElement(&dt, &tok); err != nil {
+ return err
+ }
+ if m.Child == nil {
+ dt.Parent = m
+ m.Child = dt
+ }
+ case "org.apache.plc4x.java.knxnetip.readwrite.ApduDataMemoryResponse":
+ var dt *ApduDataMemoryResponse
+ if m.Child != nil {
+ dt = m.Child.(*ApduDataMemoryResponse)
+ }
+ if err := d.DecodeElement(&dt, &tok); err != nil {
+ return err
+ }
+ if m.Child == nil {
+ dt.Parent = m
+ m.Child = dt
+ }
+ case "org.apache.plc4x.java.knxnetip.readwrite.ApduDataMemoryWrite":
+ var dt *ApduDataMemoryWrite
+ if m.Child != nil {
+ dt = m.Child.(*ApduDataMemoryWrite)
+ }
+ if err := d.DecodeElement(&dt, &tok); err != nil {
+ return err
+ }
+ if m.Child == nil {
+ dt.Parent = m
+ m.Child = dt
+ }
+ case "org.apache.plc4x.java.knxnetip.readwrite.ApduDataUserMessage":
+ var dt *ApduDataUserMessage
+ if m.Child != nil {
+ dt = m.Child.(*ApduDataUserMessage)
+ }
+ if err := d.DecodeElement(&dt, &tok); err != nil {
+ return err
+ }
+ if m.Child == nil {
+ dt.Parent = m
+ m.Child = dt
+ }
+ case "org.apache.plc4x.java.knxnetip.readwrite.ApduDataDeviceDescriptorRead":
+ var dt *ApduDataDeviceDescriptorRead
+ if m.Child != nil {
+ dt = m.Child.(*ApduDataDeviceDescriptorRead)
+ }
+ if err := d.DecodeElement(&dt, &tok); err != nil {
+ return err
+ }
+ if m.Child == nil {
+ dt.Parent = m
+ m.Child = dt
+ }
+ case "org.apache.plc4x.java.knxnetip.readwrite.ApduDataDeviceDescriptorResponse":
+ var dt *ApduDataDeviceDescriptorResponse
+ if m.Child != nil {
+ dt = m.Child.(*ApduDataDeviceDescriptorResponse)
+ }
+ if err := d.DecodeElement(&dt, &tok); err != nil {
+ return err
+ }
+ if m.Child == nil {
+ dt.Parent = m
+ m.Child = dt
+ }
+ case "org.apache.plc4x.java.knxnetip.readwrite.ApduDataRestart":
+ var dt *ApduDataRestart
+ if m.Child != nil {
+ dt = m.Child.(*ApduDataRestart)
+ }
+ if err := d.DecodeElement(&dt, &tok); err != nil {
+ return err
+ }
+ if m.Child == nil {
+ dt.Parent = m
+ m.Child = dt
+ }
+ case "org.apache.plc4x.java.knxnetip.readwrite.ApduDataOther":
+ var dt *ApduDataOther
+ if m.Child != nil {
+ dt = m.Child.(*ApduDataOther)
+ }
+ if err := d.DecodeElement(&dt, &tok); err != nil {
+ return err
+ }
+ if m.Child == nil {
+ dt.Parent = m
+ m.Child = dt
+ }
+ }
+ }
+ }
+ }
}
func (m *ApduData) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
- className := reflect.TypeOf(m.Child).String()
- className = "org.apache.plc4x.java.knxnetip.readwrite." + className[strings.LastIndex(className, ".") + 1:]
- if err := e.EncodeToken(xml.StartElement{Name: start.Name, Attr: []xml.Attr{
- {Name: xml.Name{Local: "className"}, Value: className},
- }}); err != nil {
- return err
- }
- marshaller, ok := m.Child.(xml.Marshaler)
- if !ok {
- return errors.New("child is not castable to Marshaler")
- }
- marshaller.MarshalXML(e, start)
- if err := e.EncodeToken(xml.EndElement{Name: start.Name}); err != nil {
- return err
- }
- return nil
+ className := reflect.TypeOf(m.Child).String()
+ className = "org.apache.plc4x.java.knxnetip.readwrite." + className[strings.LastIndex(className, ".")+1:]
+ if err := e.EncodeToken(xml.StartElement{Name: start.Name, Attr: []xml.Attr{
+ {Name: xml.Name{Local: "className"}, Value: className},
+ }}); err != nil {
+ return err
+ }
+ marshaller, ok := m.Child.(xml.Marshaler)
+ if !ok {
+ return errors.New("child is not castable to Marshaler")
+ }
+ marshaller.MarshalXML(e, start)
+ if err := e.EncodeToken(xml.EndElement{Name: start.Name}); err != nil {
+ return err
+ }
+ return nil
}
-
diff --git a/plc4go/internal/plc4go/knxnetip/readwrite/model/ApduDataGroupValueRead.go b/plc4go/internal/plc4go/knxnetip/readwrite/model/ApduDataGroupValueRead.go
index cdffdaa..c4774ad 100644
--- a/plc4go/internal/plc4go/knxnetip/readwrite/model/ApduDataGroupValueRead.go
+++ b/plc4go/internal/plc4go/knxnetip/readwrite/model/ApduDataGroupValueRead.go
@@ -19,117 +19,142 @@
package model
import (
- "encoding/xml"
- "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
- "io"
+ "encoding/xml"
+ "errors"
+ "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+ log "github.com/sirupsen/logrus"
+ "io"
)
// The data-structure of this message
type ApduDataGroupValueRead struct {
- Parent *ApduData
- IApduDataGroupValueRead
+ Parent *ApduData
+ IApduDataGroupValueRead
}
// The corresponding interface
type IApduDataGroupValueRead interface {
- LengthInBytes() uint16
- LengthInBits() uint16
- Serialize(io utils.WriteBuffer) error
- xml.Marshaler
+ LengthInBytes() uint16
+ LengthInBits() uint16
+ Serialize(io utils.WriteBuffer) error
+ xml.Marshaler
}
///////////////////////////////////////////////////////////
// Accessors for discriminator values.
///////////////////////////////////////////////////////////
func (m *ApduDataGroupValueRead) ApciType() uint8 {
- return 0x0
+ return 0x0
}
-
func (m *ApduDataGroupValueRead) InitializeParent(parent *ApduData) {
}
func NewApduDataGroupValueRead() *ApduData {
- child := &ApduDataGroupValueRead{
- Parent: NewApduData(),
- }
- child.Parent.Child = child
- return child.Parent
+ child := &ApduDataGroupValueRead{
+ Parent: NewApduData(),
+ }
+ child.Parent.Child = child
+ return child.Parent
}
func CastApduDataGroupValueRead(structType interface{}) *ApduDataGroupValueRead {
- castFunc := func(typ interface{}) *ApduDataGroupValueRead {
- if casted, ok := typ.(ApduDataGroupValueRead); ok {
- return &casted
- }
- if casted, ok := typ.(*ApduDataGroupValueRead); ok {
- return casted
- }
- if casted, ok := typ.(ApduData); ok {
- return CastApduDataGroupValueRead(casted.Child)
- }
- if casted, ok := typ.(*ApduData); ok {
- return CastApduDataGroupValueRead(casted.Child)
- }
- return nil
- }
- return castFunc(structType)
+ castFunc := func(typ interface{}) *ApduDataGroupValueRead {
+ if casted, ok := typ.(ApduDataGroupValueRead); ok {
+ return &casted
+ }
+ if casted, ok := typ.(*ApduDataGroupValueRead); ok {
+ return casted
+ }
+ if casted, ok := typ.(ApduData); ok {
+ return CastApduDataGroupValueRead(casted.Child)
+ }
+ if casted, ok := typ.(*ApduData); ok {
+ return CastApduDataGroupValueRead(casted.Child)
+ }
+ return nil
+ }
+ return castFunc(structType)
}
func (m *ApduDataGroupValueRead) GetTypeName() string {
- return "ApduDataGroupValueRead"
+ return "ApduDataGroupValueRead"
}
func (m *ApduDataGroupValueRead) LengthInBits() uint16 {
- lengthInBits := uint16(0)
+ lengthInBits := uint16(0)
+
+ // Reserved Field (reserved)
+ lengthInBits += 6
- return lengthInBits
+ return lengthInBits
}
func (m *ApduDataGroupValueRead) LengthInBytes() uint16 {
- return m.LengthInBits() / 8
+ return m.LengthInBits() / 8
}
func ApduDataGroupValueReadParse(io *utils.ReadBuffer) (*ApduData, error) {
- // Create a partially initialized instance
- _child := &ApduDataGroupValueRead{
- Parent: &ApduData{},
- }
- _child.Parent.Child = _child
- return _child.Parent, nil
+ // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
+ {
+ reserved, _err := io.ReadUint8(6)
+ if _err != nil {
+ return nil, errors.New("Error parsing 'reserved' field " + _err.Error())
+ }
+ if reserved != uint8(0x00) {
+ log.WithFields(log.Fields{
+ "expected value": uint8(0x00),
+ "got value": reserved,
+ }).Info("Got unexpected response.")
+ }
+ }
+
+ // Create a partially initialized instance
+ _child := &ApduDataGroupValueRead{
+ Parent: &ApduData{},
+ }
+ _child.Parent.Child = _child
+ return _child.Parent, nil
}
func (m *ApduDataGroupValueRead) Serialize(io utils.WriteBuffer) error {
- ser := func() error {
-
- return nil
- }
- return m.Parent.SerializeParent(io, m, ser)
+ ser := func() error {
+
+ // Reserved Field (reserved)
+ {
+ _err := io.WriteUint8(6, uint8(0x00))
+ if _err != nil {
+ return errors.New("Error serializing 'reserved' field " + _err.Error())
+ }
+ }
+
+ return nil
+ }
+ return m.Parent.SerializeParent(io, m, ser)
}
func (m *ApduDataGroupValueRead) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
- var token xml.Token
- var err error
- token = start
- for {
- switch token.(type) {
- case xml.StartElement:
- tok := token.(xml.StartElement)
- switch tok.Name.Local {
- }
- }
- token, err = d.Token()
- if err != nil {
- if err == io.EOF {
- return nil
- }
- return err
- }
- }
+ var token xml.Token
+ var err error
+ token = start
+ for {
+ switch token.(type) {
+ case xml.StartElement:
+ tok := token.(xml.StartElement)
+ switch tok.Name.Local {
+ }
+ }
+ token, err = d.Token()
+ if err != nil {
+ if err == io.EOF {
+ return nil
+ }
+ return err
+ }
+ }
}
func (m *ApduDataGroupValueRead) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
- return nil
+ return nil
}
-
diff --git a/plc4go/internal/plc4go/knxnetip/readwrite/model/ApduDataGroupValueResponse.go b/plc4go/internal/plc4go/knxnetip/readwrite/model/ApduDataGroupValueResponse.go
index 453289a..be132db 100644
--- a/plc4go/internal/plc4go/knxnetip/readwrite/model/ApduDataGroupValueResponse.go
+++ b/plc4go/internal/plc4go/knxnetip/readwrite/model/ApduDataGroupValueResponse.go
@@ -19,117 +19,190 @@
package model
import (
- "encoding/xml"
- "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
- "io"
+ "encoding/base64"
+ "encoding/xml"
+ "errors"
+ "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+ "io"
)
// The data-structure of this message
type ApduDataGroupValueResponse struct {
- Parent *ApduData
- IApduDataGroupValueResponse
+ DataFirstByte int8
+ Data []int8
+ Parent *ApduData
+ IApduDataGroupValueResponse
}
// The corresponding interface
type IApduDataGroupValueResponse interface {
- LengthInBytes() uint16
- LengthInBits() uint16
- Serialize(io utils.WriteBuffer) error
- xml.Marshaler
+ LengthInBytes() uint16
+ LengthInBits() uint16
+ Serialize(io utils.WriteBuffer) error
+ xml.Marshaler
}
///////////////////////////////////////////////////////////
// Accessors for discriminator values.
///////////////////////////////////////////////////////////
func (m *ApduDataGroupValueResponse) ApciType() uint8 {
- return 0x1
+ return 0x1
}
-
func (m *ApduDataGroupValueResponse) InitializeParent(parent *ApduData) {
}
-func NewApduDataGroupValueResponse() *ApduData {
- child := &ApduDataGroupValueResponse{
- Parent: NewApduData(),
- }
- child.Parent.Child = child
- return child.Parent
+func NewApduDataGroupValueResponse(dataFirstByte int8, data []int8) *ApduData {
+ child := &ApduDataGroupValueResponse{
+ DataFirstByte: dataFirstByte,
+ Data: data,
+ Parent: NewApduData(),
+ }
+ child.Parent.Child = child
+ return child.Parent
}
func CastApduDataGroupValueResponse(structType interface{}) *ApduDataGroupValueResponse {
- castFunc := func(typ interface{}) *ApduDataGroupValueResponse {
- if casted, ok := typ.(ApduDataGroupValueResponse); ok {
- return &casted
- }
- if casted, ok := typ.(*ApduDataGroupValueResponse); ok {
- return casted
- }
- if casted, ok := typ.(ApduData); ok {
- return CastApduDataGroupValueResponse(casted.Child)
- }
- if casted, ok := typ.(*ApduData); ok {
- return CastApduDataGroupValueResponse(casted.Child)
- }
- return nil
- }
- return castFunc(structType)
+ castFunc := func(typ interface{}) *ApduDataGroupValueResponse {
+ if casted, ok := typ.(ApduDataGroupValueResponse); ok {
+ return &casted
+ }
+ if casted, ok := typ.(*ApduDataGroupValueResponse); ok {
+ return casted
+ }
+ if casted, ok := typ.(ApduData); ok {
+ return CastApduDataGroupValueResponse(casted.Child)
+ }
+ if casted, ok := typ.(*ApduData); ok {
+ return CastApduDataGroupValueResponse(casted.Child)
+ }
+ return nil
+ }
+ return castFunc(structType)
}
func (m *ApduDataGroupValueResponse) GetTypeName() string {
- return "ApduDataGroupValueResponse"
+ return "ApduDataGroupValueResponse"
}
func (m *ApduDataGroupValueResponse) LengthInBits() uint16 {
- lengthInBits := uint16(0)
+ lengthInBits := uint16(0)
+
+ // Simple field (dataFirstByte)
+ lengthInBits += 6
+
+ // Array field
+ if len(m.Data) > 0 {
+ lengthInBits += 8 * uint16(len(m.Data))
+ }
- return lengthInBits
+ return lengthInBits
}
func (m *ApduDataGroupValueResponse) LengthInBytes() uint16 {
- return m.LengthInBits() / 8
+ return m.LengthInBits() / 8
}
-func ApduDataGroupValueResponseParse(io *utils.ReadBuffer) (*ApduData, error) {
-
- // Create a partially initialized instance
- _child := &ApduDataGroupValueResponse{
- Parent: &ApduData{},
- }
- _child.Parent.Child = _child
- return _child.Parent, nil
+func ApduDataGroupValueResponseParse(io *utils.ReadBuffer, dataLength uint8) (*ApduData, error) {
+
+ // Simple Field (dataFirstByte)
+ dataFirstByte, _dataFirstByteErr := io.ReadInt8(6)
+ if _dataFirstByteErr != nil {
+ return nil, errors.New("Error parsing 'dataFirstByte' field " + _dataFirstByteErr.Error())
+ }
+
+ // Array field (data)
+ // Count array
+ data := make([]int8, utils.InlineIf(bool(bool((dataLength) < (1))), uint16(uint16(0)), uint16(uint16(dataLength)-uint16(uint16(1)))))
+ for curItem := uint16(0); curItem < uint16(utils.InlineIf(bool(bool((dataLength) < (1))), uint16(uint16(0)), uint16(uint16(dataLength)-uint16(uint16(1))))); curItem++ {
+ _item, _err := io.ReadInt8(8)
+ if _err != nil {
+ return nil, errors.New("Error parsing 'data' field " + _err.Error())
+ }
+ data[curItem] = _item
+ }
+
+ // Create a partially initialized instance
+ _child := &ApduDataGroupValueResponse{
+ DataFirstByte: dataFirstByte,
+ Data: data,
+ Parent: &ApduData{},
+ }
+ _child.Parent.Child = _child
+ return _child.Parent, nil
}
func (m *ApduDataGroupValueResponse) Serialize(io utils.WriteBuffer) error {
- ser := func() error {
-
- return nil
- }
- return m.Parent.SerializeParent(io, m, ser)
+ ser := func() error {
+
+ // Simple Field (dataFirstByte)
+ dataFirstByte := int8(m.DataFirstByte)
+ _dataFirstByteErr := io.WriteInt8(6, (dataFirstByte))
+ if _dataFirstByteErr != nil {
+ return errors.New("Error serializing 'dataFirstByte' field " + _dataFirstByteErr.Error())
+ }
+
+ // Array Field (data)
+ if m.Data != nil {
+ for _, _element := range m.Data {
+ _elementErr := io.WriteInt8(8, _element)
+ if _elementErr != nil {
+ return errors.New("Error serializing 'data' field " + _elementErr.Error())
+ }
+ }
+ }
+
+ return nil
+ }
+ return m.Parent.SerializeParent(io, m, ser)
}
func (m *ApduDataGroupValueResponse) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
- var token xml.Token
- var err error
- token = start
- for {
- switch token.(type) {
- case xml.StartElement:
- tok := token.(xml.StartElement)
- switch tok.Name.Local {
- }
- }
- token, err = d.Token()
- if err != nil {
- if err == io.EOF {
- return nil
- }
- return err
- }
- }
+ var token xml.Token
+ var err error
+ token = start
+ for {
+ switch token.(type) {
+ case xml.StartElement:
+ tok := token.(xml.StartElement)
+ switch tok.Name.Local {
+ case "dataFirstByte":
+ var data int8
+ if err := d.DecodeElement(&data, &tok); err != nil {
+ return err
+ }
+ m.DataFirstByte = data
+ case "data":
+ var _encoded string
+ if err := d.DecodeElement(&_encoded, &tok); err != nil {
+ return err
+ }
+ _decoded := make([]byte, base64.StdEncoding.DecodedLen(len(_encoded)))
+ _len, err := base64.StdEncoding.Decode(_decoded, []byte(_encoded))
+ if err != nil {
+ return err
+ }
+ m.Data = utils.ByteArrayToInt8Array(_decoded[0:_len])
+ }
+ }
+ token, err = d.Token()
+ if err != nil {
+ if err == io.EOF {
+ return nil
+ }
+ return err
+ }
+ }
}
func (m *ApduDataGroupValueResponse) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
- return nil
+ if err := e.EncodeElement(m.DataFirstByte, xml.StartElement{Name: xml.Name{Local: "dataFirstByte"}}); err != nil {
+ return err
+ }
+ _encodedData := make([]byte, base64.StdEncoding.EncodedLen(len(m.Data)))
+ base64.StdEncoding.Encode(_encodedData, utils.Int8ArrayToByteArray(m.Data))
+ if err := e.EncodeElement(_encodedData, xml.StartElement{Name: xml.Name{Local: "data"}}); err != nil {
+ return err
+ }
+ return nil
}
-
diff --git a/plc4go/internal/plc4go/knxnetip/readwrite/model/KnxDatapoint.go b/plc4go/internal/plc4go/knxnetip/readwrite/model/KnxDatapoint.go
index 1b236b0..91a29cf 100644
--- a/plc4go/internal/plc4go/knxnetip/readwrite/model/KnxDatapoint.go
+++ b/plc4go/internal/plc4go/knxnetip/readwrite/model/KnxDatapoint.go
@@ -19,12289 +19,10118 @@
package model
import (
- "errors"
- "github.com/apache/plc4x/plc4go/internal/plc4go/spi/values"
- "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
- api "github.com/apache/plc4x/plc4go/pkg/plc4go/values"
- "time"
+ "errors"
+ "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+ "github.com/apache/plc4x/plc4go/internal/plc4go/spi/values"
+ api "github.com/apache/plc4x/plc4go/pkg/plc4go/values"
+ "time"
)
func KnxDatapointParse(io *utils.ReadBuffer, datapointType KnxDatapointType) (api.PlcValue, error) {
- switch {
- case datapointType == KnxDatapointType_BOOL: // BOOL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(7); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadBit()
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcBOOL(value), nil
- case datapointType == KnxDatapointType_BYTE: // BYTE
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcBYTE(value), nil
- case datapointType == KnxDatapointType_WORD: // WORD
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint16(16)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcWORD(value), nil
- case datapointType == KnxDatapointType_DWORD: // DWORD
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint32(32)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcDWORD(value), nil
- case datapointType == KnxDatapointType_LWORD: // LWORD
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint64(64)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcLWORD(value), nil
- case datapointType == KnxDatapointType_USINT: // USINT
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_SINT: // SINT
-
- // Simple Field (value)
- value, _valueErr := io.ReadInt8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcSINT(value), nil
- case datapointType == KnxDatapointType_UINT: // UINT
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint16(16)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUINT(value), nil
- case datapointType == KnxDatapointType_INT: // INT
-
- // Simple Field (value)
- value, _valueErr := io.ReadInt16(16)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcINT(value), nil
- case datapointType == KnxDatapointType_UDINT: // UDINT
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint32(32)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUDINT(value), nil
- case datapointType == KnxDatapointType_DINT: // DINT
-
- // Simple Field (value)
- value, _valueErr := io.ReadInt32(32)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcDINT(value), nil
- case datapointType == KnxDatapointType_ULINT: // ULINT
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint64(64)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcULINT(value), nil
- case datapointType == KnxDatapointType_LINT: // LINT
-
- // Simple Field (value)
- value, _valueErr := io.ReadInt64(64)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcLINT(value), nil
- case datapointType == KnxDatapointType_REAL: // REAL
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_LREAL: // LREAL
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat64(true, 11, 52)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcLREAL(value), nil
- case datapointType == KnxDatapointType_CHAR: // CHAR
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcCHAR(value), nil
- case datapointType == KnxDatapointType_WCHAR: // WCHAR
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint16(16)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcWCHAR(value), nil
- case datapointType == KnxDatapointType_TIME: // TIME
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint32(32)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcTIME(value), nil
- case datapointType == KnxDatapointType_LTIME: // LTIME
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint64(64)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcLTIME(value), nil
- case datapointType == KnxDatapointType_DATE: // DATE
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint16(16)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcDATE(value), nil
- case datapointType == KnxDatapointType_TIME_OF_DAY: // TIME_OF_DAY
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint32(32)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcTIME_OF_DAY(value), nil
- case datapointType == KnxDatapointType_TOD: // TIME_OF_DAY
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint32(32)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcTIME_OF_DAY(value), nil
- case datapointType == KnxDatapointType_DATE_AND_TIME: // DATE_AND_TIME
-
- // Simple Field (year)
- year, _yearErr := io.ReadUint16(16)
- if _yearErr != nil {
- return nil, errors.New("Error parsing 'year' field " + _yearErr.Error())
- }
-
- // Simple Field (month)
- month, _monthErr := io.ReadUint8(8)
- if _monthErr != nil {
- return nil, errors.New("Error parsing 'month' field " + _monthErr.Error())
- }
-
- // Simple Field (day)
- day, _dayErr := io.ReadUint8(8)
- if _dayErr != nil {
- return nil, errors.New("Error parsing 'day' field " + _dayErr.Error())
- }
-
- // Simple Field (dayOfWeek)
- _, _dayOfWeekErr := io.ReadUint8(8)
- if _dayOfWeekErr != nil {
- return nil, errors.New("Error parsing 'dayOfWeek' field " + _dayOfWeekErr.Error())
- }
-
- // Simple Field (hour)
- hour, _hourErr := io.ReadUint8(8)
- if _hourErr != nil {
- return nil, errors.New("Error parsing 'hour' field " + _hourErr.Error())
- }
-
- // Simple Field (minutes)
- minutes, _minutesErr := io.ReadUint8(8)
- if _minutesErr != nil {
- return nil, errors.New("Error parsing 'minutes' field " + _minutesErr.Error())
- }
-
- // Simple Field (seconds)
- seconds, _secondsErr := io.ReadUint8(8)
- if _secondsErr != nil {
- return nil, errors.New("Error parsing 'seconds' field " + _secondsErr.Error())
- }
-
- // Simple Field (nanos)
- _, _nanosErr := io.ReadUint32(32)
- if _nanosErr != nil {
- return nil, errors.New("Error parsing 'nanos' field " + _nanosErr.Error())
- }
- value := time.Date(int(year), time.Month(month), int(day), int(hour), int(minutes), int(seconds), 0, nil)
- return values.NewPlcDATE_AND_TIME(value), nil
- case datapointType == KnxDatapointType_DT: // DATE_AND_TIME
-
- // Simple Field (year)
- year, _yearErr := io.ReadUint16(16)
- if _yearErr != nil {
- return nil, errors.New("Error parsing 'year' field " + _yearErr.Error())
- }
-
- // Simple Field (month)
- month, _monthErr := io.ReadUint8(8)
- if _monthErr != nil {
- return nil, errors.New("Error parsing 'month' field " + _monthErr.Error())
- }
-
- // Simple Field (day)
- day, _dayErr := io.ReadUint8(8)
- if _dayErr != nil {
- return nil, errors.New("Error parsing 'day' field " + _dayErr.Error())
- }
-
- // Simple Field (dayOfWeek)
- _, _dayOfWeekErr := io.ReadUint8(8)
- if _dayOfWeekErr != nil {
- return nil, errors.New("Error parsing 'dayOfWeek' field " + _dayOfWeekErr.Error())
- }
-
- // Simple Field (hour)
- hour, _hourErr := io.ReadUint8(8)
- if _hourErr != nil {
- return nil, errors.New("Error parsing 'hour' field " + _hourErr.Error())
- }
-
- // Simple Field (minutes)
- minutes, _minutesErr := io.ReadUint8(8)
- if _minutesErr != nil {
- return nil, errors.New("Error parsing 'minutes' field " + _minutesErr.Error())
- }
-
- // Simple Field (seconds)
- seconds, _secondsErr := io.ReadUint8(8)
- if _secondsErr != nil {
- return nil, errors.New("Error parsing 'seconds' field " + _secondsErr.Error())
- }
-
- // Simple Field (nanos)
- _, _nanosErr := io.ReadUint32(32)
- if _nanosErr != nil {
- return nil, errors.New("Error parsing 'nanos' field " + _nanosErr.Error())
- }
- value := time.Date(int(year), time.Month(month), int(day), int(hour), int(minutes), int(seconds), 0, nil)
- return values.NewPlcDATE_AND_TIME(value), nil
- case datapointType == KnxDatapointType_DPT_Switch: // BOOL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(7); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadBit()
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcBOOL(value), nil
- case datapointType == KnxDatapointType_DPT_Bool: // BOOL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(7); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadBit()
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcBOOL(value), nil
- case datapointType == KnxDatapointType_DPT_Enable: // BOOL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(7); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadBit()
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcBOOL(value), nil
- case datapointType == KnxDatapointType_DPT_Ramp: // BOOL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(7); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadBit()
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcBOOL(value), nil
- case datapointType == KnxDatapointType_DPT_Alarm: // BOOL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(7); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadBit()
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcBOOL(value), nil
- case datapointType == KnxDatapointType_DPT_BinaryValue: // BOOL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(7); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadBit()
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcBOOL(value), nil
- case datapointType == KnxDatapointType_DPT_Step: // BOOL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(7); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadBit()
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcBOOL(value), nil
- case datapointType == KnxDatapointType_DPT_UpDown: // BOOL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(7); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadBit()
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcBOOL(value), nil
- case datapointType == KnxDatapointType_DPT_OpenClose: // BOOL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(7); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadBit()
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcBOOL(value), nil
- case datapointType == KnxDatapointType_DPT_Start: // BOOL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(7); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadBit()
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcBOOL(value), nil
- case datapointType == KnxDatapointType_DPT_State: // BOOL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(7); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadBit()
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcBOOL(value), nil
- case datapointType == KnxDatapointType_DPT_Invert: // BOOL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(7); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadBit()
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcBOOL(value), nil
- case datapointType == KnxDatapointType_DPT_DimSendStyle: // BOOL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(7); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadBit()
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcBOOL(value), nil
- case datapointType == KnxDatapointType_DPT_InputSource: // BOOL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(7); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadBit()
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcBOOL(value), nil
- case datapointType == KnxDatapointType_DPT_Reset: // BOOL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(7); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadBit()
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcBOOL(value), nil
- case datapointType == KnxDatapointType_DPT_Ack: // BOOL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(7); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadBit()
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcBOOL(value), nil
- case datapointType == KnxDatapointType_DPT_Trigger: // BOOL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(7); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadBit()
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcBOOL(value), nil
- case datapointType == KnxDatapointType_DPT_Occupancy: // BOOL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(7); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadBit()
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcBOOL(value), nil
- case datapointType == KnxDatapointType_DPT_Window_Door: // BOOL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(7); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadBit()
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcBOOL(value), nil
- case datapointType == KnxDatapointType_DPT_LogicalFunction: // BOOL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(7); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadBit()
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcBOOL(value), nil
- case datapointType == KnxDatapointType_DPT_Scene_AB: // BOOL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(7); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadBit()
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcBOOL(value), nil
- case datapointType == KnxDatapointType_DPT_ShutterBlinds_Mode: // BOOL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(7); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadBit()
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcBOOL(value), nil
- case datapointType == KnxDatapointType_DPT_DayNight: // BOOL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(7); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadBit()
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcBOOL(value), nil
- case datapointType == KnxDatapointType_DPT_Heat_Cool: // BOOL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(7); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadBit()
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcBOOL(value), nil
- case datapointType == KnxDatapointType_DPT_Switch_Control: // Struct
- _map := map[string]api.PlcValue{}
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(6); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (control)
- control, _controlErr := io.ReadBit()
- if _controlErr != nil {
- return nil, errors.New("Error parsing 'control' field " + _controlErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(control)
-
- // Simple Field (on)
- on, _onErr := io.ReadBit()
- if _onErr != nil {
- return nil, errors.New("Error parsing 'on' field " + _onErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(on)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_Bool_Control: // Struct
- _map := map[string]api.PlcValue{}
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(6); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (control)
- control, _controlErr := io.ReadBit()
- if _controlErr != nil {
- return nil, errors.New("Error parsing 'control' field " + _controlErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(control)
-
- // Simple Field (valueTrue)
- valueTrue, _valueTrueErr := io.ReadBit()
- if _valueTrueErr != nil {
- return nil, errors.New("Error parsing 'valueTrue' field " + _valueTrueErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(valueTrue)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_Enable_Control: // Struct
- _map := map[string]api.PlcValue{}
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(6); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (control)
- control, _controlErr := io.ReadBit()
- if _controlErr != nil {
- return nil, errors.New("Error parsing 'control' field " + _controlErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(control)
-
- // Simple Field (enable)
- enable, _enableErr := io.ReadBit()
- if _enableErr != nil {
- return nil, errors.New("Error parsing 'enable' field " + _enableErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(enable)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_Ramp_Control: // Struct
- _map := map[string]api.PlcValue{}
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(6); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (control)
- control, _controlErr := io.ReadBit()
- if _controlErr != nil {
- return nil, errors.New("Error parsing 'control' field " + _controlErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(control)
-
- // Simple Field (ramp)
- ramp, _rampErr := io.ReadBit()
- if _rampErr != nil {
- return nil, errors.New("Error parsing 'ramp' field " + _rampErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(ramp)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_Alarm_Control: // Struct
- _map := map[string]api.PlcValue{}
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(6); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (control)
- control, _controlErr := io.ReadBit()
- if _controlErr != nil {
- return nil, errors.New("Error parsing 'control' field " + _controlErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(control)
-
- // Simple Field (alarm)
- alarm, _alarmErr := io.ReadBit()
- if _alarmErr != nil {
- return nil, errors.New("Error parsing 'alarm' field " + _alarmErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(alarm)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_BinaryValue_Control: // Struct
- _map := map[string]api.PlcValue{}
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(6); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (control)
- control, _controlErr := io.ReadBit()
- if _controlErr != nil {
- return nil, errors.New("Error parsing 'control' field " + _controlErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(control)
-
- // Simple Field (high)
- high, _highErr := io.ReadBit()
- if _highErr != nil {
- return nil, errors.New("Error parsing 'high' field " + _highErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(high)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_Step_Control: // Struct
- _map := map[string]api.PlcValue{}
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(6); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (control)
- control, _controlErr := io.ReadBit()
- if _controlErr != nil {
- return nil, errors.New("Error parsing 'control' field " + _controlErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(control)
-
- // Simple Field (increase)
- increase, _increaseErr := io.ReadBit()
- if _increaseErr != nil {
- return nil, errors.New("Error parsing 'increase' field " + _increaseErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(increase)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_Direction1_Control: // Struct
- _map := map[string]api.PlcValue{}
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(6); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (control)
- control, _controlErr := io.ReadBit()
- if _controlErr != nil {
- return nil, errors.New("Error parsing 'control' field " + _controlErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(control)
-
- // Simple Field (down)
- down, _downErr := io.ReadBit()
- if _downErr != nil {
- return nil, errors.New("Error parsing 'down' field " + _downErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(down)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_Direction2_Control: // Struct
- _map := map[string]api.PlcValue{}
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(6); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (control)
- control, _controlErr := io.ReadBit()
- if _controlErr != nil {
- return nil, errors.New("Error parsing 'control' field " + _controlErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(control)
-
- // Simple Field (close)
- close, _closeErr := io.ReadBit()
- if _closeErr != nil {
- return nil, errors.New("Error parsing 'close' field " + _closeErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(close)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_Start_Control: // Struct
- _map := map[string]api.PlcValue{}
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(6); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (control)
- control, _controlErr := io.ReadBit()
- if _controlErr != nil {
- return nil, errors.New("Error parsing 'control' field " + _controlErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(control)
-
- // Simple Field (start)
- start, _startErr := io.ReadBit()
- if _startErr != nil {
- return nil, errors.New("Error parsing 'start' field " + _startErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(start)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_State_Control: // Struct
- _map := map[string]api.PlcValue{}
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(6); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (control)
- control, _controlErr := io.ReadBit()
- if _controlErr != nil {
- return nil, errors.New("Error parsing 'control' field " + _controlErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(control)
-
- // Simple Field (active)
- active, _activeErr := io.ReadBit()
- if _activeErr != nil {
- return nil, errors.New("Error parsing 'active' field " + _activeErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(active)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_Invert_Control: // Struct
- _map := map[string]api.PlcValue{}
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(6); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (control)
- control, _controlErr := io.ReadBit()
- if _controlErr != nil {
- return nil, errors.New("Error parsing 'control' field " + _controlErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(control)
-
- // Simple Field (inverted)
- inverted, _invertedErr := io.ReadBit()
- if _invertedErr != nil {
- return nil, errors.New("Error parsing 'inverted' field " + _invertedErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(inverted)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_Control_Dimming: // Struct
- _map := map[string]api.PlcValue{}
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(4); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (increase)
- increase, _increaseErr := io.ReadBit()
- if _increaseErr != nil {
- return nil, errors.New("Error parsing 'increase' field " + _increaseErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(increase)
-
- // Simple Field (stepcode)
- stepcode, _stepcodeErr := io.ReadUint8(3)
- if _stepcodeErr != nil {
- return nil, errors.New("Error parsing 'stepcode' field " + _stepcodeErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(stepcode)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_Control_Blinds: // Struct
- _map := map[string]api.PlcValue{}
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(4); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (down)
- down, _downErr := io.ReadBit()
- if _downErr != nil {
- return nil, errors.New("Error parsing 'down' field " + _downErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(down)
-
- // Simple Field (stepcode)
- stepcode, _stepcodeErr := io.ReadUint8(3)
- if _stepcodeErr != nil {
- return nil, errors.New("Error parsing 'stepcode' field " + _stepcodeErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(stepcode)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_Char_ASCII: // STRING
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadString(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcSTRING(value), nil
- case datapointType == KnxDatapointType_DPT_Char_8859_1: // STRING
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadString(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcSTRING(value), nil
- case datapointType == KnxDatapointType_DPT_Scaling: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_Angle: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_Percent_U8: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_DecimalFactor: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_Tariff: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_Value_1_Ucount: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_FanStage: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_Percent_V8: // SINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadInt8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcSINT(value), nil
- case datapointType == KnxDatapointType_DPT_Value_1_Count: // SINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadInt8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcSINT(value), nil
- case datapointType == KnxDatapointType_DPT_Status_Mode3: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (statusA)
- statusA, _statusAErr := io.ReadBit()
- if _statusAErr != nil {
- return nil, errors.New("Error parsing 'statusA' field " + _statusAErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(statusA)
-
- // Simple Field (statusB)
- statusB, _statusBErr := io.ReadBit()
- if _statusBErr != nil {
- return nil, errors.New("Error parsing 'statusB' field " + _statusBErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(statusB)
-
- // Simple Field (statusC)
- statusC, _statusCErr := io.ReadBit()
- if _statusCErr != nil {
- return nil, errors.New("Error parsing 'statusC' field " + _statusCErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(statusC)
-
- // Simple Field (statusD)
- statusD, _statusDErr := io.ReadBit()
- if _statusDErr != nil {
- return nil, errors.New("Error parsing 'statusD' field " + _statusDErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(statusD)
-
- // Simple Field (statusE)
- statusE, _statusEErr := io.ReadBit()
- if _statusEErr != nil {
- return nil, errors.New("Error parsing 'statusE' field " + _statusEErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(statusE)
-
- // Simple Field (mode)
- mode, _modeErr := io.ReadUint8(3)
- if _modeErr != nil {
- return nil, errors.New("Error parsing 'mode' field " + _modeErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(mode)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_Value_2_Ucount: // UINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint16(16)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUINT(value), nil
- case datapointType == KnxDatapointType_DPT_TimePeriodMsec: // UINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint16(16)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUINT(value), nil
- case datapointType == KnxDatapointType_DPT_TimePeriod10Msec: // UINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint16(16)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUINT(value), nil
- case datapointType == KnxDatapointType_DPT_TimePeriod100Msec: // UINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint16(16)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUINT(value), nil
- case datapointType == KnxDatapointType_DPT_TimePeriodSec: // UINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint16(16)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUINT(value), nil
- case datapointType == KnxDatapointType_DPT_TimePeriodMin: // UINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint16(16)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUINT(value), nil
- case datapointType == KnxDatapointType_DPT_TimePeriodHrs: // UINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint16(16)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUINT(value), nil
- case datapointType == KnxDatapointType_DPT_PropDataType: // UINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint16(16)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUINT(value), nil
- case datapointType == KnxDatapointType_DPT_Length_mm: // UINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint16(16)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUINT(value), nil
- case datapointType == KnxDatapointType_DPT_UElCurrentmA: // UINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint16(16)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUINT(value), nil
- case datapointType == KnxDatapointType_DPT_Brightness: // UINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint16(16)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUINT(value), nil
- case datapointType == KnxDatapointType_DPT_Absolute_Colour_Temperature: // UINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint16(16)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUINT(value), nil
- case datapointType == KnxDatapointType_DPT_Value_2_Count: // INT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadInt16(16)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcINT(value), nil
- case datapointType == KnxDatapointType_DPT_DeltaTimeMsec: // INT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadInt16(16)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcINT(value), nil
- case datapointType == KnxDatapointType_DPT_DeltaTime10Msec: // INT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadInt16(16)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcINT(value), nil
- case datapointType == KnxDatapointType_DPT_DeltaTime100Msec: // INT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadInt16(16)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcINT(value), nil
- case datapointType == KnxDatapointType_DPT_DeltaTimeSec: // INT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadInt16(16)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcINT(value), nil
- case datapointType == KnxDatapointType_DPT_DeltaTimeMin: // INT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadInt16(16)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcINT(value), nil
- case datapointType == KnxDatapointType_DPT_DeltaTimeHrs: // INT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadInt16(16)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcINT(value), nil
- case datapointType == KnxDatapointType_DPT_Percent_V16: // INT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadInt16(16)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcINT(value), nil
- case datapointType == KnxDatapointType_DPT_Rotation_Angle: // INT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadInt16(16)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcINT(value), nil
- case datapointType == KnxDatapointType_DPT_Length_m: // INT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadInt16(16)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcINT(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Temp: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 4, 11)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Tempd: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 4, 11)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Tempa: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 4, 11)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Lux: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 4, 11)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Wsp: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 4, 11)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Pres: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 4, 11)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Humidity: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 4, 11)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_AirQuality: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 4, 11)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_AirFlow: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 4, 11)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Time1: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 4, 11)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Time2: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 4, 11)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Volt: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 4, 11)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Curr: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 4, 11)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_PowerDensity: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 4, 11)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_KelvinPerPercent: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 4, 11)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Power: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 4, 11)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Volume_Flow: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 4, 11)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Rain_Amount: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 4, 11)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Temp_F: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 4, 11)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Wsp_kmh: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 4, 11)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Absolute_Humidity: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 4, 11)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Concentration_ygm3: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 4, 11)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_TimeOfDay: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (day)
- day, _dayErr := io.ReadUint8(3)
- if _dayErr != nil {
- return nil, errors.New("Error parsing 'day' field " + _dayErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(day)
-
- // Simple Field (hour)
- hour, _hourErr := io.ReadUint8(5)
- if _hourErr != nil {
- return nil, errors.New("Error parsing 'hour' field " + _hourErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(hour)
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(2); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (minutes)
- minutes, _minutesErr := io.ReadUint8(6)
- if _minutesErr != nil {
- return nil, errors.New("Error parsing 'minutes' field " + _minutesErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(minutes)
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(2); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (seconds)
- seconds, _secondsErr := io.ReadUint8(6)
- if _secondsErr != nil {
- return nil, errors.New("Error parsing 'seconds' field " + _secondsErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(seconds)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_Date: // Struct
- _map := map[string]api.PlcValue{}
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(3); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (dayOfMonth)
- dayOfMonth, _dayOfMonthErr := io.ReadUint8(5)
- if _dayOfMonthErr != nil {
- return nil, errors.New("Error parsing 'dayOfMonth' field " + _dayOfMonthErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(dayOfMonth)
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(4); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (month)
- month, _monthErr := io.ReadUint8(4)
- if _monthErr != nil {
- return nil, errors.New("Error parsing 'month' field " + _monthErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(month)
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(1); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (year)
- year, _yearErr := io.ReadUint8(7)
- if _yearErr != nil {
- return nil, errors.New("Error parsing 'year' field " + _yearErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(year)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_Value_4_Ucount: // UDINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint32(32)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUDINT(value), nil
- case datapointType == KnxDatapointType_DPT_LongTimePeriod_Sec: // UDINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint32(32)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUDINT(value), nil
- case datapointType == KnxDatapointType_DPT_LongTimePeriod_Min: // UDINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint32(32)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUDINT(value), nil
- case datapointType == KnxDatapointType_DPT_LongTimePeriod_Hrs: // UDINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint32(32)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUDINT(value), nil
- case datapointType == KnxDatapointType_DPT_VolumeLiquid_Litre: // UDINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint32(32)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUDINT(value), nil
- case datapointType == KnxDatapointType_DPT_Volume_m_3: // UDINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint32(32)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUDINT(value), nil
- case datapointType == KnxDatapointType_DPT_Value_4_Count: // DINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadInt32(32)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcDINT(value), nil
- case datapointType == KnxDatapointType_DPT_FlowRate_m3h: // DINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadInt32(32)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcDINT(value), nil
- case datapointType == KnxDatapointType_DPT_ActiveEnergy: // DINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadInt32(32)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcDINT(value), nil
- case datapointType == KnxDatapointType_DPT_ApparantEnergy: // DINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadInt32(32)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcDINT(value), nil
- case datapointType == KnxDatapointType_DPT_ReactiveEnergy: // DINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadInt32(32)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcDINT(value), nil
- case datapointType == KnxDatapointType_DPT_ActiveEnergy_kWh: // DINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadInt32(32)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcDINT(value), nil
- case datapointType == KnxDatapointType_DPT_ApparantEnergy_kVAh: // DINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadInt32(32)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcDINT(value), nil
- case datapointType == KnxDatapointType_DPT_ReactiveEnergy_kVARh: // DINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadInt32(32)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcDINT(value), nil
- case datapointType == KnxDatapointType_DPT_ActiveEnergy_MWh: // DINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadInt32(32)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcDINT(value), nil
- case datapointType == KnxDatapointType_DPT_LongDeltaTimeSec: // DINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadInt32(32)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcDINT(value), nil
- case datapointType == KnxDatapointType_DPT_DeltaVolumeLiquid_Litre: // DINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadInt32(32)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcDINT(value), nil
- case datapointType == KnxDatapointType_DPT_DeltaVolume_m_3: // DINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadInt32(32)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcDINT(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Acceleration: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Acceleration_Angular: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Activation_Energy: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Activity: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Mol: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Amplitude: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_AngleRad: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_AngleDeg: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Angular_Momentum: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Angular_Velocity: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Area: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Capacitance: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Charge_DensitySurface: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Charge_DensityVolume: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Compressibility: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Conductance: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Electrical_Conductivity: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Density: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Electric_Charge: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Electric_Current: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Electric_CurrentDensity: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Electric_DipoleMoment: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Electric_Displacement: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Electric_FieldStrength: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Electric_Flux: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Electric_FluxDensity: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Electric_Polarization: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Electric_Potential: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Electric_PotentialDifference: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_ElectromagneticMoment: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Electromotive_Force: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Energy: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Force: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Frequency: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Angular_Frequency: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Heat_Capacity: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Heat_FlowRate: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Heat_Quantity: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Impedance: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Length: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Light_Quantity: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Luminance: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Luminous_Flux: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Luminous_Intensity: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Magnetic_FieldStrength: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Magnetic_Flux: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Magnetic_FluxDensity: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Magnetic_Moment: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Magnetic_Polarization: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Magnetization: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_MagnetomotiveForce: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Mass: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_MassFlux: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Momentum: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Phase_AngleRad: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Phase_AngleDeg: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Power: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Power_Factor: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Pressure: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Reactance: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Resistance: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Resistivity: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_SelfInductance: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_SolidAngle: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Sound_Intensity: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Speed: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Stress: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Surface_Tension: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Common_Temperature: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Absolute_Temperature: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_TemperatureDifference: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Thermal_Capacity: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Thermal_Conductivity: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_ThermoelectricPower: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Time: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Torque: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Volume: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Volume_Flux: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Weight: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Value_Work: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 8, 23)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Volume_Flux_Meter: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 4, 11)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Volume_Flux_ls: // REAL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadFloat32(true, 4, 11)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcREAL(value), nil
- case datapointType == KnxDatapointType_DPT_Access_Data: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (hurz)
- hurz, _hurzErr := io.ReadUint8(4)
- if _hurzErr != nil {
- return nil, errors.New("Error parsing 'hurz' field " + _hurzErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(hurz)
-
- // Simple Field (value1)
- value1, _value1Err := io.ReadUint8(4)
- if _value1Err != nil {
- return nil, errors.New("Error parsing 'value1' field " + _value1Err.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(value1)
-
- // Simple Field (value2)
- value2, _value2Err := io.ReadUint8(4)
- if _value2Err != nil {
- return nil, errors.New("Error parsing 'value2' field " + _value2Err.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(value2)
-
- // Simple Field (value3)
- value3, _value3Err := io.ReadUint8(4)
- if _value3Err != nil {
- return nil, errors.New("Error parsing 'value3' field " + _value3Err.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(value3)
-
- // Simple Field (value4)
- value4, _value4Err := io.ReadUint8(4)
- if _value4Err != nil {
- return nil, errors.New("Error parsing 'value4' field " + _value4Err.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(value4)
-
- // Simple Field (value5)
- value5, _value5Err := io.ReadUint8(4)
- if _value5Err != nil {
- return nil, errors.New("Error parsing 'value5' field " + _value5Err.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(value5)
-
- // Simple Field (detectionError)
- detectionError, _detectionErrorErr := io.ReadBit()
- if _detectionErrorErr != nil {
- return nil, errors.New("Error parsing 'detectionError' field " + _detectionErrorErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(detectionError)
-
- // Simple Field (permission)
- permission, _permissionErr := io.ReadBit()
- if _permissionErr != nil {
- return nil, errors.New("Error parsing 'permission' field " + _permissionErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(permission)
-
- // Simple Field (readDirection)
- readDirection, _readDirectionErr := io.ReadBit()
- if _readDirectionErr != nil {
- return nil, errors.New("Error parsing 'readDirection' field " + _readDirectionErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(readDirection)
-
- // Simple Field (encryptionOfAccessInformation)
- encryptionOfAccessInformation, _encryptionOfAccessInformationErr := io.ReadBit()
- if _encryptionOfAccessInformationErr != nil {
- return nil, errors.New("Error parsing 'encryptionOfAccessInformation' field " + _encryptionOfAccessInformationErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(encryptionOfAccessInformation)
-
- // Simple Field (indexOfAccessIdentificationCode)
- indexOfAccessIdentificationCode, _indexOfAccessIdentificationCodeErr := io.ReadUint8(4)
- if _indexOfAccessIdentificationCodeErr != nil {
- return nil, errors.New("Error parsing 'indexOfAccessIdentificationCode' field " + _indexOfAccessIdentificationCodeErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(indexOfAccessIdentificationCode)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_String_ASCII: // STRING
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadString(112)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcSTRING(value), nil
- case datapointType == KnxDatapointType_DPT_String_8859_1: // STRING
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadString(112)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcSTRING(value), nil
- case datapointType == KnxDatapointType_DPT_SceneNumber: // USINT
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(6)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_SceneControl: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (learnTheSceneCorrespondingToTheFieldSceneNumber)
- learnTheSceneCorrespondingToTheFieldSceneNumber, _learnTheSceneCorrespondingToTheFieldSceneNumberErr := io.ReadBit()
- if _learnTheSceneCorrespondingToTheFieldSceneNumberErr != nil {
- return nil, errors.New("Error parsing 'learnTheSceneCorrespondingToTheFieldSceneNumber' field " + _learnTheSceneCorrespondingToTheFieldSceneNumberErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(learnTheSceneCorrespondingToTheFieldSceneNumber)
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(1); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (sceneNumber)
- sceneNumber, _sceneNumberErr := io.ReadUint8(6)
- if _sceneNumberErr != nil {
- return nil, errors.New("Error parsing 'sceneNumber' field " + _sceneNumberErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(sceneNumber)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_DateTime: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (year)
- year, _yearErr := io.ReadUint8(8)
- if _yearErr != nil {
- return nil, errors.New("Error parsing 'year' field " + _yearErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(year)
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(4); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (month)
- month, _monthErr := io.ReadUint8(4)
- if _monthErr != nil {
- return nil, errors.New("Error parsing 'month' field " + _monthErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(month)
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(3); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (dayofmonth)
- dayofmonth, _dayofmonthErr := io.ReadUint8(5)
- if _dayofmonthErr != nil {
- return nil, errors.New("Error parsing 'dayofmonth' field " + _dayofmonthErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(dayofmonth)
-
- // Simple Field (dayofweek)
- dayofweek, _dayofweekErr := io.ReadUint8(3)
- if _dayofweekErr != nil {
- return nil, errors.New("Error parsing 'dayofweek' field " + _dayofweekErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(dayofweek)
-
- // Simple Field (hourofday)
- hourofday, _hourofdayErr := io.ReadUint8(5)
- if _hourofdayErr != nil {
- return nil, errors.New("Error parsing 'hourofday' field " + _hourofdayErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(hourofday)
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(2); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (minutes)
- minutes, _minutesErr := io.ReadUint8(6)
- if _minutesErr != nil {
- return nil, errors.New("Error parsing 'minutes' field " + _minutesErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(minutes)
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(2); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (seconds)
- seconds, _secondsErr := io.ReadUint8(6)
- if _secondsErr != nil {
- return nil, errors.New("Error parsing 'seconds' field " + _secondsErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(seconds)
-
- // Simple Field (fault)
- fault, _faultErr := io.ReadBit()
- if _faultErr != nil {
- return nil, errors.New("Error parsing 'fault' field " + _faultErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(fault)
-
- // Simple Field (workingDay)
- workingDay, _workingDayErr := io.ReadBit()
- if _workingDayErr != nil {
- return nil, errors.New("Error parsing 'workingDay' field " + _workingDayErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(workingDay)
-
- // Simple Field (noWd)
- noWd, _noWdErr := io.ReadBit()
- if _noWdErr != nil {
- return nil, errors.New("Error parsing 'noWd' field " + _noWdErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(noWd)
-
- // Simple Field (noYear)
- noYear, _noYearErr := io.ReadBit()
- if _noYearErr != nil {
- return nil, errors.New("Error parsing 'noYear' field " + _noYearErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(noYear)
-
- // Simple Field (noDate)
- noDate, _noDateErr := io.ReadBit()
- if _noDateErr != nil {
- return nil, errors.New("Error parsing 'noDate' field " + _noDateErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(noDate)
-
- // Simple Field (noDayOfWeek)
- noDayOfWeek, _noDayOfWeekErr := io.ReadBit()
- if _noDayOfWeekErr != nil {
- return nil, errors.New("Error parsing 'noDayOfWeek' field " + _noDayOfWeekErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(noDayOfWeek)
-
- // Simple Field (noTime)
- noTime, _noTimeErr := io.ReadBit()
- if _noTimeErr != nil {
- return nil, errors.New("Error parsing 'noTime' field " + _noTimeErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(noTime)
-
- // Simple Field (standardSummerTime)
- standardSummerTime, _standardSummerTimeErr := io.ReadBit()
- if _standardSummerTimeErr != nil {
- return nil, errors.New("Error parsing 'standardSummerTime' field " + _standardSummerTimeErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(standardSummerTime)
-
- // Simple Field (qualityOfClock)
- qualityOfClock, _qualityOfClockErr := io.ReadBit()
- if _qualityOfClockErr != nil {
- return nil, errors.New("Error parsing 'qualityOfClock' field " + _qualityOfClockErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(qualityOfClock)
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(7); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_SCLOMode: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_BuildingMode: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_OccMode: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_Priority: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_LightApplicationMode: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_ApplicationArea: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_AlarmClassType: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_PSUMode: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_ErrorClass_System: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_ErrorClass_HVAC: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_Time_Delay: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_Beaufort_Wind_Force_Scale: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_SensorSelect: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_ActuatorConnectType: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_Cloud_Cover: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_PowerReturnMode: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_FuelType: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_BurnerType: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_HVACMode: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_DHWMode: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_LoadPriority: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_HVACContrMode: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_HVACEmergMode: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_ChangeoverMode: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_ValveMode: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_DamperMode: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_HeaterMode: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_FanMode: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_MasterSlaveMode: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_StatusRoomSetp: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_Metering_DeviceType: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_HumDehumMode: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_EnableHCStage: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_ADAType: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_BackupMode: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_StartSynchronization: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_Behaviour_Lock_Unlock: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_Behaviour_Bus_Power_Up_Down: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_DALI_Fade_Time: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_BlinkingMode: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_LightControlMode: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_SwitchPBModel: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_PBAction: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_DimmPBModel: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_SwitchOnMode: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_LoadTypeSet: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_LoadTypeDetected: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_Converter_Test_Control: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_SABExcept_Behaviour: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_SABBehaviour_Lock_Unlock: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_SSSBMode: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_BlindsControlMode: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_CommMode: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_AddInfoTypes: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_RF_ModeSelect: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_RF_FilterSelect: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(8)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_StatusGen: // Struct
- _map := map[string]api.PlcValue{}
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(3); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (alarmStatusOfCorrespondingDatapointIsNotAcknowledged)
- alarmStatusOfCorrespondingDatapointIsNotAcknowledged, _alarmStatusOfCorrespondingDatapointIsNotAcknowledgedErr := io.ReadBit()
- if _alarmStatusOfCorrespondingDatapointIsNotAcknowledgedErr != nil {
- return nil, errors.New("Error parsing 'alarmStatusOfCorrespondingDatapointIsNotAcknowledged' field " + _alarmStatusOfCorrespondingDatapointIsNotAcknowledgedErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(alarmStatusOfCorrespondingDatapointIsNotAcknowledged)
-
- // Simple Field (correspondingDatapointIsInAlarm)
- correspondingDatapointIsInAlarm, _correspondingDatapointIsInAlarmErr := io.ReadBit()
- if _correspondingDatapointIsInAlarmErr != nil {
- return nil, errors.New("Error parsing 'correspondingDatapointIsInAlarm' field " + _correspondingDatapointIsInAlarmErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(correspondingDatapointIsInAlarm)
-
- // Simple Field (correspondingDatapointMainValueIsOverridden)
- correspondingDatapointMainValueIsOverridden, _correspondingDatapointMainValueIsOverriddenErr := io.ReadBit()
- if _correspondingDatapointMainValueIsOverriddenErr != nil {
- return nil, errors.New("Error parsing 'correspondingDatapointMainValueIsOverridden' field " + _correspondingDatapointMainValueIsOverriddenErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(correspondingDatapointMainValueIsOverridden)
-
- // Simple Field (correspondingDatapointMainValueIsCorruptedDueToFailure)
- correspondingDatapointMainValueIsCorruptedDueToFailure, _correspondingDatapointMainValueIsCorruptedDueToFailureErr := io.ReadBit()
- if _correspondingDatapointMainValueIsCorruptedDueToFailureErr != nil {
- return nil, errors.New("Error parsing 'correspondingDatapointMainValueIsCorruptedDueToFailure' field " + _correspondingDatapointMainValueIsCorruptedDueToFailureErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(correspondingDatapointMainValueIsCorruptedDueToFailure)
-
- // Simple Field (correspondingDatapointValueIsOutOfService)
- correspondingDatapointValueIsOutOfService, _correspondingDatapointValueIsOutOfServiceErr := io.ReadBit()
- if _correspondingDatapointValueIsOutOfServiceErr != nil {
- return nil, errors.New("Error parsing 'correspondingDatapointValueIsOutOfService' field " + _correspondingDatapointValueIsOutOfServiceErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(correspondingDatapointValueIsOutOfService)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_Device_Control: // Struct
- _map := map[string]api.PlcValue{}
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(5); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (verifyModeIsOn)
- verifyModeIsOn, _verifyModeIsOnErr := io.ReadBit()
- if _verifyModeIsOnErr != nil {
- return nil, errors.New("Error parsing 'verifyModeIsOn' field " + _verifyModeIsOnErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(verifyModeIsOn)
-
- // Simple Field (aDatagramWithTheOwnIndividualAddressAsSourceAddressHasBeenReceived)
- aDatagramWithTheOwnIndividualAddressAsSourceAddressHasBeenReceived, _aDatagramWithTheOwnIndividualAddressAsSourceAddressHasBeenReceivedErr := io.ReadBit()
- if _aDatagramWithTheOwnIndividualAddressAsSourceAddressHasBeenReceivedErr != nil {
- return nil, errors.New("Error parsing 'aDatagramWithTheOwnIndividualAddressAsSourceAddressHasBeenReceived' field " + _aDatagramWithTheOwnIndividualAddressAsSourceAddressHasBeenReceivedErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(aDatagramWithTheOwnIndividualAddressAsSourceAddressHasBeenReceived)
-
- // Simple Field (theUserApplicationIsStopped)
- theUserApplicationIsStopped, _theUserApplicationIsStoppedErr := io.ReadBit()
- if _theUserApplicationIsStoppedErr != nil {
- return nil, errors.New("Error parsing 'theUserApplicationIsStopped' field " + _theUserApplicationIsStoppedErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(theUserApplicationIsStopped)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_ForceSign: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (roomhmax)
- roomhmax, _roomhmaxErr := io.ReadBit()
- if _roomhmaxErr != nil {
- return nil, errors.New("Error parsing 'roomhmax' field " + _roomhmaxErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(roomhmax)
-
- // Simple Field (roomhconf)
- roomhconf, _roomhconfErr := io.ReadBit()
- if _roomhconfErr != nil {
- return nil, errors.New("Error parsing 'roomhconf' field " + _roomhconfErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(roomhconf)
-
- // Simple Field (dhwlegio)
- dhwlegio, _dhwlegioErr := io.ReadBit()
- if _dhwlegioErr != nil {
- return nil, errors.New("Error parsing 'dhwlegio' field " + _dhwlegioErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(dhwlegio)
-
- // Simple Field (dhwnorm)
- dhwnorm, _dhwnormErr := io.ReadBit()
- if _dhwnormErr != nil {
- return nil, errors.New("Error parsing 'dhwnorm' field " + _dhwnormErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(dhwnorm)
-
- // Simple Field (overrun)
- overrun, _overrunErr := io.ReadBit()
- if _overrunErr != nil {
- return nil, errors.New("Error parsing 'overrun' field " + _overrunErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(overrun)
-
- // Simple Field (oversupply)
- oversupply, _oversupplyErr := io.ReadBit()
- if _oversupplyErr != nil {
- return nil, errors.New("Error parsing 'oversupply' field " + _oversupplyErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(oversupply)
-
- // Simple Field (protection)
- protection, _protectionErr := io.ReadBit()
- if _protectionErr != nil {
- return nil, errors.New("Error parsing 'protection' field " + _protectionErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(protection)
-
- // Simple Field (forcerequest)
- forcerequest, _forcerequestErr := io.ReadBit()
- if _forcerequestErr != nil {
- return nil, errors.New("Error parsing 'forcerequest' field " + _forcerequestErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(forcerequest)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_ForceSignCool: // BOOL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(7); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadBit()
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcBOOL(value), nil
- case datapointType == KnxDatapointType_DPT_StatusRHC: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (summermode)
- summermode, _summermodeErr := io.ReadBit()
- if _summermodeErr != nil {
- return nil, errors.New("Error parsing 'summermode' field " + _summermodeErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(summermode)
-
- // Simple Field (statusstopoptim)
- statusstopoptim, _statusstopoptimErr := io.ReadBit()
- if _statusstopoptimErr != nil {
- return nil, errors.New("Error parsing 'statusstopoptim' field " + _statusstopoptimErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(statusstopoptim)
-
- // Simple Field (statusstartoptim)
- statusstartoptim, _statusstartoptimErr := io.ReadBit()
- if _statusstartoptimErr != nil {
- return nil, errors.New("Error parsing 'statusstartoptim' field " + _statusstartoptimErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(statusstartoptim)
-
- // Simple Field (statusmorningboost)
- statusmorningboost, _statusmorningboostErr := io.ReadBit()
- if _statusmorningboostErr != nil {
- return nil, errors.New("Error parsing 'statusmorningboost' field " + _statusmorningboostErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(statusmorningboost)
-
- // Simple Field (tempreturnlimit)
- tempreturnlimit, _tempreturnlimitErr := io.ReadBit()
- if _tempreturnlimitErr != nil {
- return nil, errors.New("Error parsing 'tempreturnlimit' field " + _tempreturnlimitErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(tempreturnlimit)
-
- // Simple Field (tempflowlimit)
- tempflowlimit, _tempflowlimitErr := io.ReadBit()
- if _tempflowlimitErr != nil {
- return nil, errors.New("Error parsing 'tempflowlimit' field " + _tempflowlimitErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(tempflowlimit)
-
- // Simple Field (satuseco)
- satuseco, _satusecoErr := io.ReadBit()
- if _satusecoErr != nil {
- return nil, errors.New("Error parsing 'satuseco' field " + _satusecoErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(satuseco)
-
- // Simple Field (fault)
- fault, _faultErr := io.ReadBit()
- if _faultErr != nil {
- return nil, errors.New("Error parsing 'fault' field " + _faultErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(fault)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_StatusSDHWC: // Struct
- _map := map[string]api.PlcValue{}
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(5); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (solarloadsufficient)
- solarloadsufficient, _solarloadsufficientErr := io.ReadBit()
- if _solarloadsufficientErr != nil {
- return nil, errors.New("Error parsing 'solarloadsufficient' field " + _solarloadsufficientErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(solarloadsufficient)
-
- // Simple Field (sdhwloadactive)
- sdhwloadactive, _sdhwloadactiveErr := io.ReadBit()
- if _sdhwloadactiveErr != nil {
- return nil, errors.New("Error parsing 'sdhwloadactive' field " + _sdhwloadactiveErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(sdhwloadactive)
-
- // Simple Field (fault)
- fault, _faultErr := io.ReadBit()
- if _faultErr != nil {
- return nil, errors.New("Error parsing 'fault' field " + _faultErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(fault)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_FuelTypeSet: // Struct
- _map := map[string]api.PlcValue{}
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(5); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (solidstate)
- solidstate, _solidstateErr := io.ReadBit()
- if _solidstateErr != nil {
- return nil, errors.New("Error parsing 'solidstate' field " + _solidstateErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(solidstate)
-
- // Simple Field (gas)
- gas, _gasErr := io.ReadBit()
- if _gasErr != nil {
- return nil, errors.New("Error parsing 'gas' field " + _gasErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(gas)
-
- // Simple Field (oil)
- oil, _oilErr := io.ReadBit()
- if _oilErr != nil {
- return nil, errors.New("Error parsing 'oil' field " + _oilErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(oil)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_StatusRCC: // BOOL
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(7); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadBit()
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcBOOL(value), nil
- case datapointType == KnxDatapointType_DPT_StatusAHU: // Struct
- _map := map[string]api.PlcValue{}
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(4); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (cool)
- cool, _coolErr := io.ReadBit()
- if _coolErr != nil {
- return nil, errors.New("Error parsing 'cool' field " + _coolErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(cool)
-
- // Simple Field (heat)
- heat, _heatErr := io.ReadBit()
- if _heatErr != nil {
- return nil, errors.New("Error parsing 'heat' field " + _heatErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(heat)
-
- // Simple Field (fanactive)
- fanactive, _fanactiveErr := io.ReadBit()
- if _fanactiveErr != nil {
- return nil, errors.New("Error parsing 'fanactive' field " + _fanactiveErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(fanactive)
-
- // Simple Field (fault)
- fault, _faultErr := io.ReadBit()
- if _faultErr != nil {
- return nil, errors.New("Error parsing 'fault' field " + _faultErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(fault)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_CombinedStatus_RTSM: // Struct
- _map := map[string]api.PlcValue{}
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(3); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (statusOfHvacModeUser)
- statusOfHvacModeUser, _statusOfHvacModeUserErr := io.ReadBit()
- if _statusOfHvacModeUserErr != nil {
- return nil, errors.New("Error parsing 'statusOfHvacModeUser' field " + _statusOfHvacModeUserErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(statusOfHvacModeUser)
-
- // Simple Field (statusOfComfortProlongationUser)
- statusOfComfortProlongationUser, _statusOfComfortProlongationUserErr := io.ReadBit()
- if _statusOfComfortProlongationUserErr != nil {
- return nil, errors.New("Error parsing 'statusOfComfortProlongationUser' field " + _statusOfComfortProlongationUserErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(statusOfComfortProlongationUser)
-
- // Simple Field (effectiveValueOfTheComfortPushButton)
- effectiveValueOfTheComfortPushButton, _effectiveValueOfTheComfortPushButtonErr := io.ReadBit()
- if _effectiveValueOfTheComfortPushButtonErr != nil {
- return nil, errors.New("Error parsing 'effectiveValueOfTheComfortPushButton' field " + _effectiveValueOfTheComfortPushButtonErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(effectiveValueOfTheComfortPushButton)
-
- // Simple Field (effectiveValueOfThePresenceStatus)
- effectiveValueOfThePresenceStatus, _effectiveValueOfThePresenceStatusErr := io.ReadBit()
- if _effectiveValueOfThePresenceStatusErr != nil {
- return nil, errors.New("Error parsing 'effectiveValueOfThePresenceStatus' field " + _effectiveValueOfThePresenceStatusErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(effectiveValueOfThePresenceStatus)
-
- // Simple Field (effectiveValueOfTheWindowStatus)
- effectiveValueOfTheWindowStatus, _effectiveValueOfTheWindowStatusErr := io.ReadBit()
- if _effectiveValueOfTheWindowStatusErr != nil {
- return nil, errors.New("Error parsing 'effectiveValueOfTheWindowStatus' field " + _effectiveValueOfTheWindowStatusErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(effectiveValueOfTheWindowStatus)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_LightActuatorErrorInfo: // Struct
- _map := map[string]api.PlcValue{}
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(1); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (overheat)
- overheat, _overheatErr := io.ReadBit()
- if _overheatErr != nil {
- return nil, errors.New("Error parsing 'overheat' field " + _overheatErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(overheat)
-
- // Simple Field (lampfailure)
- lampfailure, _lampfailureErr := io.ReadBit()
- if _lampfailureErr != nil {
- return nil, errors.New("Error parsing 'lampfailure' field " + _lampfailureErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(lampfailure)
-
- // Simple Field (defectiveload)
- defectiveload, _defectiveloadErr := io.ReadBit()
- if _defectiveloadErr != nil {
- return nil, errors.New("Error parsing 'defectiveload' field " + _defectiveloadErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(defectiveload)
-
- // Simple Field (underload)
- underload, _underloadErr := io.ReadBit()
- if _underloadErr != nil {
- return nil, errors.New("Error parsing 'underload' field " + _underloadErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(underload)
-
- // Simple Field (overcurrent)
- overcurrent, _overcurrentErr := io.ReadBit()
- if _overcurrentErr != nil {
- return nil, errors.New("Error parsing 'overcurrent' field " + _overcurrentErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(overcurrent)
-
- // Simple Field (undervoltage)
- undervoltage, _undervoltageErr := io.ReadBit()
- if _undervoltageErr != nil {
- return nil, errors.New("Error parsing 'undervoltage' field " + _undervoltageErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(undervoltage)
-
- // Simple Field (loaddetectionerror)
- loaddetectionerror, _loaddetectionerrorErr := io.ReadBit()
- if _loaddetectionerrorErr != nil {
- return nil, errors.New("Error parsing 'loaddetectionerror' field " + _loaddetectionerrorErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(loaddetectionerror)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_RF_ModeInfo: // Struct
- _map := map[string]api.PlcValue{}
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(5); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (bibatSlave)
- bibatSlave, _bibatSlaveErr := io.ReadBit()
- if _bibatSlaveErr != nil {
- return nil, errors.New("Error parsing 'bibatSlave' field " + _bibatSlaveErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(bibatSlave)
-
- // Simple Field (bibatMaster)
- bibatMaster, _bibatMasterErr := io.ReadBit()
- if _bibatMasterErr != nil {
- return nil, errors.New("Error parsing 'bibatMaster' field " + _bibatMasterErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(bibatMaster)
-
- // Simple Field (asynchronous)
- asynchronous, _asynchronousErr := io.ReadBit()
- if _asynchronousErr != nil {
- return nil, errors.New("Error parsing 'asynchronous' field " + _asynchronousErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(asynchronous)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_RF_FilterInfo: // Struct
- _map := map[string]api.PlcValue{}
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(5); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (doa)
- doa, _doaErr := io.ReadBit()
- if _doaErr != nil {
- return nil, errors.New("Error parsing 'doa' field " + _doaErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(doa)
-
- // Simple Field (knxSn)
- knxSn, _knxSnErr := io.ReadBit()
- if _knxSnErr != nil {
- return nil, errors.New("Error parsing 'knxSn' field " + _knxSnErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(knxSn)
-
- // Simple Field (doaAndKnxSn)
- doaAndKnxSn, _doaAndKnxSnErr := io.ReadBit()
- if _doaAndKnxSnErr != nil {
- return nil, errors.New("Error parsing 'doaAndKnxSn' field " + _doaAndKnxSnErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(doaAndKnxSn)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_Channel_Activation_8: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (activationStateOfChannel1)
- activationStateOfChannel1, _activationStateOfChannel1Err := io.ReadBit()
- if _activationStateOfChannel1Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel1' field " + _activationStateOfChannel1Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel1)
-
- // Simple Field (activationStateOfChannel2)
- activationStateOfChannel2, _activationStateOfChannel2Err := io.ReadBit()
- if _activationStateOfChannel2Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel2' field " + _activationStateOfChannel2Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel2)
-
- // Simple Field (activationStateOfChannel3)
- activationStateOfChannel3, _activationStateOfChannel3Err := io.ReadBit()
- if _activationStateOfChannel3Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel3' field " + _activationStateOfChannel3Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel3)
-
- // Simple Field (activationStateOfChannel4)
- activationStateOfChannel4, _activationStateOfChannel4Err := io.ReadBit()
- if _activationStateOfChannel4Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel4' field " + _activationStateOfChannel4Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel4)
-
- // Simple Field (activationStateOfChannel5)
- activationStateOfChannel5, _activationStateOfChannel5Err := io.ReadBit()
- if _activationStateOfChannel5Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel5' field " + _activationStateOfChannel5Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel5)
-
- // Simple Field (activationStateOfChannel6)
- activationStateOfChannel6, _activationStateOfChannel6Err := io.ReadBit()
- if _activationStateOfChannel6Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel6' field " + _activationStateOfChannel6Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel6)
-
- // Simple Field (activationStateOfChannel7)
- activationStateOfChannel7, _activationStateOfChannel7Err := io.ReadBit()
- if _activationStateOfChannel7Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel7' field " + _activationStateOfChannel7Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel7)
-
- // Simple Field (activationStateOfChannel8)
- activationStateOfChannel8, _activationStateOfChannel8Err := io.ReadBit()
- if _activationStateOfChannel8Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel8' field " + _activationStateOfChannel8Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel8)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_StatusDHWC: // Struct
- _map := map[string]api.PlcValue{}
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (tempoptimshiftactive)
- tempoptimshiftactive, _tempoptimshiftactiveErr := io.ReadBit()
- if _tempoptimshiftactiveErr != nil {
- return nil, errors.New("Error parsing 'tempoptimshiftactive' field " + _tempoptimshiftactiveErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(tempoptimshiftactive)
-
- // Simple Field (solarenergysupport)
- solarenergysupport, _solarenergysupportErr := io.ReadBit()
- if _solarenergysupportErr != nil {
- return nil, errors.New("Error parsing 'solarenergysupport' field " + _solarenergysupportErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(solarenergysupport)
-
- // Simple Field (solarenergyonly)
- solarenergyonly, _solarenergyonlyErr := io.ReadBit()
- if _solarenergyonlyErr != nil {
- return nil, errors.New("Error parsing 'solarenergyonly' field " + _solarenergyonlyErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(solarenergyonly)
-
- // Simple Field (otherenergysourceactive)
- otherenergysourceactive, _otherenergysourceactiveErr := io.ReadBit()
- if _otherenergysourceactiveErr != nil {
- return nil, errors.New("Error parsing 'otherenergysourceactive' field " + _otherenergysourceactiveErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(otherenergysourceactive)
-
- // Simple Field (dhwpushactive)
- dhwpushactive, _dhwpushactiveErr := io.ReadBit()
- if _dhwpushactiveErr != nil {
- return nil, errors.New("Error parsing 'dhwpushactive' field " + _dhwpushactiveErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(dhwpushactive)
-
- // Simple Field (legioprotactive)
- legioprotactive, _legioprotactiveErr := io.ReadBit()
- if _legioprotactiveErr != nil {
- return nil, errors.New("Error parsing 'legioprotactive' field " + _legioprotactiveErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(legioprotactive)
-
- // Simple Field (dhwloadactive)
- dhwloadactive, _dhwloadactiveErr := io.ReadBit()
- if _dhwloadactiveErr != nil {
- return nil, errors.New("Error parsing 'dhwloadactive' field " + _dhwloadactiveErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(dhwloadactive)
-
- // Simple Field (fault)
- fault, _faultErr := io.ReadBit()
- if _faultErr != nil {
- return nil, errors.New("Error parsing 'fault' field " + _faultErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(fault)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_StatusRHCC: // Struct
- _map := map[string]api.PlcValue{}
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(1); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (overheatalarm)
- overheatalarm, _overheatalarmErr := io.ReadBit()
- if _overheatalarmErr != nil {
- return nil, errors.New("Error parsing 'overheatalarm' field " + _overheatalarmErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(overheatalarm)
-
- // Simple Field (frostalarm)
- frostalarm, _frostalarmErr := io.ReadBit()
- if _frostalarmErr != nil {
- return nil, errors.New("Error parsing 'frostalarm' field " + _frostalarmErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(frostalarm)
-
- // Simple Field (dewpointstatus)
- dewpointstatus, _dewpointstatusErr := io.ReadBit()
- if _dewpointstatusErr != nil {
- return nil, errors.New("Error parsing 'dewpointstatus' field " + _dewpointstatusErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(dewpointstatus)
-
- // Simple Field (coolingdisabled)
- coolingdisabled, _coolingdisabledErr := io.ReadBit()
- if _coolingdisabledErr != nil {
- return nil, errors.New("Error parsing 'coolingdisabled' field " + _coolingdisabledErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(coolingdisabled)
-
- // Simple Field (statusprecool)
- statusprecool, _statusprecoolErr := io.ReadBit()
- if _statusprecoolErr != nil {
- return nil, errors.New("Error parsing 'statusprecool' field " + _statusprecoolErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(statusprecool)
-
- // Simple Field (statusecoc)
- statusecoc, _statusecocErr := io.ReadBit()
- if _statusecocErr != nil {
- return nil, errors.New("Error parsing 'statusecoc' field " + _statusecocErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(statusecoc)
-
- // Simple Field (heatcoolmode)
- heatcoolmode, _heatcoolmodeErr := io.ReadBit()
- if _heatcoolmodeErr != nil {
- return nil, errors.New("Error parsing 'heatcoolmode' field " + _heatcoolmodeErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(heatcoolmode)
-
- // Simple Field (heatingdiabled)
- heatingdiabled, _heatingdiabledErr := io.ReadBit()
- if _heatingdiabledErr != nil {
- return nil, errors.New("Error parsing 'heatingdiabled' field " + _heatingdiabledErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(heatingdiabled)
-
- // Simple Field (statusstopoptim)
- statusstopoptim, _statusstopoptimErr := io.ReadBit()
- if _statusstopoptimErr != nil {
- return nil, errors.New("Error parsing 'statusstopoptim' field " + _statusstopoptimErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(statusstopoptim)
-
- // Simple Field (statusstartoptim)
- statusstartoptim, _statusstartoptimErr := io.ReadBit()
- if _statusstartoptimErr != nil {
- return nil, errors.New("Error parsing 'statusstartoptim' field " + _statusstartoptimErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(statusstartoptim)
-
- // Simple Field (statusmorningboosth)
- statusmorningboosth, _statusmorningboosthErr := io.ReadBit()
- if _statusmorningboosthErr != nil {
- return nil, errors.New("Error parsing 'statusmorningboosth' field " + _statusmorningboosthErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(statusmorningboosth)
-
- // Simple Field (tempflowreturnlimit)
- tempflowreturnlimit, _tempflowreturnlimitErr := io.ReadBit()
- if _tempflowreturnlimitErr != nil {
- return nil, errors.New("Error parsing 'tempflowreturnlimit' field " + _tempflowreturnlimitErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(tempflowreturnlimit)
-
- // Simple Field (tempflowlimit)
- tempflowlimit, _tempflowlimitErr := io.ReadBit()
- if _tempflowlimitErr != nil {
- return nil, errors.New("Error parsing 'tempflowlimit' field " + _tempflowlimitErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(tempflowlimit)
-
- // Simple Field (statusecoh)
- statusecoh, _statusecohErr := io.ReadBit()
- if _statusecohErr != nil {
- return nil, errors.New("Error parsing 'statusecoh' field " + _statusecohErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(statusecoh)
-
- // Simple Field (fault)
- fault, _faultErr := io.ReadBit()
- if _faultErr != nil {
- return nil, errors.New("Error parsing 'fault' field " + _faultErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(fault)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_CombinedStatus_HVA: // Struct
- _map := map[string]api.PlcValue{}
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(7); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (calibrationMode)
- calibrationMode, _calibrationModeErr := io.ReadBit()
- if _calibrationModeErr != nil {
- return nil, errors.New("Error parsing 'calibrationMode' field " + _calibrationModeErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(calibrationMode)
-
- // Simple Field (lockedPosition)
- lockedPosition, _lockedPositionErr := io.ReadBit()
- if _lockedPositionErr != nil {
- return nil, errors.New("Error parsing 'lockedPosition' field " + _lockedPositionErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(lockedPosition)
-
- // Simple Field (forcedPosition)
- forcedPosition, _forcedPositionErr := io.ReadBit()
- if _forcedPositionErr != nil {
- return nil, errors.New("Error parsing 'forcedPosition' field " + _forcedPositionErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(forcedPosition)
-
- // Simple Field (manuaOperationOverridden)
- manuaOperationOverridden, _manuaOperationOverriddenErr := io.ReadBit()
- if _manuaOperationOverriddenErr != nil {
- return nil, errors.New("Error parsing 'manuaOperationOverridden' field " + _manuaOperationOverriddenErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(manuaOperationOverridden)
-
- // Simple Field (serviceMode)
- serviceMode, _serviceModeErr := io.ReadBit()
- if _serviceModeErr != nil {
- return nil, errors.New("Error parsing 'serviceMode' field " + _serviceModeErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(serviceMode)
-
- // Simple Field (valveKick)
- valveKick, _valveKickErr := io.ReadBit()
- if _valveKickErr != nil {
- return nil, errors.New("Error parsing 'valveKick' field " + _valveKickErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(valveKick)
-
- // Simple Field (overload)
- overload, _overloadErr := io.ReadBit()
- if _overloadErr != nil {
- return nil, errors.New("Error parsing 'overload' field " + _overloadErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(overload)
-
- // Simple Field (shortCircuit)
- shortCircuit, _shortCircuitErr := io.ReadBit()
- if _shortCircuitErr != nil {
- return nil, errors.New("Error parsing 'shortCircuit' field " + _shortCircuitErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(shortCircuit)
-
- // Simple Field (currentValvePosition)
- currentValvePosition, _currentValvePositionErr := io.ReadBit()
- if _currentValvePositionErr != nil {
- return nil, errors.New("Error parsing 'currentValvePosition' field " + _currentValvePositionErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(currentValvePosition)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_CombinedStatus_RTC: // Struct
- _map := map[string]api.PlcValue{}
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(7); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (coolingModeEnabled)
- coolingModeEnabled, _coolingModeEnabledErr := io.ReadBit()
- if _coolingModeEnabledErr != nil {
- return nil, errors.New("Error parsing 'coolingModeEnabled' field " + _coolingModeEnabledErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(coolingModeEnabled)
-
- // Simple Field (heatingModeEnabled)
- heatingModeEnabled, _heatingModeEnabledErr := io.ReadBit()
- if _heatingModeEnabledErr != nil {
- return nil, errors.New("Error parsing 'heatingModeEnabled' field " + _heatingModeEnabledErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(heatingModeEnabled)
-
- // Simple Field (additionalHeatingCoolingStage2Stage)
- additionalHeatingCoolingStage2Stage, _additionalHeatingCoolingStage2StageErr := io.ReadBit()
- if _additionalHeatingCoolingStage2StageErr != nil {
- return nil, errors.New("Error parsing 'additionalHeatingCoolingStage2Stage' field " + _additionalHeatingCoolingStage2StageErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(additionalHeatingCoolingStage2Stage)
-
- // Simple Field (controllerInactive)
- controllerInactive, _controllerInactiveErr := io.ReadBit()
- if _controllerInactiveErr != nil {
- return nil, errors.New("Error parsing 'controllerInactive' field " + _controllerInactiveErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(controllerInactive)
-
- // Simple Field (overheatAlarm)
- overheatAlarm, _overheatAlarmErr := io.ReadBit()
- if _overheatAlarmErr != nil {
- return nil, errors.New("Error parsing 'overheatAlarm' field " + _overheatAlarmErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(overheatAlarm)
-
- // Simple Field (frostAlarm)
- frostAlarm, _frostAlarmErr := io.ReadBit()
- if _frostAlarmErr != nil {
- return nil, errors.New("Error parsing 'frostAlarm' field " + _frostAlarmErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(frostAlarm)
-
- // Simple Field (dewPointStatus)
- dewPointStatus, _dewPointStatusErr := io.ReadBit()
- if _dewPointStatusErr != nil {
- return nil, errors.New("Error parsing 'dewPointStatus' field " + _dewPointStatusErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(dewPointStatus)
-
- // Simple Field (activeMode)
- activeMode, _activeModeErr := io.ReadBit()
- if _activeModeErr != nil {
- return nil, errors.New("Error parsing 'activeMode' field " + _activeModeErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activeMode)
-
- // Simple Field (generalFailureInformation)
- generalFailureInformation, _generalFailureInformationErr := io.ReadBit()
- if _generalFailureInformationErr != nil {
- return nil, errors.New("Error parsing 'generalFailureInformation' field " + _generalFailureInformationErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(generalFailureInformation)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_Media: // Struct
- _map := map[string]api.PlcValue{}
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint16(10); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (knxIp)
- knxIp, _knxIpErr := io.ReadBit()
- if _knxIpErr != nil {
- return nil, errors.New("Error parsing 'knxIp' field " + _knxIpErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(knxIp)
-
- // Simple Field (rf)
- rf, _rfErr := io.ReadBit()
- if _rfErr != nil {
- return nil, errors.New("Error parsing 'rf' field " + _rfErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(rf)
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(1); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (pl110)
- pl110, _pl110Err := io.ReadBit()
- if _pl110Err != nil {
- return nil, errors.New("Error parsing 'pl110' field " + _pl110Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(pl110)
-
- // Simple Field (tp1)
- tp1, _tp1Err := io.ReadBit()
- if _tp1Err != nil {
- return nil, errors.New("Error parsing 'tp1' field " + _tp1Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(tp1)
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(1); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_Channel_Activation_16: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (activationStateOfChannel1)
- activationStateOfChannel1, _activationStateOfChannel1Err := io.ReadBit()
- if _activationStateOfChannel1Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel1' field " + _activationStateOfChannel1Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel1)
-
- // Simple Field (activationStateOfChannel2)
- activationStateOfChannel2, _activationStateOfChannel2Err := io.ReadBit()
- if _activationStateOfChannel2Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel2' field " + _activationStateOfChannel2Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel2)
-
- // Simple Field (activationStateOfChannel3)
- activationStateOfChannel3, _activationStateOfChannel3Err := io.ReadBit()
- if _activationStateOfChannel3Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel3' field " + _activationStateOfChannel3Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel3)
-
- // Simple Field (activationStateOfChannel4)
- activationStateOfChannel4, _activationStateOfChannel4Err := io.ReadBit()
- if _activationStateOfChannel4Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel4' field " + _activationStateOfChannel4Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel4)
-
- // Simple Field (activationStateOfChannel5)
- activationStateOfChannel5, _activationStateOfChannel5Err := io.ReadBit()
- if _activationStateOfChannel5Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel5' field " + _activationStateOfChannel5Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel5)
-
- // Simple Field (activationStateOfChannel6)
- activationStateOfChannel6, _activationStateOfChannel6Err := io.ReadBit()
- if _activationStateOfChannel6Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel6' field " + _activationStateOfChannel6Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel6)
-
- // Simple Field (activationStateOfChannel7)
- activationStateOfChannel7, _activationStateOfChannel7Err := io.ReadBit()
- if _activationStateOfChannel7Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel7' field " + _activationStateOfChannel7Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel7)
-
- // Simple Field (activationStateOfChannel8)
- activationStateOfChannel8, _activationStateOfChannel8Err := io.ReadBit()
- if _activationStateOfChannel8Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel8' field " + _activationStateOfChannel8Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel8)
-
- // Simple Field (activationStateOfChannel9)
- activationStateOfChannel9, _activationStateOfChannel9Err := io.ReadBit()
- if _activationStateOfChannel9Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel9' field " + _activationStateOfChannel9Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel9)
-
- // Simple Field (activationStateOfChannel10)
- activationStateOfChannel10, _activationStateOfChannel10Err := io.ReadBit()
- if _activationStateOfChannel10Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel10' field " + _activationStateOfChannel10Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel10)
-
- // Simple Field (activationStateOfChannel11)
- activationStateOfChannel11, _activationStateOfChannel11Err := io.ReadBit()
- if _activationStateOfChannel11Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel11' field " + _activationStateOfChannel11Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel11)
-
- // Simple Field (activationStateOfChannel12)
- activationStateOfChannel12, _activationStateOfChannel12Err := io.ReadBit()
- if _activationStateOfChannel12Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel12' field " + _activationStateOfChannel12Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel12)
-
- // Simple Field (activationStateOfChannel13)
- activationStateOfChannel13, _activationStateOfChannel13Err := io.ReadBit()
- if _activationStateOfChannel13Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel13' field " + _activationStateOfChannel13Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel13)
-
- // Simple Field (activationStateOfChannel14)
- activationStateOfChannel14, _activationStateOfChannel14Err := io.ReadBit()
- if _activationStateOfChannel14Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel14' field " + _activationStateOfChannel14Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel14)
-
- // Simple Field (activationStateOfChannel15)
- activationStateOfChannel15, _activationStateOfChannel15Err := io.ReadBit()
- if _activationStateOfChannel15Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel15' field " + _activationStateOfChannel15Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel15)
-
- // Simple Field (activationStateOfChannel16)
- activationStateOfChannel16, _activationStateOfChannel16Err := io.ReadBit()
- if _activationStateOfChannel16Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel16' field " + _activationStateOfChannel16Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel16)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_OnOffAction: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(6); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(2)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_Alarm_Reaction: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(6); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(2)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_UpDown_Action: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(6); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(2)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_HVAC_PB_Action: // USINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(6); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadUint8(2)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcUSINT(value), nil
- case datapointType == KnxDatapointType_DPT_DoubleNibble: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (busy)
- busy, _busyErr := io.ReadUint8(4)
- if _busyErr != nil {
- return nil, errors.New("Error parsing 'busy' field " + _busyErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(busy)
-
- // Simple Field (nak)
- nak, _nakErr := io.ReadUint8(4)
- if _nakErr != nil {
- return nil, errors.New("Error parsing 'nak' field " + _nakErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(nak)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_SceneInfo: // Struct
- _map := map[string]api.PlcValue{}
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(1); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (sceneIsInactive)
- sceneIsInactive, _sceneIsInactiveErr := io.ReadBit()
- if _sceneIsInactiveErr != nil {
- return nil, errors.New("Error parsing 'sceneIsInactive' field " + _sceneIsInactiveErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(sceneIsInactive)
-
- // Simple Field (scenenumber)
- scenenumber, _scenenumberErr := io.ReadUint8(6)
- if _scenenumberErr != nil {
- return nil, errors.New("Error parsing 'scenenumber' field " + _scenenumberErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(scenenumber)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_CombinedInfoOnOff: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (maskBitInfoOnOffOutput16)
- maskBitInfoOnOffOutput16, _maskBitInfoOnOffOutput16Err := io.ReadBit()
- if _maskBitInfoOnOffOutput16Err != nil {
- return nil, errors.New("Error parsing 'maskBitInfoOnOffOutput16' field " + _maskBitInfoOnOffOutput16Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(maskBitInfoOnOffOutput16)
-
- // Simple Field (maskBitInfoOnOffOutput15)
- maskBitInfoOnOffOutput15, _maskBitInfoOnOffOutput15Err := io.ReadBit()
- if _maskBitInfoOnOffOutput15Err != nil {
- return nil, errors.New("Error parsing 'maskBitInfoOnOffOutput15' field " + _maskBitInfoOnOffOutput15Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(maskBitInfoOnOffOutput15)
-
- // Simple Field (maskBitInfoOnOffOutput14)
- maskBitInfoOnOffOutput14, _maskBitInfoOnOffOutput14Err := io.ReadBit()
- if _maskBitInfoOnOffOutput14Err != nil {
- return nil, errors.New("Error parsing 'maskBitInfoOnOffOutput14' field " + _maskBitInfoOnOffOutput14Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(maskBitInfoOnOffOutput14)
-
- // Simple Field (maskBitInfoOnOffOutput13)
- maskBitInfoOnOffOutput13, _maskBitInfoOnOffOutput13Err := io.ReadBit()
- if _maskBitInfoOnOffOutput13Err != nil {
- return nil, errors.New("Error parsing 'maskBitInfoOnOffOutput13' field " + _maskBitInfoOnOffOutput13Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(maskBitInfoOnOffOutput13)
-
- // Simple Field (maskBitInfoOnOffOutput12)
- maskBitInfoOnOffOutput12, _maskBitInfoOnOffOutput12Err := io.ReadBit()
- if _maskBitInfoOnOffOutput12Err != nil {
- return nil, errors.New("Error parsing 'maskBitInfoOnOffOutput12' field " + _maskBitInfoOnOffOutput12Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(maskBitInfoOnOffOutput12)
-
- // Simple Field (maskBitInfoOnOffOutput11)
- maskBitInfoOnOffOutput11, _maskBitInfoOnOffOutput11Err := io.ReadBit()
- if _maskBitInfoOnOffOutput11Err != nil {
- return nil, errors.New("Error parsing 'maskBitInfoOnOffOutput11' field " + _maskBitInfoOnOffOutput11Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(maskBitInfoOnOffOutput11)
-
- // Simple Field (maskBitInfoOnOffOutput10)
- maskBitInfoOnOffOutput10, _maskBitInfoOnOffOutput10Err := io.ReadBit()
- if _maskBitInfoOnOffOutput10Err != nil {
- return nil, errors.New("Error parsing 'maskBitInfoOnOffOutput10' field " + _maskBitInfoOnOffOutput10Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(maskBitInfoOnOffOutput10)
-
- // Simple Field (maskBitInfoOnOffOutput9)
- maskBitInfoOnOffOutput9, _maskBitInfoOnOffOutput9Err := io.ReadBit()
- if _maskBitInfoOnOffOutput9Err != nil {
- return nil, errors.New("Error parsing 'maskBitInfoOnOffOutput9' field " + _maskBitInfoOnOffOutput9Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(maskBitInfoOnOffOutput9)
-
- // Simple Field (maskBitInfoOnOffOutput8)
- maskBitInfoOnOffOutput8, _maskBitInfoOnOffOutput8Err := io.ReadBit()
- if _maskBitInfoOnOffOutput8Err != nil {
- return nil, errors.New("Error parsing 'maskBitInfoOnOffOutput8' field " + _maskBitInfoOnOffOutput8Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(maskBitInfoOnOffOutput8)
-
- // Simple Field (maskBitInfoOnOffOutput7)
- maskBitInfoOnOffOutput7, _maskBitInfoOnOffOutput7Err := io.ReadBit()
- if _maskBitInfoOnOffOutput7Err != nil {
- return nil, errors.New("Error parsing 'maskBitInfoOnOffOutput7' field " + _maskBitInfoOnOffOutput7Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(maskBitInfoOnOffOutput7)
-
- // Simple Field (maskBitInfoOnOffOutput6)
- maskBitInfoOnOffOutput6, _maskBitInfoOnOffOutput6Err := io.ReadBit()
- if _maskBitInfoOnOffOutput6Err != nil {
- return nil, errors.New("Error parsing 'maskBitInfoOnOffOutput6' field " + _maskBitInfoOnOffOutput6Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(maskBitInfoOnOffOutput6)
-
- // Simple Field (maskBitInfoOnOffOutput5)
- maskBitInfoOnOffOutput5, _maskBitInfoOnOffOutput5Err := io.ReadBit()
- if _maskBitInfoOnOffOutput5Err != nil {
- return nil, errors.New("Error parsing 'maskBitInfoOnOffOutput5' field " + _maskBitInfoOnOffOutput5Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(maskBitInfoOnOffOutput5)
-
- // Simple Field (maskBitInfoOnOffOutput4)
- maskBitInfoOnOffOutput4, _maskBitInfoOnOffOutput4Err := io.ReadBit()
- if _maskBitInfoOnOffOutput4Err != nil {
- return nil, errors.New("Error parsing 'maskBitInfoOnOffOutput4' field " + _maskBitInfoOnOffOutput4Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(maskBitInfoOnOffOutput4)
-
- // Simple Field (maskBitInfoOnOffOutput3)
- maskBitInfoOnOffOutput3, _maskBitInfoOnOffOutput3Err := io.ReadBit()
- if _maskBitInfoOnOffOutput3Err != nil {
- return nil, errors.New("Error parsing 'maskBitInfoOnOffOutput3' field " + _maskBitInfoOnOffOutput3Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(maskBitInfoOnOffOutput3)
-
- // Simple Field (maskBitInfoOnOffOutput2)
- maskBitInfoOnOffOutput2, _maskBitInfoOnOffOutput2Err := io.ReadBit()
- if _maskBitInfoOnOffOutput2Err != nil {
- return nil, errors.New("Error parsing 'maskBitInfoOnOffOutput2' field " + _maskBitInfoOnOffOutput2Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(maskBitInfoOnOffOutput2)
-
- // Simple Field (maskBitInfoOnOffOutput1)
- maskBitInfoOnOffOutput1, _maskBitInfoOnOffOutput1Err := io.ReadBit()
- if _maskBitInfoOnOffOutput1Err != nil {
- return nil, errors.New("Error parsing 'maskBitInfoOnOffOutput1' field " + _maskBitInfoOnOffOutput1Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(maskBitInfoOnOffOutput1)
-
- // Simple Field (infoOnOffOutput16)
- infoOnOffOutput16, _infoOnOffOutput16Err := io.ReadBit()
- if _infoOnOffOutput16Err != nil {
- return nil, errors.New("Error parsing 'infoOnOffOutput16' field " + _infoOnOffOutput16Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(infoOnOffOutput16)
-
- // Simple Field (infoOnOffOutput15)
- infoOnOffOutput15, _infoOnOffOutput15Err := io.ReadBit()
- if _infoOnOffOutput15Err != nil {
- return nil, errors.New("Error parsing 'infoOnOffOutput15' field " + _infoOnOffOutput15Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(infoOnOffOutput15)
-
- // Simple Field (infoOnOffOutput14)
- infoOnOffOutput14, _infoOnOffOutput14Err := io.ReadBit()
- if _infoOnOffOutput14Err != nil {
- return nil, errors.New("Error parsing 'infoOnOffOutput14' field " + _infoOnOffOutput14Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(infoOnOffOutput14)
-
- // Simple Field (infoOnOffOutput13)
- infoOnOffOutput13, _infoOnOffOutput13Err := io.ReadBit()
- if _infoOnOffOutput13Err != nil {
- return nil, errors.New("Error parsing 'infoOnOffOutput13' field " + _infoOnOffOutput13Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(infoOnOffOutput13)
-
- // Simple Field (infoOnOffOutput12)
- infoOnOffOutput12, _infoOnOffOutput12Err := io.ReadBit()
- if _infoOnOffOutput12Err != nil {
- return nil, errors.New("Error parsing 'infoOnOffOutput12' field " + _infoOnOffOutput12Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(infoOnOffOutput12)
-
- // Simple Field (infoOnOffOutput11)
- infoOnOffOutput11, _infoOnOffOutput11Err := io.ReadBit()
- if _infoOnOffOutput11Err != nil {
- return nil, errors.New("Error parsing 'infoOnOffOutput11' field " + _infoOnOffOutput11Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(infoOnOffOutput11)
-
- // Simple Field (infoOnOffOutput10)
- infoOnOffOutput10, _infoOnOffOutput10Err := io.ReadBit()
- if _infoOnOffOutput10Err != nil {
- return nil, errors.New("Error parsing 'infoOnOffOutput10' field " + _infoOnOffOutput10Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(infoOnOffOutput10)
-
- // Simple Field (infoOnOffOutput9)
- infoOnOffOutput9, _infoOnOffOutput9Err := io.ReadBit()
- if _infoOnOffOutput9Err != nil {
- return nil, errors.New("Error parsing 'infoOnOffOutput9' field " + _infoOnOffOutput9Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(infoOnOffOutput9)
-
- // Simple Field (infoOnOffOutput8)
- infoOnOffOutput8, _infoOnOffOutput8Err := io.ReadBit()
- if _infoOnOffOutput8Err != nil {
- return nil, errors.New("Error parsing 'infoOnOffOutput8' field " + _infoOnOffOutput8Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(infoOnOffOutput8)
-
- // Simple Field (infoOnOffOutput7)
- infoOnOffOutput7, _infoOnOffOutput7Err := io.ReadBit()
- if _infoOnOffOutput7Err != nil {
- return nil, errors.New("Error parsing 'infoOnOffOutput7' field " + _infoOnOffOutput7Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(infoOnOffOutput7)
-
- // Simple Field (infoOnOffOutput6)
- infoOnOffOutput6, _infoOnOffOutput6Err := io.ReadBit()
- if _infoOnOffOutput6Err != nil {
- return nil, errors.New("Error parsing 'infoOnOffOutput6' field " + _infoOnOffOutput6Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(infoOnOffOutput6)
-
- // Simple Field (infoOnOffOutput5)
- infoOnOffOutput5, _infoOnOffOutput5Err := io.ReadBit()
- if _infoOnOffOutput5Err != nil {
- return nil, errors.New("Error parsing 'infoOnOffOutput5' field " + _infoOnOffOutput5Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(infoOnOffOutput5)
-
- // Simple Field (infoOnOffOutput4)
- infoOnOffOutput4, _infoOnOffOutput4Err := io.ReadBit()
- if _infoOnOffOutput4Err != nil {
- return nil, errors.New("Error parsing 'infoOnOffOutput4' field " + _infoOnOffOutput4Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(infoOnOffOutput4)
-
- // Simple Field (infoOnOffOutput3)
- infoOnOffOutput3, _infoOnOffOutput3Err := io.ReadBit()
- if _infoOnOffOutput3Err != nil {
- return nil, errors.New("Error parsing 'infoOnOffOutput3' field " + _infoOnOffOutput3Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(infoOnOffOutput3)
-
- // Simple Field (infoOnOffOutput2)
- infoOnOffOutput2, _infoOnOffOutput2Err := io.ReadBit()
- if _infoOnOffOutput2Err != nil {
- return nil, errors.New("Error parsing 'infoOnOffOutput2' field " + _infoOnOffOutput2Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(infoOnOffOutput2)
-
- // Simple Field (infoOnOffOutput1)
- infoOnOffOutput1, _infoOnOffOutput1Err := io.ReadBit()
- if _infoOnOffOutput1Err != nil {
- return nil, errors.New("Error parsing 'infoOnOffOutput1' field " + _infoOnOffOutput1Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(infoOnOffOutput1)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_ActiveEnergy_V64: // LINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadInt64(64)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcLINT(value), nil
- case datapointType == KnxDatapointType_DPT_ApparantEnergy_V64: // LINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadInt64(64)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcLINT(value), nil
- case datapointType == KnxDatapointType_DPT_ReactiveEnergy_V64: // LINT
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadInt64(64)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcLINT(value), nil
- case datapointType == KnxDatapointType_DPT_Channel_Activation_24: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (activationStateOfChannel1)
- activationStateOfChannel1, _activationStateOfChannel1Err := io.ReadBit()
- if _activationStateOfChannel1Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel1' field " + _activationStateOfChannel1Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel1)
-
- // Simple Field (activationStateOfChannel2)
- activationStateOfChannel2, _activationStateOfChannel2Err := io.ReadBit()
- if _activationStateOfChannel2Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel2' field " + _activationStateOfChannel2Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel2)
-
- // Simple Field (activationStateOfChannel3)
- activationStateOfChannel3, _activationStateOfChannel3Err := io.ReadBit()
- if _activationStateOfChannel3Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel3' field " + _activationStateOfChannel3Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel3)
-
- // Simple Field (activationStateOfChannel4)
- activationStateOfChannel4, _activationStateOfChannel4Err := io.ReadBit()
- if _activationStateOfChannel4Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel4' field " + _activationStateOfChannel4Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel4)
-
- // Simple Field (activationStateOfChannel5)
- activationStateOfChannel5, _activationStateOfChannel5Err := io.ReadBit()
- if _activationStateOfChannel5Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel5' field " + _activationStateOfChannel5Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel5)
-
- // Simple Field (activationStateOfChannel6)
- activationStateOfChannel6, _activationStateOfChannel6Err := io.ReadBit()
- if _activationStateOfChannel6Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel6' field " + _activationStateOfChannel6Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel6)
-
- // Simple Field (activationStateOfChannel7)
- activationStateOfChannel7, _activationStateOfChannel7Err := io.ReadBit()
- if _activationStateOfChannel7Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel7' field " + _activationStateOfChannel7Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel7)
-
- // Simple Field (activationStateOfChannel8)
- activationStateOfChannel8, _activationStateOfChannel8Err := io.ReadBit()
- if _activationStateOfChannel8Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel8' field " + _activationStateOfChannel8Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel8)
-
- // Simple Field (activationStateOfChannel9)
- activationStateOfChannel9, _activationStateOfChannel9Err := io.ReadBit()
- if _activationStateOfChannel9Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel9' field " + _activationStateOfChannel9Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel9)
-
- // Simple Field (activationStateOfChannel10)
- activationStateOfChannel10, _activationStateOfChannel10Err := io.ReadBit()
- if _activationStateOfChannel10Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel10' field " + _activationStateOfChannel10Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel10)
-
- // Simple Field (activationStateOfChannel11)
- activationStateOfChannel11, _activationStateOfChannel11Err := io.ReadBit()
- if _activationStateOfChannel11Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel11' field " + _activationStateOfChannel11Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel11)
-
- // Simple Field (activationStateOfChannel12)
- activationStateOfChannel12, _activationStateOfChannel12Err := io.ReadBit()
- if _activationStateOfChannel12Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel12' field " + _activationStateOfChannel12Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel12)
-
- // Simple Field (activationStateOfChannel13)
- activationStateOfChannel13, _activationStateOfChannel13Err := io.ReadBit()
- if _activationStateOfChannel13Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel13' field " + _activationStateOfChannel13Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel13)
-
- // Simple Field (activationStateOfChannel14)
- activationStateOfChannel14, _activationStateOfChannel14Err := io.ReadBit()
- if _activationStateOfChannel14Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel14' field " + _activationStateOfChannel14Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel14)
-
- // Simple Field (activationStateOfChannel15)
- activationStateOfChannel15, _activationStateOfChannel15Err := io.ReadBit()
- if _activationStateOfChannel15Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel15' field " + _activationStateOfChannel15Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel15)
-
- // Simple Field (activationStateOfChannel16)
- activationStateOfChannel16, _activationStateOfChannel16Err := io.ReadBit()
- if _activationStateOfChannel16Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel16' field " + _activationStateOfChannel16Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel16)
-
- // Simple Field (activationStateOfChannel17)
- activationStateOfChannel17, _activationStateOfChannel17Err := io.ReadBit()
- if _activationStateOfChannel17Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel17' field " + _activationStateOfChannel17Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel17)
-
- // Simple Field (activationStateOfChannel18)
- activationStateOfChannel18, _activationStateOfChannel18Err := io.ReadBit()
- if _activationStateOfChannel18Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel18' field " + _activationStateOfChannel18Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel18)
-
- // Simple Field (activationStateOfChannel19)
- activationStateOfChannel19, _activationStateOfChannel19Err := io.ReadBit()
- if _activationStateOfChannel19Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel19' field " + _activationStateOfChannel19Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel19)
-
- // Simple Field (activationStateOfChannel20)
- activationStateOfChannel20, _activationStateOfChannel20Err := io.ReadBit()
- if _activationStateOfChannel20Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel20' field " + _activationStateOfChannel20Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel20)
-
- // Simple Field (activationStateOfChannel21)
- activationStateOfChannel21, _activationStateOfChannel21Err := io.ReadBit()
- if _activationStateOfChannel21Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel21' field " + _activationStateOfChannel21Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel21)
-
- // Simple Field (activationStateOfChannel22)
- activationStateOfChannel22, _activationStateOfChannel22Err := io.ReadBit()
- if _activationStateOfChannel22Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel22' field " + _activationStateOfChannel22Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel22)
-
- // Simple Field (activationStateOfChannel23)
- activationStateOfChannel23, _activationStateOfChannel23Err := io.ReadBit()
- if _activationStateOfChannel23Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel23' field " + _activationStateOfChannel23Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel23)
-
- // Simple Field (activationStateOfChannel24)
- activationStateOfChannel24, _activationStateOfChannel24Err := io.ReadBit()
- if _activationStateOfChannel24Err != nil {
- return nil, errors.New("Error parsing 'activationStateOfChannel24' field " + _activationStateOfChannel24Err.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(activationStateOfChannel24)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_HVACModeNext: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (delayTimeMin)
- delayTimeMin, _delayTimeMinErr := io.ReadUint16(16)
- if _delayTimeMinErr != nil {
- return nil, errors.New("Error parsing 'delayTimeMin' field " + _delayTimeMinErr.Error())
- }
- _map["Struct"] = values.NewPlcUINT(delayTimeMin)
-
- // Simple Field (hvacMode)
- hvacMode, _hvacModeErr := io.ReadUint8(8)
- if _hvacModeErr != nil {
- return nil, errors.New("Error parsing 'hvacMode' field " + _hvacModeErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(hvacMode)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_DHWModeNext: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (delayTimeMin)
- delayTimeMin, _delayTimeMinErr := io.ReadUint16(16)
- if _delayTimeMinErr != nil {
- return nil, errors.New("Error parsing 'delayTimeMin' field " + _delayTimeMinErr.Error())
- }
- _map["Struct"] = values.NewPlcUINT(delayTimeMin)
-
- // Simple Field (dhwMode)
- dhwMode, _dhwModeErr := io.ReadUint8(8)
- if _dhwModeErr != nil {
- return nil, errors.New("Error parsing 'dhwMode' field " + _dhwModeErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(dhwMode)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_OccModeNext: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (delayTimeMin)
- delayTimeMin, _delayTimeMinErr := io.ReadUint16(16)
- if _delayTimeMinErr != nil {
- return nil, errors.New("Error parsing 'delayTimeMin' field " + _delayTimeMinErr.Error())
- }
- _map["Struct"] = values.NewPlcUINT(delayTimeMin)
-
- // Simple Field (occupancyMode)
- occupancyMode, _occupancyModeErr := io.ReadUint8(8)
- if _occupancyModeErr != nil {
- return nil, errors.New("Error parsing 'occupancyMode' field " + _occupancyModeErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(occupancyMode)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_BuildingModeNext: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (delayTimeMin)
- delayTimeMin, _delayTimeMinErr := io.ReadUint16(16)
- if _delayTimeMinErr != nil {
- return nil, errors.New("Error parsing 'delayTimeMin' field " + _delayTimeMinErr.Error())
- }
- _map["Struct"] = values.NewPlcUINT(delayTimeMin)
-
- // Simple Field (buildingMode)
- buildingMode, _buildingModeErr := io.ReadUint8(8)
- if _buildingModeErr != nil {
- return nil, errors.New("Error parsing 'buildingMode' field " + _buildingModeErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(buildingMode)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_Version: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (magicNumber)
- magicNumber, _magicNumberErr := io.ReadUint8(5)
- if _magicNumberErr != nil {
- return nil, errors.New("Error parsing 'magicNumber' field " + _magicNumberErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(magicNumber)
-
- // Simple Field (versionNumber)
- versionNumber, _versionNumberErr := io.ReadUint8(5)
- if _versionNumberErr != nil {
- return nil, errors.New("Error parsing 'versionNumber' field " + _versionNumberErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(versionNumber)
-
- // Simple Field (revisionNumber)
- revisionNumber, _revisionNumberErr := io.ReadUint8(6)
- if _revisionNumberErr != nil {
- return nil, errors.New("Error parsing 'revisionNumber' field " + _revisionNumberErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(revisionNumber)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_AlarmInfo: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (logNumber)
- logNumber, _logNumberErr := io.ReadUint8(8)
- if _logNumberErr != nil {
- return nil, errors.New("Error parsing 'logNumber' field " + _logNumberErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(logNumber)
-
- // Simple Field (alarmPriority)
- alarmPriority, _alarmPriorityErr := io.ReadUint8(8)
- if _alarmPriorityErr != nil {
- return nil, errors.New("Error parsing 'alarmPriority' field " + _alarmPriorityErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(alarmPriority)
-
- // Simple Field (applicationArea)
- applicationArea, _applicationAreaErr := io.ReadUint8(8)
- if _applicationAreaErr != nil {
- return nil, errors.New("Error parsing 'applicationArea' field " + _applicationAreaErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(applicationArea)
-
- // Simple Field (errorClass)
- errorClass, _errorClassErr := io.ReadUint8(8)
- if _errorClassErr != nil {
- return nil, errors.New("Error parsing 'errorClass' field " + _errorClassErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(errorClass)
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(4); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (errorcodeSup)
- errorcodeSup, _errorcodeSupErr := io.ReadBit()
- if _errorcodeSupErr != nil {
- return nil, errors.New("Error parsing 'errorcodeSup' field " + _errorcodeSupErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(errorcodeSup)
-
- // Simple Field (alarmtextSup)
- alarmtextSup, _alarmtextSupErr := io.ReadBit()
- if _alarmtextSupErr != nil {
- return nil, errors.New("Error parsing 'alarmtextSup' field " + _alarmtextSupErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(alarmtextSup)
-
- // Simple Field (timestampSup)
- timestampSup, _timestampSupErr := io.ReadBit()
- if _timestampSupErr != nil {
- return nil, errors.New("Error parsing 'timestampSup' field " + _timestampSupErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(timestampSup)
-
- // Simple Field (ackSup)
- ackSup, _ackSupErr := io.ReadBit()
- if _ackSupErr != nil {
- return nil, errors.New("Error parsing 'ackSup' field " + _ackSupErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(ackSup)
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(5); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (locked)
- locked, _lockedErr := io.ReadBit()
- if _lockedErr != nil {
- return nil, errors.New("Error parsing 'locked' field " + _lockedErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(locked)
-
- // Simple Field (alarmunack)
- alarmunack, _alarmunackErr := io.ReadBit()
- if _alarmunackErr != nil {
- return nil, errors.New("Error parsing 'alarmunack' field " + _alarmunackErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(alarmunack)
-
- // Simple Field (inalarm)
- inalarm, _inalarmErr := io.ReadBit()
- if _inalarmErr != nil {
- return nil, errors.New("Error parsing 'inalarm' field " + _inalarmErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(inalarm)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_TempRoomSetpSetF16_3: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (tempsetpcomf)
- tempsetpcomf, _tempsetpcomfErr := io.ReadFloat32(true, 4, 11)
- if _tempsetpcomfErr != nil {
- return nil, errors.New("Error parsing 'tempsetpcomf' field " + _tempsetpcomfErr.Error())
- }
- _map["Struct"] = values.NewPlcREAL(tempsetpcomf)
-
- // Simple Field (tempsetpstdby)
- tempsetpstdby, _tempsetpstdbyErr := io.ReadFloat32(true, 4, 11)
- if _tempsetpstdbyErr != nil {
- return nil, errors.New("Error parsing 'tempsetpstdby' field " + _tempsetpstdbyErr.Error())
- }
- _map["Struct"] = values.NewPlcREAL(tempsetpstdby)
-
- // Simple Field (tempsetpeco)
- tempsetpeco, _tempsetpecoErr := io.ReadFloat32(true, 4, 11)
- if _tempsetpecoErr != nil {
- return nil, errors.New("Error parsing 'tempsetpeco' field " + _tempsetpecoErr.Error())
- }
- _map["Struct"] = values.NewPlcREAL(tempsetpeco)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_TempRoomSetpSetShiftF16_3: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (tempsetpshiftcomf)
- tempsetpshiftcomf, _tempsetpshiftcomfErr := io.ReadFloat32(true, 4, 11)
- if _tempsetpshiftcomfErr != nil {
- return nil, errors.New("Error parsing 'tempsetpshiftcomf' field " + _tempsetpshiftcomfErr.Error())
- }
- _map["Struct"] = values.NewPlcREAL(tempsetpshiftcomf)
-
- // Simple Field (tempsetpshiftstdby)
- tempsetpshiftstdby, _tempsetpshiftstdbyErr := io.ReadFloat32(true, 4, 11)
- if _tempsetpshiftstdbyErr != nil {
- return nil, errors.New("Error parsing 'tempsetpshiftstdby' field " + _tempsetpshiftstdbyErr.Error())
- }
- _map["Struct"] = values.NewPlcREAL(tempsetpshiftstdby)
-
- // Simple Field (tempsetpshifteco)
- tempsetpshifteco, _tempsetpshiftecoErr := io.ReadFloat32(true, 4, 11)
- if _tempsetpshiftecoErr != nil {
- return nil, errors.New("Error parsing 'tempsetpshifteco' field " + _tempsetpshiftecoErr.Error())
- }
- _map["Struct"] = values.NewPlcREAL(tempsetpshifteco)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_Scaling_Speed: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (timePeriod)
- timePeriod, _timePeriodErr := io.ReadUint16(16)
- if _timePeriodErr != nil {
- return nil, errors.New("Error parsing 'timePeriod' field " + _timePeriodErr.Error())
- }
- _map["Struct"] = values.NewPlcUINT(timePeriod)
-
- // Simple Field (percent)
- percent, _percentErr := io.ReadUint8(8)
- if _percentErr != nil {
- return nil, errors.New("Error parsing 'percent' field " + _percentErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(percent)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_Scaling_Step_Time: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (timePeriod)
- timePeriod, _timePeriodErr := io.ReadUint16(16)
- if _timePeriodErr != nil {
- return nil, errors.New("Error parsing 'timePeriod' field " + _timePeriodErr.Error())
- }
- _map["Struct"] = values.NewPlcUINT(timePeriod)
-
- // Simple Field (percent)
- percent, _percentErr := io.ReadUint8(8)
- if _percentErr != nil {
- return nil, errors.New("Error parsing 'percent' field " + _percentErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(percent)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_MeteringValue: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (countval)
- countval, _countvalErr := io.ReadInt32(32)
- if _countvalErr != nil {
- return nil, errors.New("Error parsing 'countval' field " + _countvalErr.Error())
- }
- _map["Struct"] = values.NewPlcDINT(countval)
-
- // Simple Field (valinffield)
- valinffield, _valinffieldErr := io.ReadUint8(8)
- if _valinffieldErr != nil {
- return nil, errors.New("Error parsing 'valinffield' field " + _valinffieldErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(valinffield)
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(3); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (alarmunack)
- alarmunack, _alarmunackErr := io.ReadBit()
- if _alarmunackErr != nil {
- return nil, errors.New("Error parsing 'alarmunack' field " + _alarmunackErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(alarmunack)
-
- // Simple Field (inalarm)
- inalarm, _inalarmErr := io.ReadBit()
- if _inalarmErr != nil {
- return nil, errors.New("Error parsing 'inalarm' field " + _inalarmErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(inalarm)
-
- // Simple Field (overridden)
- overridden, _overriddenErr := io.ReadBit()
- if _overriddenErr != nil {
- return nil, errors.New("Error parsing 'overridden' field " + _overriddenErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(overridden)
-
- // Simple Field (fault)
- fault, _faultErr := io.ReadBit()
- if _faultErr != nil {
- return nil, errors.New("Error parsing 'fault' field " + _faultErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(fault)
-
- // Simple Field (outofservice)
- outofservice, _outofserviceErr := io.ReadBit()
- if _outofserviceErr != nil {
- return nil, errors.New("Error parsing 'outofservice' field " + _outofserviceErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(outofservice)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_MBus_Address: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (manufactid)
- manufactid, _manufactidErr := io.ReadUint16(16)
- if _manufactidErr != nil {
- return nil, errors.New("Error parsing 'manufactid' field " + _manufactidErr.Error())
- }
- _map["Struct"] = values.NewPlcUINT(manufactid)
-
- // Simple Field (identnumber)
- identnumber, _identnumberErr := io.ReadUint32(32)
- if _identnumberErr != nil {
- return nil, errors.New("Error parsing 'identnumber' field " + _identnumberErr.Error())
- }
- _map["Struct"] = values.NewPlcUDINT(identnumber)
-
- // Simple Field (version)
- version, _versionErr := io.ReadUint8(8)
- if _versionErr != nil {
- return nil, errors.New("Error parsing 'version' field " + _versionErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(version)
-
- // Simple Field (medium)
- medium, _mediumErr := io.ReadUint8(8)
- if _mediumErr != nil {
- return nil, errors.New("Error parsing 'medium' field " + _mediumErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(medium)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_Colour_RGB: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (r)
- r, _rErr := io.ReadUint8(8)
- if _rErr != nil {
- return nil, errors.New("Error parsing 'r' field " + _rErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(r)
-
- // Simple Field (g)
- g, _gErr := io.ReadUint8(8)
- if _gErr != nil {
- return nil, errors.New("Error parsing 'g' field " + _gErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(g)
-
- // Simple Field (b)
- b, _bErr := io.ReadUint8(8)
- if _bErr != nil {
- return nil, errors.New("Error parsing 'b' field " + _bErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(b)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_LanguageCodeAlpha2_ASCII: // STRING
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (value)
- value, _valueErr := io.ReadString(16)
- if _valueErr != nil {
- return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
- }
- return values.NewPlcSTRING(value), nil
- case datapointType == KnxDatapointType_DPT_Tariff_ActiveEnergy: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (activeelectricalenergy)
- activeelectricalenergy, _activeelectricalenergyErr := io.ReadInt32(32)
- if _activeelectricalenergyErr != nil {
- return nil, errors.New("Error parsing 'activeelectricalenergy' field " + _activeelectricalenergyErr.Error())
- }
- _map["Struct"] = values.NewPlcDINT(activeelectricalenergy)
-
- // Simple Field (tariff)
- tariff, _tariffErr := io.ReadUint8(8)
- if _tariffErr != nil {
- return nil, errors.New("Error parsing 'tariff' field " + _tariffErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(tariff)
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(6); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (electricalengergyvalidity)
- electricalengergyvalidity, _electricalengergyvalidityErr := io.ReadBit()
- if _electricalengergyvalidityErr != nil {
- return nil, errors.New("Error parsing 'electricalengergyvalidity' field " + _electricalengergyvalidityErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(electricalengergyvalidity)
-
- // Simple Field (tariffvalidity)
- tariffvalidity, _tariffvalidityErr := io.ReadBit()
- if _tariffvalidityErr != nil {
- return nil, errors.New("Error parsing 'tariffvalidity' field " + _tariffvalidityErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(tariffvalidity)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_Prioritised_Mode_Control: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (deactivationOfPriority)
- deactivationOfPriority, _deactivationOfPriorityErr := io.ReadBit()
- if _deactivationOfPriorityErr != nil {
- return nil, errors.New("Error parsing 'deactivationOfPriority' field " + _deactivationOfPriorityErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(deactivationOfPriority)
-
- // Simple Field (priorityLevel)
- priorityLevel, _priorityLevelErr := io.ReadUint8(3)
- if _priorityLevelErr != nil {
- return nil, errors.New("Error parsing 'priorityLevel' field " + _priorityLevelErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(priorityLevel)
-
- // Simple Field (modeLevel)
- modeLevel, _modeLevelErr := io.ReadUint8(4)
- if _modeLevelErr != nil {
- return nil, errors.New("Error parsing 'modeLevel' field " + _modeLevelErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(modeLevel)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_DALI_Control_Gear_Diagnostic: // Struct
- _map := map[string]api.PlcValue{}
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(5); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (convertorError)
- convertorError, _convertorErrorErr := io.ReadBit()
- if _convertorErrorErr != nil {
- return nil, errors.New("Error parsing 'convertorError' field " + _convertorErrorErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(convertorError)
-
- // Simple Field (ballastFailure)
- ballastFailure, _ballastFailureErr := io.ReadBit()
- if _ballastFailureErr != nil {
- return nil, errors.New("Error parsing 'ballastFailure' field " + _ballastFailureErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(ballastFailure)
-
- // Simple Field (lampFailure)
- lampFailure, _lampFailureErr := io.ReadBit()
- if _lampFailureErr != nil {
- return nil, errors.New("Error parsing 'lampFailure' field " + _lampFailureErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(lampFailure)
-
- // Simple Field (readOrResponse)
- readOrResponse, _readOrResponseErr := io.ReadBit()
- if _readOrResponseErr != nil {
- return nil, errors.New("Error parsing 'readOrResponse' field " + _readOrResponseErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(readOrResponse)
-
- // Simple Field (addressIndicator)
- addressIndicator, _addressIndicatorErr := io.ReadBit()
- if _addressIndicatorErr != nil {
- return nil, errors.New("Error parsing 'addressIndicator' field " + _addressIndicatorErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(addressIndicator)
-
- // Simple Field (daliDeviceAddressOrDaliGroupAddress)
- daliDeviceAddressOrDaliGroupAddress, _daliDeviceAddressOrDaliGroupAddressErr := io.ReadUint8(6)
- if _daliDeviceAddressOrDaliGroupAddressErr != nil {
- return nil, errors.New("Error parsing 'daliDeviceAddressOrDaliGroupAddress' field " + _daliDeviceAddressOrDaliGroupAddressErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(daliDeviceAddressOrDaliGroupAddress)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_DALI_Diagnostics: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (ballastFailure)
- ballastFailure, _ballastFailureErr := io.ReadBit()
- if _ballastFailureErr != nil {
- return nil, errors.New("Error parsing 'ballastFailure' field " + _ballastFailureErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(ballastFailure)
-
- // Simple Field (lampFailure)
- lampFailure, _lampFailureErr := io.ReadBit()
- if _lampFailureErr != nil {
- return nil, errors.New("Error parsing 'lampFailure' field " + _lampFailureErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(lampFailure)
-
- // Simple Field (deviceAddress)
- deviceAddress, _deviceAddressErr := io.ReadUint8(6)
- if _deviceAddressErr != nil {
- return nil, errors.New("Error parsing 'deviceAddress' field " + _deviceAddressErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(deviceAddress)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_CombinedPosition: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (heightPosition)
- heightPosition, _heightPositionErr := io.ReadUint8(8)
- if _heightPositionErr != nil {
- return nil, errors.New("Error parsing 'heightPosition' field " + _heightPositionErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(heightPosition)
-
- // Simple Field (slatsPosition)
- slatsPosition, _slatsPositionErr := io.ReadUint8(8)
- if _slatsPositionErr != nil {
- return nil, errors.New("Error parsing 'slatsPosition' field " + _slatsPositionErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(slatsPosition)
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(6); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (validityHeightPosition)
- validityHeightPosition, _validityHeightPositionErr := io.ReadBit()
- if _validityHeightPositionErr != nil {
- return nil, errors.New("Error parsing 'validityHeightPosition' field " + _validityHeightPositionErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(validityHeightPosition)
-
- // Simple Field (validitySlatsPosition)
- validitySlatsPosition, _validitySlatsPositionErr := io.ReadBit()
- if _validitySlatsPositionErr != nil {
- return nil, errors.New("Error parsing 'validitySlatsPosition' field " + _validitySlatsPositionErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(validitySlatsPosition)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_StatusSAB: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (heightPosition)
- heightPosition, _heightPositionErr := io.ReadUint8(8)
- if _heightPositionErr != nil {
- return nil, errors.New("Error parsing 'heightPosition' field " + _heightPositionErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(heightPosition)
-
- // Simple Field (slatsPosition)
- slatsPosition, _slatsPositionErr := io.ReadUint8(8)
- if _slatsPositionErr != nil {
- return nil, errors.New("Error parsing 'slatsPosition' field " + _slatsPositionErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(slatsPosition)
-
- // Simple Field (upperEndPosReached)
- upperEndPosReached, _upperEndPosReachedErr := io.ReadBit()
- if _upperEndPosReachedErr != nil {
- return nil, errors.New("Error parsing 'upperEndPosReached' field " + _upperEndPosReachedErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(upperEndPosReached)
-
- // Simple Field (lowerEndPosReached)
- lowerEndPosReached, _lowerEndPosReachedErr := io.ReadBit()
- if _lowerEndPosReachedErr != nil {
- return nil, errors.New("Error parsing 'lowerEndPosReached' field " + _lowerEndPosReachedErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(lowerEndPosReached)
-
- // Simple Field (lowerPredefPosReachedTypHeight100PercentSlatsAngle100Percent)
- lowerPredefPosReachedTypHeight100PercentSlatsAngle100Percent, _lowerPredefPosReachedTypHeight100PercentSlatsAngle100PercentErr := io.ReadBit()
- if _lowerPredefPosReachedTypHeight100PercentSlatsAngle100PercentErr != nil {
- return nil, errors.New("Error parsing 'lowerPredefPosReachedTypHeight100PercentSlatsAngle100Percent' field " + _lowerPredefPosReachedTypHeight100PercentSlatsAngle100PercentErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(lowerPredefPosReachedTypHeight100PercentSlatsAngle100Percent)
-
- // Simple Field (targetPosDrive)
- targetPosDrive, _targetPosDriveErr := io.ReadBit()
- if _targetPosDriveErr != nil {
- return nil, errors.New("Error parsing 'targetPosDrive' field " + _targetPosDriveErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(targetPosDrive)
-
- // Simple Field (restrictionOfTargetHeightPosPosCanNotBeReached)
- restrictionOfTargetHeightPosPosCanNotBeReached, _restrictionOfTargetHeightPosPosCanNotBeReachedErr := io.ReadBit()
- if _restrictionOfTargetHeightPosPosCanNotBeReachedErr != nil {
- return nil, errors.New("Error parsing 'restrictionOfTargetHeightPosPosCanNotBeReached' field " + _restrictionOfTargetHeightPosPosCanNotBeReachedErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(restrictionOfTargetHeightPosPosCanNotBeReached)
-
- // Simple Field (restrictionOfSlatsHeightPosPosCanNotBeReached)
- restrictionOfSlatsHeightPosPosCanNotBeReached, _restrictionOfSlatsHeightPosPosCanNotBeReachedErr := io.ReadBit()
- if _restrictionOfSlatsHeightPosPosCanNotBeReachedErr != nil {
- return nil, errors.New("Error parsing 'restrictionOfSlatsHeightPosPosCanNotBeReached' field " + _restrictionOfSlatsHeightPosPosCanNotBeReachedErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(restrictionOfSlatsHeightPosPosCanNotBeReached)
-
- // Simple Field (atLeastOneOfTheInputsWindRainFrostAlarmIsInAlarm)
- atLeastOneOfTheInputsWindRainFrostAlarmIsInAlarm, _atLeastOneOfTheInputsWindRainFrostAlarmIsInAlarmErr := io.ReadBit()
- if _atLeastOneOfTheInputsWindRainFrostAlarmIsInAlarmErr != nil {
- return nil, errors.New("Error parsing 'atLeastOneOfTheInputsWindRainFrostAlarmIsInAlarm' field " + _atLeastOneOfTheInputsWindRainFrostAlarmIsInAlarmErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(atLeastOneOfTheInputsWindRainFrostAlarmIsInAlarm)
-
- // Simple Field (upDownPositionIsForcedByMoveupdownforcedInput)
- upDownPositionIsForcedByMoveupdownforcedInput, _upDownPositionIsForcedByMoveupdownforcedInputErr := io.ReadBit()
- if _upDownPositionIsForcedByMoveupdownforcedInputErr != nil {
- return nil, errors.New("Error parsing 'upDownPositionIsForcedByMoveupdownforcedInput' field " + _upDownPositionIsForcedByMoveupdownforcedInputErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(upDownPositionIsForcedByMoveupdownforcedInput)
-
- // Simple Field (movementIsLockedEGByDevicelockedInput)
- movementIsLockedEGByDevicelockedInput, _movementIsLockedEGByDevicelockedInputErr := io.ReadBit()
- if _movementIsLockedEGByDevicelockedInputErr != nil {
- return nil, errors.New("Error parsing 'movementIsLockedEGByDevicelockedInput' field " + _movementIsLockedEGByDevicelockedInputErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(movementIsLockedEGByDevicelockedInput)
-
- // Simple Field (actuatorSetvalueIsLocallyOverriddenEGViaALocalUserInterface)
- actuatorSetvalueIsLocallyOverriddenEGViaALocalUserInterface, _actuatorSetvalueIsLocallyOverriddenEGViaALocalUserInterfaceErr := io.ReadBit()
- if _actuatorSetvalueIsLocallyOverriddenEGViaALocalUserInterfaceErr != nil {
- return nil, errors.New("Error parsing 'actuatorSetvalueIsLocallyOverriddenEGViaALocalUserInterface' field " + _actuatorSetvalueIsLocallyOverriddenEGViaALocalUserInterfaceErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(actuatorSetvalueIsLocallyOverriddenEGViaALocalUserInterface)
-
- // Simple Field (generalFailureOfTheActuatorOrTheDrive)
- generalFailureOfTheActuatorOrTheDrive, _generalFailureOfTheActuatorOrTheDriveErr := io.ReadBit()
- if _generalFailureOfTheActuatorOrTheDriveErr != nil {
- return nil, errors.New("Error parsing 'generalFailureOfTheActuatorOrTheDrive' field " + _generalFailureOfTheActuatorOrTheDriveErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(generalFailureOfTheActuatorOrTheDrive)
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(3); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (validityHeightPos)
- validityHeightPos, _validityHeightPosErr := io.ReadBit()
- if _validityHeightPosErr != nil {
- return nil, errors.New("Error parsing 'validityHeightPos' field " + _validityHeightPosErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(validityHeightPos)
-
- // Simple Field (validitySlatsPos)
- validitySlatsPos, _validitySlatsPosErr := io.ReadBit()
- if _validitySlatsPosErr != nil {
- return nil, errors.New("Error parsing 'validitySlatsPos' field " + _validitySlatsPosErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(validitySlatsPos)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_Colour_xyY: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (xAxis)
- xAxis, _xAxisErr := io.ReadUint16(16)
- if _xAxisErr != nil {
- return nil, errors.New("Error parsing 'xAxis' field " + _xAxisErr.Error())
- }
- _map["Struct"] = values.NewPlcUINT(xAxis)
-
- // Simple Field (yAxis)
- yAxis, _yAxisErr := io.ReadUint16(16)
- if _yAxisErr != nil {
- return nil, errors.New("Error parsing 'yAxis' field " + _yAxisErr.Error())
- }
- _map["Struct"] = values.NewPlcUINT(yAxis)
-
- // Simple Field (brightness)
- brightness, _brightnessErr := io.ReadUint8(8)
- if _brightnessErr != nil {
- return nil, errors.New("Error parsing 'brightness' field " + _brightnessErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(brightness)
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(6); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (validityXy)
- validityXy, _validityXyErr := io.ReadBit()
- if _validityXyErr != nil {
- return nil, errors.New("Error parsing 'validityXy' field " + _validityXyErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(validityXy)
-
- // Simple Field (validityBrightness)
- validityBrightness, _validityBrightnessErr := io.ReadBit()
- if _validityBrightnessErr != nil {
- return nil, errors.New("Error parsing 'validityBrightness' field " + _validityBrightnessErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(validityBrightness)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_Converter_Status: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (converterModeAccordingToTheDaliConverterStateMachine)
- converterModeAccordingToTheDaliConverterStateMachine, _converterModeAccordingToTheDaliConverterStateMachineErr := io.ReadUint8(4)
- if _converterModeAccordingToTheDaliConverterStateMachineErr != nil {
- return nil, errors.New("Error parsing 'converterModeAccordingToTheDaliConverterStateMachine' field " + _converterModeAccordingToTheDaliConverterStateMachineErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(converterModeAccordingToTheDaliConverterStateMachine)
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(2); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (hardwiredSwitchIsActive)
- hardwiredSwitchIsActive, _hardwiredSwitchIsActiveErr := io.ReadBit()
- if _hardwiredSwitchIsActiveErr != nil {
- return nil, errors.New("Error parsing 'hardwiredSwitchIsActive' field " + _hardwiredSwitchIsActiveErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(hardwiredSwitchIsActive)
-
- // Simple Field (hardwiredInhibitIsActive)
- hardwiredInhibitIsActive, _hardwiredInhibitIsActiveErr := io.ReadBit()
- if _hardwiredInhibitIsActiveErr != nil {
- return nil, errors.New("Error parsing 'hardwiredInhibitIsActive' field " + _hardwiredInhibitIsActiveErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(hardwiredInhibitIsActive)
-
- // Simple Field (functionTestPending)
- functionTestPending, _functionTestPendingErr := io.ReadUint8(2)
- if _functionTestPendingErr != nil {
- return nil, errors.New("Error parsing 'functionTestPending' field " + _functionTestPendingErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(functionTestPending)
-
- // Simple Field (durationTestPending)
- durationTestPending, _durationTestPendingErr := io.ReadUint8(2)
- if _durationTestPendingErr != nil {
- return nil, errors.New("Error parsing 'durationTestPending' field " + _durationTestPendingErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(durationTestPending)
-
- // Simple Field (partialDurationTestPending)
- partialDurationTestPending, _partialDurationTestPendingErr := io.ReadUint8(2)
- if _partialDurationTestPendingErr != nil {
- return nil, errors.New("Error parsing 'partialDurationTestPending' field " + _partialDurationTestPendingErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(partialDurationTestPending)
-
- // Simple Field (converterFailure)
- converterFailure, _converterFailureErr := io.ReadUint8(2)
- if _converterFailureErr != nil {
- return nil, errors.New("Error parsing 'converterFailure' field " + _converterFailureErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(converterFailure)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_Converter_Test_Result: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (ltrf)
- ltrf, _ltrfErr := io.ReadUint8(4)
- if _ltrfErr != nil {
- return nil, errors.New("Error parsing 'ltrf' field " + _ltrfErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(ltrf)
-
- // Simple Field (ltrd)
- ltrd, _ltrdErr := io.ReadUint8(4)
- if _ltrdErr != nil {
- return nil, errors.New("Error parsing 'ltrd' field " + _ltrdErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(ltrd)
-
- // Simple Field (ltrp)
- ltrp, _ltrpErr := io.ReadUint8(4)
- if _ltrpErr != nil {
- return nil, errors.New("Error parsing 'ltrp' field " + _ltrpErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(ltrp)
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(4); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (sf)
- sf, _sfErr := io.ReadUint8(2)
- if _sfErr != nil {
- return nil, errors.New("Error parsing 'sf' field " + _sfErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(sf)
-
- // Simple Field (sd)
- sd, _sdErr := io.ReadUint8(2)
- if _sdErr != nil {
- return nil, errors.New("Error parsing 'sd' field " + _sdErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(sd)
-
- // Simple Field (sp)
- sp, _spErr := io.ReadUint8(2)
- if _spErr != nil {
- return nil, errors.New("Error parsing 'sp' field " + _spErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(sp)
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(2); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (ldtr)
- ldtr, _ldtrErr := io.ReadUint16(16)
- if _ldtrErr != nil {
- return nil, errors.New("Error parsing 'ldtr' field " + _ldtrErr.Error())
- }
- _map["Struct"] = values.NewPlcUINT(ldtr)
-
- // Simple Field (lpdtr)
- lpdtr, _lpdtrErr := io.ReadUint8(8)
- if _lpdtrErr != nil {
- return nil, errors.New("Error parsing 'lpdtr' field " + _lpdtrErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(lpdtr)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_Battery_Info: // Struct
- _map := map[string]api.PlcValue{}
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(5); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (batteryFailure)
- batteryFailure, _batteryFailureErr := io.ReadBit()
- if _batteryFailureErr != nil {
- return nil, errors.New("Error parsing 'batteryFailure' field " + _batteryFailureErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(batteryFailure)
-
- // Simple Field (batteryDurationFailure)
- batteryDurationFailure, _batteryDurationFailureErr := io.ReadBit()
- if _batteryDurationFailureErr != nil {
- return nil, errors.New("Error parsing 'batteryDurationFailure' field " + _batteryDurationFailureErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(batteryDurationFailure)
-
- // Simple Field (batteryFullyCharged)
- batteryFullyCharged, _batteryFullyChargedErr := io.ReadBit()
- if _batteryFullyChargedErr != nil {
- return nil, errors.New("Error parsing 'batteryFullyCharged' field " + _batteryFullyChargedErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(batteryFullyCharged)
-
- // Simple Field (batteryChargeLevel)
- batteryChargeLevel, _batteryChargeLevelErr := io.ReadUint8(8)
- if _batteryChargeLevelErr != nil {
- return nil, errors.New("Error parsing 'batteryChargeLevel' field " + _batteryChargeLevelErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(batteryChargeLevel)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_Brightness_Colour_Temperature_Transition: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (ms)
- ms, _msErr := io.ReadUint16(16)
- if _msErr != nil {
- return nil, errors.New("Error parsing 'ms' field " + _msErr.Error())
- }
- _map["Struct"] = values.NewPlcUINT(ms)
-
- // Simple Field (temperatureK)
- temperatureK, _temperatureKErr := io.ReadUint16(16)
- if _temperatureKErr != nil {
- return nil, errors.New("Error parsing 'temperatureK' field " + _temperatureKErr.Error())
- }
- _map["Struct"] = values.NewPlcUINT(temperatureK)
-
- // Simple Field (percent)
- percent, _percentErr := io.ReadUint8(8)
- if _percentErr != nil {
- return nil, errors.New("Error parsing 'percent' field " + _percentErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(percent)
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(5); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (validityOfTheTimePeriod)
- validityOfTheTimePeriod, _validityOfTheTimePeriodErr := io.ReadBit()
- if _validityOfTheTimePeriodErr != nil {
- return nil, errors.New("Error parsing 'validityOfTheTimePeriod' field " + _validityOfTheTimePeriodErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(validityOfTheTimePeriod)
-
- // Simple Field (validityOfTheAbsoluteColourTemperature)
- validityOfTheAbsoluteColourTemperature, _validityOfTheAbsoluteColourTemperatureErr := io.ReadBit()
- if _validityOfTheAbsoluteColourTemperatureErr != nil {
- return nil, errors.New("Error parsing 'validityOfTheAbsoluteColourTemperature' field " + _validityOfTheAbsoluteColourTemperatureErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(validityOfTheAbsoluteColourTemperature)
-
- // Simple Field (validityOfTheAbsoluteBrightness)
- validityOfTheAbsoluteBrightness, _validityOfTheAbsoluteBrightnessErr := io.ReadBit()
- if _validityOfTheAbsoluteBrightnessErr != nil {
- return nil, errors.New("Error parsing 'validityOfTheAbsoluteBrightness' field " + _validityOfTheAbsoluteBrightnessErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(validityOfTheAbsoluteBrightness)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_Brightness_Colour_Temperature_Control: // Struct
- _map := map[string]api.PlcValue{}
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(4); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (cct)
- cct, _cctErr := io.ReadBit()
- if _cctErr != nil {
- return nil, errors.New("Error parsing 'cct' field " + _cctErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(cct)
-
- // Simple Field (stepCodeColourTemperature)
- stepCodeColourTemperature, _stepCodeColourTemperatureErr := io.ReadUint8(3)
- if _stepCodeColourTemperatureErr != nil {
- return nil, errors.New("Error parsing 'stepCodeColourTemperature' field " + _stepCodeColourTemperatureErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(stepCodeColourTemperature)
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(4); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (cb)
- cb, _cbErr := io.ReadBit()
- if _cbErr != nil {
- return nil, errors.New("Error parsing 'cb' field " + _cbErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(cb)
-
- // Simple Field (stepCodeBrightness)
- stepCodeBrightness, _stepCodeBrightnessErr := io.ReadUint8(3)
- if _stepCodeBrightnessErr != nil {
- return nil, errors.New("Error parsing 'stepCodeBrightness' field " + _stepCodeBrightnessErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(stepCodeBrightness)
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(6); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (cctAndStepCodeColourValidity)
- cctAndStepCodeColourValidity, _cctAndStepCodeColourValidityErr := io.ReadBit()
- if _cctAndStepCodeColourValidityErr != nil {
- return nil, errors.New("Error parsing 'cctAndStepCodeColourValidity' field " + _cctAndStepCodeColourValidityErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(cctAndStepCodeColourValidity)
-
- // Simple Field (cbAndStepCodeBrightnessValidity)
- cbAndStepCodeBrightnessValidity, _cbAndStepCodeBrightnessValidityErr := io.ReadBit()
- if _cbAndStepCodeBrightnessValidityErr != nil {
- return nil, errors.New("Error parsing 'cbAndStepCodeBrightnessValidity' field " + _cbAndStepCodeBrightnessValidityErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(cbAndStepCodeBrightnessValidity)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_Colour_RGBW: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (colourLevelRed)
- colourLevelRed, _colourLevelRedErr := io.ReadUint8(8)
- if _colourLevelRedErr != nil {
- return nil, errors.New("Error parsing 'colourLevelRed' field " + _colourLevelRedErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(colourLevelRed)
-
- // Simple Field (colourLevelGreen)
- colourLevelGreen, _colourLevelGreenErr := io.ReadUint8(8)
- if _colourLevelGreenErr != nil {
- return nil, errors.New("Error parsing 'colourLevelGreen' field " + _colourLevelGreenErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(colourLevelGreen)
-
- // Simple Field (colourLevelBlue)
- colourLevelBlue, _colourLevelBlueErr := io.ReadUint8(8)
- if _colourLevelBlueErr != nil {
- return nil, errors.New("Error parsing 'colourLevelBlue' field " + _colourLevelBlueErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(colourLevelBlue)
-
- // Simple Field (colourLevelWhite)
- colourLevelWhite, _colourLevelWhiteErr := io.ReadUint8(8)
- if _colourLevelWhiteErr != nil {
- return nil, errors.New("Error parsing 'colourLevelWhite' field " + _colourLevelWhiteErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(colourLevelWhite)
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(8); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(4); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (mr)
- mr, _mrErr := io.ReadBit()
- if _mrErr != nil {
- return nil, errors.New("Error parsing 'mr' field " + _mrErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(mr)
-
- // Simple Field (mg)
- mg, _mgErr := io.ReadBit()
- if _mgErr != nil {
- return nil, errors.New("Error parsing 'mg' field " + _mgErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(mg)
-
- // Simple Field (mb)
- mb, _mbErr := io.ReadBit()
- if _mbErr != nil {
- return nil, errors.New("Error parsing 'mb' field " + _mbErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(mb)
-
- // Simple Field (mw)
- mw, _mwErr := io.ReadBit()
- if _mwErr != nil {
- return nil, errors.New("Error parsing 'mw' field " + _mwErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(mw)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_Relative_Control_RGBW: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (maskcw)
- maskcw, _maskcwErr := io.ReadBit()
- if _maskcwErr != nil {
- return nil, errors.New("Error parsing 'maskcw' field " + _maskcwErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(maskcw)
-
- // Simple Field (maskcb)
- maskcb, _maskcbErr := io.ReadBit()
- if _maskcbErr != nil {
- return nil, errors.New("Error parsing 'maskcb' field " + _maskcbErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(maskcb)
-
- // Simple Field (maskcg)
- maskcg, _maskcgErr := io.ReadBit()
- if _maskcgErr != nil {
- return nil, errors.New("Error parsing 'maskcg' field " + _maskcgErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(maskcg)
-
- // Simple Field (maskcr)
- maskcr, _maskcrErr := io.ReadBit()
- if _maskcrErr != nil {
- return nil, errors.New("Error parsing 'maskcr' field " + _maskcrErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(maskcr)
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(4); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (cw)
- cw, _cwErr := io.ReadBit()
- if _cwErr != nil {
- return nil, errors.New("Error parsing 'cw' field " + _cwErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(cw)
-
- // Simple Field (stepCodeColourWhite)
- stepCodeColourWhite, _stepCodeColourWhiteErr := io.ReadUint8(3)
- if _stepCodeColourWhiteErr != nil {
- return nil, errors.New("Error parsing 'stepCodeColourWhite' field " + _stepCodeColourWhiteErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(stepCodeColourWhite)
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(4); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (cb)
- cb, _cbErr := io.ReadBit()
- if _cbErr != nil {
- return nil, errors.New("Error parsing 'cb' field " + _cbErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(cb)
-
- // Simple Field (stepCodeColourBlue)
- stepCodeColourBlue, _stepCodeColourBlueErr := io.ReadUint8(3)
- if _stepCodeColourBlueErr != nil {
- return nil, errors.New("Error parsing 'stepCodeColourBlue' field " + _stepCodeColourBlueErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(stepCodeColourBlue)
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(4); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (cg)
- cg, _cgErr := io.ReadBit()
- if _cgErr != nil {
- return nil, errors.New("Error parsing 'cg' field " + _cgErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(cg)
-
- // Simple Field (stepCodeColourGreen)
- stepCodeColourGreen, _stepCodeColourGreenErr := io.ReadUint8(3)
- if _stepCodeColourGreenErr != nil {
- return nil, errors.New("Error parsing 'stepCodeColourGreen' field " + _stepCodeColourGreenErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(stepCodeColourGreen)
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(4); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (cr)
- cr, _crErr := io.ReadBit()
- if _crErr != nil {
- return nil, errors.New("Error parsing 'cr' field " + _crErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(cr)
-
- // Simple Field (stepCodeColourRed)
- stepCodeColourRed, _stepCodeColourRedErr := io.ReadUint8(3)
- if _stepCodeColourRedErr != nil {
- return nil, errors.New("Error parsing 'stepCodeColourRed' field " + _stepCodeColourRedErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(stepCodeColourRed)
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(4); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_Relative_Control_RGB: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (cb)
- cb, _cbErr := io.ReadBit()
- if _cbErr != nil {
- return nil, errors.New("Error parsing 'cb' field " + _cbErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(cb)
-
- // Simple Field (stepCodeColourBlue)
- stepCodeColourBlue, _stepCodeColourBlueErr := io.ReadUint8(3)
- if _stepCodeColourBlueErr != nil {
- return nil, errors.New("Error parsing 'stepCodeColourBlue' field " + _stepCodeColourBlueErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(stepCodeColourBlue)
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(4); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (cg)
- cg, _cgErr := io.ReadBit()
- if _cgErr != nil {
- return nil, errors.New("Error parsing 'cg' field " + _cgErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(cg)
-
- // Simple Field (stepCodeColourGreen)
- stepCodeColourGreen, _stepCodeColourGreenErr := io.ReadUint8(3)
- if _stepCodeColourGreenErr != nil {
- return nil, errors.New("Error parsing 'stepCodeColourGreen' field " + _stepCodeColourGreenErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(stepCodeColourGreen)
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(4); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
-
- // Simple Field (cr)
- cr, _crErr := io.ReadBit()
- if _crErr != nil {
- return nil, errors.New("Error parsing 'cr' field " + _crErr.Error())
- }
- _map["Struct"] = values.NewPlcBOOL(cr)
-
- // Simple Field (stepCodeColourRed)
- stepCodeColourRed, _stepCodeColourRedErr := io.ReadUint8(3)
- if _stepCodeColourRedErr != nil {
- return nil, errors.New("Error parsing 'stepCodeColourRed' field " + _stepCodeColourRedErr.Error())
- }
- _map["Struct"] = values.NewPlcUSINT(stepCodeColourRed)
-
- // Reserved Field (Just skip the bytes)
- if _, _err := io.ReadUint8(4); _err != nil {
- return nil, errors.New("Error parsing reserved field " + _err.Error())
- }
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_GeographicalLocation: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (longitude)
- longitude, _longitudeErr := io.ReadFloat32(true, 8, 23)
- if _longitudeErr != nil {
- return nil, errors.New("Error parsing 'longitude' field " + _longitudeErr.Error())
- }
- _map["Struct"] = values.NewPlcREAL(longitude)
-
- // Simple Field (latitude)
- latitude, _latitudeErr := io.ReadFloat32(true, 8, 23)
- if _latitudeErr != nil {
- return nil, errors.New("Error parsing 'latitude' field " + _latitudeErr.Error())
- }
- _map["Struct"] = values.NewPlcREAL(latitude)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_TempRoomSetpSetF16_4: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (roomTemperatureSetpointComfort)
- roomTemperatureSetpointComfort, _roomTemperatureSetpointComfortErr := io.ReadFloat32(true, 4, 11)
- if _roomTemperatureSetpointComfortErr != nil {
- return nil, errors.New("Error parsing 'roomTemperatureSetpointComfort' field " + _roomTemperatureSetpointComfortErr.Error())
- }
- _map["Struct"] = values.NewPlcREAL(roomTemperatureSetpointComfort)
-
- // Simple Field (roomTemperatureSetpointStandby)
- roomTemperatureSetpointStandby, _roomTemperatureSetpointStandbyErr := io.ReadFloat32(true, 4, 11)
- if _roomTemperatureSetpointStandbyErr != nil {
- return nil, errors.New("Error parsing 'roomTemperatureSetpointStandby' field " + _roomTemperatureSetpointStandbyErr.Error())
- }
- _map["Struct"] = values.NewPlcREAL(roomTemperatureSetpointStandby)
-
- // Simple Field (roomTemperatureSetpointEconomy)
- roomTemperatureSetpointEconomy, _roomTemperatureSetpointEconomyErr := io.ReadFloat32(true, 4, 11)
- if _roomTemperatureSetpointEconomyErr != nil {
- return nil, errors.New("Error parsing 'roomTemperatureSetpointEconomy' field " + _roomTemperatureSetpointEconomyErr.Error())
- }
- _map["Struct"] = values.NewPlcREAL(roomTemperatureSetpointEconomy)
-
- // Simple Field (roomTemperatureSetpointBuildingProtection)
- roomTemperatureSetpointBuildingProtection, _roomTemperatureSetpointBuildingProtectionErr := io.ReadFloat32(true, 4, 11)
- if _roomTemperatureSetpointBuildingProtectionErr != nil {
- return nil, errors.New("Error parsing 'roomTemperatureSetpointBuildingProtection' field " + _roomTemperatureSetpointBuildingProtectionErr.Error())
- }
- _map["Struct"] = values.NewPlcREAL(roomTemperatureSetpointBuildingProtection)
- return values.NewPlcStruct(_map), nil
- case datapointType == KnxDatapointType_DPT_TempRoomSetpSetShiftF16_4: // Struct
- _map := map[string]api.PlcValue{}
-
- // Simple Field (roomTemperatureSetpointShiftComfort)
- roomTemperatureSetpointShiftComfort, _roomTemperatureSetpointShiftComfortErr := io.ReadFloat32(true, 4, 11)
- if _roomTemperatureSetpointShiftComfortErr != nil {
- return nil, errors.New("Error parsing 'roomTemperatureSetpointShiftComfort' field " + _roomTemperatureSetpointShiftComfortErr.Error())
- }
- _map["Struct"] = values.NewPlcREAL(roomTemperatureSetpointShiftComfort)
-
- // Simple Field (roomTemperatureSetpointShiftStandby)
- roomTemperatureSetpointShiftStandby, _roomTemperatureSetpointShiftStandbyErr := io.ReadFloat32(true, 4, 11)
- if _roomTemperatureSetpointShiftStandbyErr != nil {
- return nil, errors.New("Error parsing 'roomTemperatureSetpointShiftStandby' field " + _roomTemperatureSetpointShiftStandbyErr.Error())
- }
- _map["Struct"] = values.NewPlcREAL(roomTemperatureSetpointShiftStandby)
-
- // Simple Field (roomTemperatureSetpointShiftEconomy)
- roomTemperatureSetpointShiftEconomy, _roomTemperatureSetpointShiftEconomyErr := io.ReadFloat32(true, 4, 11)
- if _roomTemperatureSetpointShiftEconomyErr != nil {
- return nil, errors.New("Error parsing 'roomTemperatureSetpointShiftEconomy' field " + _roomTemperatureSetpointShiftEconomyErr.Error())
- }
- _map["Struct"] = values.NewPlcREAL(roomTemperatureSetpointShiftEconomy)
-
- // Simple Field (roomTemperatureSetpointShiftBuildingProtection)
- roomTemperatureSetpointShiftBuildingProtection, _roomTemperatureSetpointShiftBuildingProtectionErr := io.ReadFloat32(true, 4, 11)
- if _roomTemperatureSetpointShiftBuildingProtectionErr != nil {
- return nil, errors.New("Error parsing 'roomTemperatureSetpointShiftBuildingProtection' field " + _roomTemperatureSetpointShiftBuildingProtectionErr.Error())
- }
- _map["Struct"] = values.NewPlcREAL(roomTemperatureSetpointShiftBuildingProtection)
- return values.NewPlcStruct(_map), nil
- }
- return nil, errors.New("unsupported type")
+ switch {
+ case datapointType == KnxDatapointType_BOOL: // BOOL
+
+ // Reserved Field (Just skip the bytes)
+ if _, _err := io.ReadUint8(7); _err != nil {
+ return nil, errors.New("Error parsing reserved field " + _err.Error())
+ }
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadBit()
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcBOOL(value), nil
+ case datapointType == KnxDatapointType_BYTE: // BYTE
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadUint8(8)
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcBYTE(value), nil
+ case datapointType == KnxDatapointType_WORD: // WORD
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadUint16(16)
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcWORD(value), nil
+ case datapointType == KnxDatapointType_DWORD: // DWORD
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadUint32(32)
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcDWORD(value), nil
+ case datapointType == KnxDatapointType_LWORD: // LWORD
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadUint64(64)
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcLWORD(value), nil
+ case datapointType == KnxDatapointType_USINT: // USINT
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadUint8(8)
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcUSINT(value), nil
+ case datapointType == KnxDatapointType_SINT: // SINT
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadInt8(8)
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcSINT(value), nil
+ case datapointType == KnxDatapointType_UINT: // UINT
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadUint16(16)
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcUINT(value), nil
+ case datapointType == KnxDatapointType_INT: // INT
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadInt16(16)
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcINT(value), nil
+ case datapointType == KnxDatapointType_UDINT: // UDINT
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadUint32(32)
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcUDINT(value), nil
+ case datapointType == KnxDatapointType_DINT: // DINT
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadInt32(32)
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcDINT(value), nil
+ case datapointType == KnxDatapointType_ULINT: // ULINT
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadUint64(64)
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcULINT(value), nil
+ case datapointType == KnxDatapointType_LINT: // LINT
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadInt64(64)
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcLINT(value), nil
+ case datapointType == KnxDatapointType_REAL: // REAL
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadFloat32(true, 8, 23)
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcREAL(value), nil
+ case datapointType == KnxDatapointType_LREAL: // LREAL
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadFloat64(true, 11, 52)
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcLREAL(value), nil
+ case datapointType == KnxDatapointType_CHAR: // CHAR
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadUint8(8)
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcCHAR(value), nil
+ case datapointType == KnxDatapointType_WCHAR: // WCHAR
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadUint16(16)
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcWCHAR(value), nil
+ case datapointType == KnxDatapointType_TIME: // TIME
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadUint32(32)
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcTIME(value), nil
+ case datapointType == KnxDatapointType_LTIME: // LTIME
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadUint64(64)
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcLTIME(value), nil
+ case datapointType == KnxDatapointType_DATE: // DATE
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadUint16(16)
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcDATE(value), nil
+ case datapointType == KnxDatapointType_TIME_OF_DAY: // TIME_OF_DAY
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadUint32(32)
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcTIME_OF_DAY(value), nil
+ case datapointType == KnxDatapointType_TOD: // TIME_OF_DAY
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadUint32(32)
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcTIME_OF_DAY(value), nil
+ case datapointType == KnxDatapointType_DATE_AND_TIME: // DATE_AND_TIME
+
+ // Simple Field (year)
+ year, _yearErr := io.ReadUint16(16)
+ if _yearErr != nil {
+ return nil, errors.New("Error parsing 'year' field " + _yearErr.Error())
+ }
+
+ // Simple Field (month)
+ month, _monthErr := io.ReadUint8(8)
+ if _monthErr != nil {
+ return nil, errors.New("Error parsing 'month' field " + _monthErr.Error())
+ }
+
+ // Simple Field (day)
+ day, _dayErr := io.ReadUint8(8)
+ if _dayErr != nil {
+ return nil, errors.New("Error parsing 'day' field " + _dayErr.Error())
+ }
+
+ // Simple Field (dayOfWeek)
+ _, _dayOfWeekErr := io.ReadUint8(8)
+ if _dayOfWeekErr != nil {
+ return nil, errors.New("Error parsing 'dayOfWeek' field " + _dayOfWeekErr.Error())
+ }
+
+ // Simple Field (hour)
+ hour, _hourErr := io.ReadUint8(8)
+ if _hourErr != nil {
+ return nil, errors.New("Error parsing 'hour' field " + _hourErr.Error())
+ }
+
+ // Simple Field (minutes)
+ minutes, _minutesErr := io.ReadUint8(8)
+ if _minutesErr != nil {
+ return nil, errors.New("Error parsing 'minutes' field " + _minutesErr.Error())
+ }
+
+ // Simple Field (seconds)
+ seconds, _secondsErr := io.ReadUint8(8)
+ if _secondsErr != nil {
+ return nil, errors.New("Error parsing 'seconds' field " + _secondsErr.Error())
+ }
+
+ // Simple Field (nanos)
+ _, _nanosErr := io.ReadUint32(32)
+ if _nanosErr != nil {
+ return nil, errors.New("Error parsing 'nanos' field " + _nanosErr.Error())
+ }
+ value := time.Date(int(year), time.Month(month), int(day), int(hour), int(minutes), int(seconds), 0, nil)
+ return values.NewPlcDATE_AND_TIME(value), nil
+ case datapointType == KnxDatapointType_DT: // DATE_AND_TIME
+
+ // Simple Field (year)
+ year, _yearErr := io.ReadUint16(16)
+ if _yearErr != nil {
+ return nil, errors.New("Error parsing 'year' field " + _yearErr.Error())
+ }
+
+ // Simple Field (month)
+ month, _monthErr := io.ReadUint8(8)
+ if _monthErr != nil {
+ return nil, errors.New("Error parsing 'month' field " + _monthErr.Error())
+ }
+
+ // Simple Field (day)
+ day, _dayErr := io.ReadUint8(8)
+ if _dayErr != nil {
+ return nil, errors.New("Error parsing 'day' field " + _dayErr.Error())
+ }
+
+ // Simple Field (dayOfWeek)
+ _, _dayOfWeekErr := io.ReadUint8(8)
+ if _dayOfWeekErr != nil {
+ return nil, errors.New("Error parsing 'dayOfWeek' field " + _dayOfWeekErr.Error())
+ }
+
+ // Simple Field (hour)
+ hour, _hourErr := io.ReadUint8(8)
+ if _hourErr != nil {
+ return nil, errors.New("Error parsing 'hour' field " + _hourErr.Error())
+ }
+
+ // Simple Field (minutes)
+ minutes, _minutesErr := io.ReadUint8(8)
+ if _minutesErr != nil {
+ return nil, errors.New("Error parsing 'minutes' field " + _minutesErr.Error())
+ }
+
+ // Simple Field (seconds)
+ seconds, _secondsErr := io.ReadUint8(8)
+ if _secondsErr != nil {
+ return nil, errors.New("Error parsing 'seconds' field " + _secondsErr.Error())
+ }
+
+ // Simple Field (nanos)
+ _, _nanosErr := io.ReadUint32(32)
+ if _nanosErr != nil {
+ return nil, errors.New("Error parsing 'nanos' field " + _nanosErr.Error())
+ }
+ value := time.Date(int(year), time.Month(month), int(day), int(hour), int(minutes), int(seconds), 0, nil)
+ return values.NewPlcDATE_AND_TIME(value), nil
+ case datapointType == KnxDatapointType_DPT_Switch: // BOOL
+
+ // Reserved Field (Just skip the bytes)
+ if _, _err := io.ReadUint8(7); _err != nil {
+ return nil, errors.New("Error parsing reserved field " + _err.Error())
+ }
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadBit()
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcBOOL(value), nil
+ case datapointType == KnxDatapointType_DPT_Bool: // BOOL
+
+ // Reserved Field (Just skip the bytes)
+ if _, _err := io.ReadUint8(7); _err != nil {
+ return nil, errors.New("Error parsing reserved field " + _err.Error())
+ }
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadBit()
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcBOOL(value), nil
+ case datapointType == KnxDatapointType_DPT_Enable: // BOOL
+
+ // Reserved Field (Just skip the bytes)
+ if _, _err := io.ReadUint8(7); _err != nil {
+ return nil, errors.New("Error parsing reserved field " + _err.Error())
+ }
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadBit()
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcBOOL(value), nil
+ case datapointType == KnxDatapointType_DPT_Ramp: // BOOL
+
+ // Reserved Field (Just skip the bytes)
+ if _, _err := io.ReadUint8(7); _err != nil {
+ return nil, errors.New("Error parsing reserved field " + _err.Error())
+ }
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadBit()
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcBOOL(value), nil
+ case datapointType == KnxDatapointType_DPT_Alarm: // BOOL
+
+ // Reserved Field (Just skip the bytes)
+ if _, _err := io.ReadUint8(7); _err != nil {
+ return nil, errors.New("Error parsing reserved field " + _err.Error())
+ }
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadBit()
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcBOOL(value), nil
+ case datapointType == KnxDatapointType_DPT_BinaryValue: // BOOL
+
+ // Reserved Field (Just skip the bytes)
+ if _, _err := io.ReadUint8(7); _err != nil {
+ return nil, errors.New("Error parsing reserved field " + _err.Error())
+ }
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadBit()
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcBOOL(value), nil
+ case datapointType == KnxDatapointType_DPT_Step: // BOOL
+
+ // Reserved Field (Just skip the bytes)
+ if _, _err := io.ReadUint8(7); _err != nil {
+ return nil, errors.New("Error parsing reserved field " + _err.Error())
+ }
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadBit()
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcBOOL(value), nil
+ case datapointType == KnxDatapointType_DPT_UpDown: // BOOL
+
+ // Reserved Field (Just skip the bytes)
+ if _, _err := io.ReadUint8(7); _err != nil {
+ return nil, errors.New("Error parsing reserved field " + _err.Error())
+ }
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadBit()
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcBOOL(value), nil
+ case datapointType == KnxDatapointType_DPT_OpenClose: // BOOL
+
+ // Reserved Field (Just skip the bytes)
+ if _, _err := io.ReadUint8(7); _err != nil {
+ return nil, errors.New("Error parsing reserved field " + _err.Error())
+ }
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadBit()
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcBOOL(value), nil
+ case datapointType == KnxDatapointType_DPT_Start: // BOOL
+
+ // Reserved Field (Just skip the bytes)
+ if _, _err := io.ReadUint8(7); _err != nil {
+ return nil, errors.New("Error parsing reserved field " + _err.Error())
+ }
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadBit()
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcBOOL(value), nil
+ case datapointType == KnxDatapointType_DPT_State: // BOOL
+
+ // Reserved Field (Just skip the bytes)
+ if _, _err := io.ReadUint8(7); _err != nil {
+ return nil, errors.New("Error parsing reserved field " + _err.Error())
+ }
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadBit()
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcBOOL(value), nil
+ case datapointType == KnxDatapointType_DPT_Invert: // BOOL
+
+ // Reserved Field (Just skip the bytes)
+ if _, _err := io.ReadUint8(7); _err != nil {
+ return nil, errors.New("Error parsing reserved field " + _err.Error())
+ }
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadBit()
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcBOOL(value), nil
+ case datapointType == KnxDatapointType_DPT_DimSendStyle: // BOOL
+
+ // Reserved Field (Just skip the bytes)
+ if _, _err := io.ReadUint8(7); _err != nil {
+ return nil, errors.New("Error parsing reserved field " + _err.Error())
+ }
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadBit()
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcBOOL(value), nil
+ case datapointType == KnxDatapointType_DPT_InputSource: // BOOL
+
+ // Reserved Field (Just skip the bytes)
+ if _, _err := io.ReadUint8(7); _err != nil {
+ return nil, errors.New("Error parsing reserved field " + _err.Error())
+ }
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadBit()
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcBOOL(value), nil
+ case datapointType == KnxDatapointType_DPT_Reset: // BOOL
+
+ // Reserved Field (Just skip the bytes)
+ if _, _err := io.ReadUint8(7); _err != nil {
+ return nil, errors.New("Error parsing reserved field " + _err.Error())
+ }
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadBit()
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcBOOL(value), nil
+ case datapointType == KnxDatapointType_DPT_Ack: // BOOL
+
+ // Reserved Field (Just skip the bytes)
+ if _, _err := io.ReadUint8(7); _err != nil {
+ return nil, errors.New("Error parsing reserved field " + _err.Error())
+ }
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadBit()
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcBOOL(value), nil
+ case datapointType == KnxDatapointType_DPT_Trigger: // BOOL
+
+ // Reserved Field (Just skip the bytes)
+ if _, _err := io.ReadUint8(7); _err != nil {
+ return nil, errors.New("Error parsing reserved field " + _err.Error())
+ }
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadBit()
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcBOOL(value), nil
+ case datapointType == KnxDatapointType_DPT_Occupancy: // BOOL
+
+ // Reserved Field (Just skip the bytes)
+ if _, _err := io.ReadUint8(7); _err != nil {
+ return nil, errors.New("Error parsing reserved field " + _err.Error())
+ }
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadBit()
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcBOOL(value), nil
+ case datapointType == KnxDatapointType_DPT_Window_Door: // BOOL
+
+ // Reserved Field (Just skip the bytes)
+ if _, _err := io.ReadUint8(7); _err != nil {
+ return nil, errors.New("Error parsing reserved field " + _err.Error())
+ }
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadBit()
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcBOOL(value), nil
+ case datapointType == KnxDatapointType_DPT_LogicalFunction: // BOOL
+
+ // Reserved Field (Just skip the bytes)
+ if _, _err := io.ReadUint8(7); _err != nil {
+ return nil, errors.New("Error parsing reserved field " + _err.Error())
+ }
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadBit()
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcBOOL(value), nil
+ case datapointType == KnxDatapointType_DPT_Scene_AB: // BOOL
+
+ // Reserved Field (Just skip the bytes)
+ if _, _err := io.ReadUint8(7); _err != nil {
+ return nil, errors.New("Error parsing reserved field " + _err.Error())
+ }
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadBit()
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcBOOL(value), nil
+ case datapointType == KnxDatapointType_DPT_ShutterBlinds_Mode: // BOOL
+
+ // Reserved Field (Just skip the bytes)
+ if _, _err := io.ReadUint8(7); _err != nil {
+ return nil, errors.New("Error parsing reserved field " + _err.Error())
+ }
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadBit()
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcBOOL(value), nil
+ case datapointType == KnxDatapointType_DPT_DayNight: // BOOL
+
+ // Reserved Field (Just skip the bytes)
+ if _, _err := io.ReadUint8(7); _err != nil {
+ return nil, errors.New("Error parsing reserved field " + _err.Error())
+ }
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadBit()
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcBOOL(value), nil
+ case datapointType == KnxDatapointType_DPT_Heat_Cool: // BOOL
+
+ // Reserved Field (Just skip the bytes)
+ if _, _err := io.ReadUint8(7); _err != nil {
+ return nil, errors.New("Error parsing reserved field " + _err.Error())
+ }
+
+ // Simple Field (value)
+ value, _valueErr := io.ReadBit()
+ if _valueErr != nil {
+ return nil, errors.New("Error parsing 'value' field " + _valueErr.Error())
+ }
+ return values.NewPlcBOOL(value), nil
+ case datapointType == KnxDatapointType_DPT_Switch_Control: // Struct
+ _map := map[string]api.PlcValue{}
+
+ // Reserved Field (Just skip the bytes)
+ if _, _err := io.ReadUint8(6); _err != nil {
+ return nil, errors.New("Error parsing reserved field " + _err.Error())
+ }
+
+ // Simple Field (control)
+ control, _controlErr := io.ReadBit()
+ if _controlErr != nil {
+ return nil, errors.New("Error parsing 'control' field " + _controlErr.Error())
+ }
+ _map["Struct"] = values.NewPlcBOOL(control)
+
+ // Simple Field (on)
+ on, _onErr := io.ReadBit()
+ if _onErr != nil {
+ return nil, errors.New("Error parsing 'on' field " + _onErr.Error())
+ }
+ _map["Struct"] = values.NewPlcBOOL(on)
+ return values.NewPlcStruct(_map), nil
+ case datapointType == KnxDatapointType_DPT_Bool_Control: // Struct
+ _map := map[string]api.PlcValue{}
+
+ // Reserved Field (Just skip the bytes)
+ if _, _err := io.ReadUint8(6); _err != nil {
+ return nil, errors.New("Error parsing reserved field " + _err.Error())
+ }
+
+ // Simple Field (control)
+ control, _controlErr := io.ReadBit()
+ if _controlErr != nil {
+ return nil, errors.New("Error parsing 'control' field " + _controlErr.Error())
+ }
+ _map["Struct"] = values.NewPlcBOOL(control)
+
+ // Simple Field (valueTrue)
+ valueTrue, _valueTrueErr := io.ReadBit()
+ if _valueTrueErr != nil {
+ return nil, errors.New("Error parsing 'valueTrue' field " + _valueTrueErr.Error())
+ }
+ _map["Struct"] = values.NewPlcBOOL(valueTrue)
+ return values.NewPlcStruct(_map), nil
+ case datapointType == KnxDatapointType_DPT_Enable_Control: // Struct
+ _map := map[string]api.PlcValue{}
+
+ // Reserved Field (Just skip the bytes)
+ if _, _err := io.ReadUint8(6); _err != nil {
+ return nil, errors.New("Error parsing reserved field " + _err.Error())
+ }
+
+ // Simple Field (control)
+ control, _controlErr := io.ReadBit()
+ if _controlErr != nil {
+ return nil, errors.New("Error parsing 'control' field " + _controlErr.Error())
+ }
+ _map["Struct"] = values.NewPlcBOOL(control)
+
+ // Simple Field (enable)
+ enable, _enableErr := io.ReadBit()
+ if _enableErr != nil {
+ return nil, errors.New("Error parsing 'enable' field " + _enableErr.Error())
+ }
+ _map["Struct"] = values.NewPlcBOOL(enable)
+ return values.NewPlcStruct(_map), nil
+ case datapointType == KnxDatapointType_DPT_Ramp_Control: // Struct
+ _map := map[string]api.PlcValue{}
+
+ // Reserved Field (Just skip the bytes)
+ if _, _err := io.ReadUint8(6); _err != nil {
+ return nil, errors.New("Error parsing reserved field " + _err.Error())
+ }
+
+ // Simple Field (control)
+ control, _controlErr := io.ReadBit()
+ if _controlErr != nil {
+ return nil, errors.New("Error parsing 'control' field " + _controlErr.Error())
+ }
+ _map["Struct"] = values.NewPlcBOOL(control)
+
+ // Simple Field (ramp)
+ ramp, _rampErr := io.ReadBit()
+ if _rampErr != nil {
+ return nil, errors.New("Error parsing 'ramp' field " + _rampErr.Error())
+ }
+ _map["Struct"] = values.NewPlcBOOL(ramp)
+ return values.NewPlcStruct(_map), nil
+ case datapointType == KnxDatapointType_DPT_Alarm_Control: // Struct
+ _map := map[string]api.PlcValue{}
+
+ // Reserved Field (Just skip the bytes)
+ if _, _err := io.ReadUint8(6); _err != nil {
+ return nil, errors.New("Error parsing reserved field " + _err.Error())
+ }
+
+ // Simple Field (control)
+ control, _controlErr := io.ReadBit()
+ if _controlErr != nil {
+ return nil, errors.New("Error parsing 'control' field " + _controlErr.Error())
+ }
+ _map["Struct"] = values.NewPlcBOOL(control)
+
+ // Simple Field (alarm)
+ alarm, _alarmErr := io.ReadBit()
+ if _alarmErr != nil {
+ return nil, errors.New("Error parsing 'alarm' field " + _alarmErr.Error())
+ }
+ _map["Struct"] = values.NewPlcBOOL(alarm)
+ return values.NewPlcStruct(_map), nil
+ case datapointType == KnxDatapointType_DPT_BinaryValue_Control: // Struct
+ _map := map[string]api.PlcValue{}
+
+ // Reserved Field (Just skip the bytes)
+ if _, _err := io.ReadUint8(6); _err != nil {
+ return nil, errors.New("Error parsing reserved field " + _err.Error())
+ }
+
+ // Simple Field (control)
+ control, _controlErr := io.ReadBit()
+ if _controlErr != nil {
+ return nil, errors.New("Error parsing 'control' field " + _controlErr.Error())
+ }
+ _map["Struct"] = values.NewPlcBOOL(control)
+
+ // Simple Field (high)
+ high, _highErr := io.ReadBit()
+ if _highErr != nil {
+ return nil, errors.New("Error parsing 'high' field " + _highErr.Error())
+ }
+ _map["Struct"] = values.NewPlcBOOL(high)
+ return values.NewPlcStruct(_map), nil
+ case datapointType == KnxDatapointType_DPT_Step_Control: // Struct
+ _map := map[string]api.PlcValue{}
+
+ // Reserved Field (Just skip the bytes)
+ if _, _err := io.ReadUint8(6); _err != nil {
+ return nil, errors.New("Error parsing reserved field " + _err.Error())
+ }
+
+ // Simple Field (control)
+ control, _controlErr := io.ReadBit()
+ if _controlErr != nil {
+ return nil, errors.New("Error parsing 'control' field " + _controlErr.Error())
+ }
+ _map["Struct"] = values.NewPlcBOOL(control)
+
+ // Simple Field (increase)
+ increase, _increaseErr := io.ReadBit()
+ if _increaseErr != nil {
+ return nil, errors.New("Error parsing 'increase' field " + _increaseErr.Error())
+ }
+ _map["Struct"] = values.NewPlcBOOL(increase)
+ return values.NewPlcStruct(_map), nil
+ case datapointType == KnxDatapointType_DPT_Direction1_Control: // Struct
+ _map := map[string]api.PlcValue{}
+
+ // Reserved Field (Just skip the bytes)
+ if _, _err := io.ReadUint8(6); _err != nil {
+ return nil, errors.New("Error parsing reserved field " + _err.Error())
+ }
+
+ // Simple Field (control)
+ control, _controlErr := io.ReadBit()
+ if _controlErr != nil {
+ return nil, errors.New("Error parsing 'control' field " + _controlErr.Error())
+ }
+ _map["Struct"] = values.NewPlcBOOL(control)
+
+ // Simple Field (down)
+ down, _downErr := io.ReadBit()
+ if _downErr != nil {
+ return nil, errors.New("Error parsing 'down' field " + _downErr.Error())
+ }
+ _map["Struct"] = values.NewPlcBOOL(down)
+ return values.NewPlcStruct(_map), nil
+ case datapointType == KnxDatapointType_DPT_Direction2_Control: // Struct
+ _map := map[string]api.PlcValue{}
+
+ // Reserved Field (Just skip the bytes)
+ if _, _err := io.ReadUint8(6); _err != nil {
+ return nil, errors.New("Error parsing reserved field " + _err.Error())
+ }
+
+ // Simple Field (control)
+ control, _controlErr := io.ReadBit()
+ if _controlErr != nil {
... 14779 lines suppressed ...