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/03/11 15:44:36 UTC
[plc4x] branch develop updated: - Adjusted the execution times of
the go maven plugin tools - Removed obsolete test-code (That actually
wasn't test code)
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 6bba1b85 - Adjusted the execution times of the go maven plugin tools - Removed obsolete test-code (That actually wasn't test code)
6bba1b85 is described below
commit 6bba1b85954e71509cf63466937da90ded78c0a5
Author: Christofer Dutz <ch...@c-ware.de>
AuthorDate: Thu Mar 11 16:43:42 2021 +0100
- Adjusted the execution times of the go maven plugin tools
- Removed obsolete test-code (That actually wasn't test code)
---
plc4go/cmd/main/drivers/knxnetip_test.go | 466 ----------------
plc4go/cmd/main/drivers/modbus_test.go | 143 -----
.../cmd/main/drivers/tests/knx_discovery_test.go | 613 ---------------------
.../model/AdsAddDeviceNotificationRequest.go | 1 -
.../ads/readwrite/model/AdsMultiRequestItem.go | 273 ++++-----
.../ads/readwrite/model/AdsMultiRequestItemRead.go | 296 +++++-----
.../model/AdsMultiRequestItemReadWrite.go | 350 ++++++------
.../readwrite/model/AdsMultiRequestItemWrite.go | 296 +++++-----
.../knxnetip/readwrite/model/KnxDatapointType.go | 2 +-
.../knxnetip/readwrite/model/KnxManufacturer.go | 114 +---
plc4go/pom.xml | 19 +-
11 files changed, 636 insertions(+), 1937 deletions(-)
diff --git a/plc4go/cmd/main/drivers/knxnetip_test.go b/plc4go/cmd/main/drivers/knxnetip_test.go
index 99ff70d..1383d05 100644
--- a/plc4go/cmd/main/drivers/knxnetip_test.go
+++ b/plc4go/cmd/main/drivers/knxnetip_test.go
@@ -21,16 +21,11 @@ package drivers
import (
"encoding/hex"
"fmt"
- "github.com/apache/plc4x/plc4go/internal/plc4go/knxnetip"
driverModel "github.com/apache/plc4x/plc4go/internal/plc4go/knxnetip/readwrite/model"
- "github.com/apache/plc4x/plc4go/internal/plc4go/spi/transports/udp"
"github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
- "github.com/apache/plc4x/plc4go/pkg/plc4go"
- apiModel "github.com/apache/plc4x/plc4go/pkg/plc4go/model"
log "github.com/sirupsen/logrus"
"os"
"testing"
- "time"
)
func Init() {
@@ -53,464 +48,3 @@ func TestParser(t *testing.T) {
}
print(knxMessage)
}
-
-func TestKnxNetIpPlc4goBrowse(t *testing.T) {
- Init()
-
- startTime := time.Now()
-
- log.Debug("Initializing PLC4X")
- driverManager := plc4go.NewPlcDriverManager()
- log.Debug("Registering KNXnet/IP driver")
- driverManager.RegisterDriver(knxnetip.NewKnxNetIpDriver())
- log.Debug("Registering UDP transport")
- driverManager.RegisterTransport(udp.NewUdpTransport())
-
- // Create a connection string from the discovery result.
- connectionString := "knxnet-ip:udp://192.168.42.11:3671"
- crc := driverManager.GetConnection(connectionString)
- connectionResult := <-crc
- if connectionResult.Err != nil {
- log.Errorf("Got an error getting a connection: %s", connectionResult.Err.Error())
- t.Fail()
- return
- }
- log.Info("Got a connection")
- connection := connectionResult.Connection
- defer connection.BlockingClose()
-
- // Build a browse request, to scan the KNX network for KNX devices
- // (Limiting the range to only the actually used range of addresses)
- browseRequestBuilder := connection.BrowseRequestBuilder()
- browseRequestBuilder.AddItem("findAllKnxDevices", "[1-3].[1-6].[1-60]")
- browseRequest, err := browseRequestBuilder.Build()
- if err != nil {
- log.Errorf("Got an error preparing browse-request: %s", connectionResult.Err.Error())
- t.Fail()
- return
- }
-
- // Execute the browse-request
- log.Info("Scanning for KNX devices")
- brr := browseRequest.Execute()
- browseRequestResults := <-brr
- if browseRequestResults.Err != nil {
- log.Errorf("Got an error scanning for KNX devices: %s", connectionResult.Err.Error())
- t.Fail()
- return
- }
-
- // Output the addresses found
- for _, queryName := range browseRequestResults.Response.GetQueryNames() {
- results := browseRequestResults.Response.GetQueryResults(queryName)
- for _, result := range results {
- log.Infof("Found KNX device at address: %v querying device information: \n", result.Address)
-
- // Create a read-request to read the manufacturer and hardware ids
- readRequestBuilder := connection.ReadRequestBuilder()
- readRequestBuilder.AddQuery("manufacturerId", result.Address+"/0/12")
- readRequestBuilder.AddQuery("applicationProgramVersion", result.Address+"/3/13")
- readRequestBuilder.AddQuery("interfaceProgramVersion", result.Address+"/4/13")
- readRequest, err := readRequestBuilder.Build()
- if err != nil {
- log.Errorf("Got an error creating read-request: %s", err.Error())
- t.Fail()
- return
- }
-
- // Execute the read-requests
- rrr := readRequest.Execute()
- readResult := <-rrr
- if readResult.Err != nil {
- log.Errorf("got an error executing read-request: %s", readResult.Err.Error())
- t.Fail()
- return
- }
-
- // Check the response
- readResponse := readResult.Response
- if readResponse.GetResponseCode("manufacturerId") != apiModel.PlcResponseCode_OK {
- log.Errorf("Got an error response code %d for field 'manufacturerId'", readResponse.GetResponseCode("manufacturerId"))
- t.Fail()
- continue
- }
- if readResponse.GetResponseCode("applicationProgramVersion") != apiModel.PlcResponseCode_OK && readResponse.GetResponseCode("interfaceProgramVersion") != apiModel.PlcResponseCode_OK {
- log.Errorf("Got response code %d for address %s ('programVersion')",
- readResponse.GetResponseCode("applicationProgramVersion"), result.Address+"/3/13")
- log.Errorf("Got response code %d for address %s ('programVersion')",
- readResponse.GetResponseCode("interfaceProgramVersion"), result.Address+"/4/13")
- t.Fail()
- }
-
- manufacturerId := readResponse.GetValue("manufacturerId").GetUint16()
- if readResponse.GetResponseCode("applicationProgramVersion") == apiModel.PlcResponseCode_OK {
- programVersion := readResponse.GetValue("applicationProgramVersion")
- programVersionBytes := utils.PlcValueUint8ListToByteArray(programVersion)
- log.Infof(" - Manufacturer Id: %d, Application Program Version: %s\n", manufacturerId, hex.EncodeToString(programVersionBytes))
- } else if readResponse.GetResponseCode("interfaceProgramVersion") == apiModel.PlcResponseCode_OK {
- programVersion := readResponse.GetValue("interfaceProgramVersion")
- programVersionBytes := utils.PlcValueUint8ListToByteArray(programVersion)
- log.Infof(" - Manufacturer Id: %d, Interface Program Version: %s\n", manufacturerId, hex.EncodeToString(programVersionBytes))
- }
- }
- }
-
- log.Infof("Operation finished in %s", time.Since(startTime))
-}
-
-func TestKnxNetIpPlc4goBlockingBrowseWithCallback(t *testing.T) {
- Init()
-
- startTime := time.Now()
-
- log.Debug("Initializing PLC4X")
- driverManager := plc4go.NewPlcDriverManager()
- log.Debug("Registering KNXnet/IP driver")
- driverManager.RegisterDriver(knxnetip.NewKnxNetIpDriver())
- log.Debug("Registering UDP transport")
- driverManager.RegisterTransport(udp.NewUdpTransport())
-
- // Create a connection string from the discovery result.
- connectionString := "knxnet-ip:udp://192.168.42.11:3671"
- crc := driverManager.GetConnection(connectionString)
- connectionResult := <-crc
- if connectionResult.Err != nil {
- log.Errorf("Got an error getting a connection: %s", connectionResult.Err.Error())
- t.Fail()
- return
- }
- log.Info("Got a connection")
- connection := connectionResult.Connection
- defer connection.BlockingClose()
-
- // Build a browse request, to scan the KNX network for KNX devices
- // (Limiting the range to only the actually used range of addresses)
- browseRequestBuilder := connection.BrowseRequestBuilder()
- browseRequestBuilder.AddQuery("findAllKnxDevices", "[1-3].[1-6].[1-60]")
- browseRequest, err := browseRequestBuilder.Build()
- if err != nil {
- log.Errorf("Got an error preparing browse-request: %s", connectionResult.Err.Error())
- t.Fail()
- return
- }
-
- // Execute the browse-request
- log.Info("Scanning for KNX devices")
-
- brr := browseRequest.ExecuteWithInterceptor(func(result apiModel.PlcBrowseEvent) bool {
- if result.Err != nil {
- return false
- }
-
- // Create a read-request to read the manufacturer and hardware ids
- readRequestBuilder := connection.ReadRequestBuilder()
- readRequestBuilder.AddQuery("manufacturerId", result.Result.Address+"/0/12")
- readRequestBuilder.AddQuery("applicationProgramVersion", result.Result.Address+"/3/13")
- readRequestBuilder.AddQuery("interfaceProgramVersion", result.Result.Address+"/4/13")
- readRequest, err := readRequestBuilder.Build()
- if err != nil {
- log.Errorf("Got an error creating read-request: %s", err.Error())
- t.Fail()
- return false
- }
-
- // Execute the read-requests
- rrr := readRequest.Execute()
- readResult := <-rrr
- if readResult.Err != nil {
- log.Errorf("got an error executing read-request: %s", readResult.Err.Error())
- t.Fail()
- return false
- }
-
- // Check the response
- readResponse := readResult.Response
- if readResponse.GetResponseCode("manufacturerId") != apiModel.PlcResponseCode_OK {
- log.Errorf("Got an error response code %d for field 'manufacturerId'", readResponse.GetResponseCode("manufacturerId"))
- t.Fail()
- return false
- }
- if readResponse.GetResponseCode("applicationProgramVersion") != apiModel.PlcResponseCode_OK && readResponse.GetResponseCode("interfaceProgramVersion") != apiModel.PlcResponseCode_OK {
- log.Errorf("Got response code %d for address %s ('programVersion')",
- readResponse.GetResponseCode("applicationProgramVersion"), result.Result.Address+"/3/13")
- log.Errorf("Got response code %d for address %s ('programVersion')",
- readResponse.GetResponseCode("interfaceProgramVersion"), result.Result.Address+"/4/13")
- t.Fail()
- }
-
- manufacturerId := readResponse.GetValue("manufacturerId").GetUint16()
- if readResponse.GetResponseCode("applicationProgramVersion") == apiModel.PlcResponseCode_OK {
- programVersion := readResponse.GetValue("applicationProgramVersion")
- programVersionBytes := utils.PlcValueUint8ListToByteArray(programVersion)
- log.Infof(" - Manufacturer Id: %d, Application Program Version: %s\n", manufacturerId, hex.EncodeToString(programVersionBytes))
- } else if readResponse.GetResponseCode("interfaceProgramVersion") == apiModel.PlcResponseCode_OK {
- programVersion := readResponse.GetValue("interfaceProgramVersion")
- programVersionBytes := utils.PlcValueUint8ListToByteArray(programVersion)
- log.Infof(" - Manufacturer Id: %d, Interface Program Version: %s\n", manufacturerId, hex.EncodeToString(programVersionBytes))
- }
- return true
- })
- browseRequestResults := <-brr
- if browseRequestResults.Err != nil {
- log.Errorf("Got an error scanning for KNX devices: %s", connectionResult.Err.Error())
- t.Fail()
- return
- }
-
- log.Infof("Operation finished in %s", time.Since(startTime))
-}
-
-func TestKnxNetIpPlc4goGroupAddressRead(t *testing.T) {
- driverManager := plc4go.NewPlcDriverManager()
- driverManager.RegisterDriver(knxnetip.NewKnxNetIpDriver())
- driverManager.RegisterTransport(udp.NewUdpTransport())
-
- // Get a connection to a remote PLC
- crc := driverManager.GetConnection("knxnet-ip://192.168.42.11")
-
- // Wait for the driver to connect (or not)
- connectionResult := <-crc
- if connectionResult.Err != nil {
- t.Errorf("error connecting to PLC: %s", connectionResult.Err.Error())
- t.Fail()
- return
- }
- connection := connectionResult.Connection
- defer connection.BlockingClose()
-
- attributes := connection.GetMetadata().GetConnectionAttributes()
- fmt.Printf("Successfully connected to KNXnet/IP Gateway '%s' with KNX address '%s' got assigned client KNX address '%s'\n",
- attributes["GatewayName"],
- attributes["GatewayKnxAddress"],
- attributes["ClientKnxAddress"])
-
- // Try to ping the remote device
- pingResultChannel := connection.Ping()
- pingResult := <-pingResultChannel
- if pingResult.Err != nil {
- t.Errorf("couldn't ping device: %s", pingResult.Err.Error())
- t.Fail()
- return
- }
-
- srb := connection.SubscriptionRequestBuilder()
- srb.AddChangeOfStateItem("heating-actual-temperature", "*/*/10:DPT_Value_Temp")
- srb.AddChangeOfStateItem("heating-target-temperature", "*/*/11:DPT_Value_Temp")
- srb.AddChangeOfStateItem("heating-valve-open", "*/*/12:DPT_OpenClose")
- srb.AddItemHandler(knxEventHandler)
- subscriptionRequest, err := srb.Build()
- if err != nil {
- t.Errorf("error preparing subscription-request: %s", connectionResult.Err.Error())
- t.Fail()
- return
- }
-
- // Execute a subscription-request
- rrc := subscriptionRequest.Execute()
-
- // Wait for the response to finish
- rrr := <-rrc
- if rrr.Err != nil {
- t.Errorf("error executing read-request: %s", rrr.Err.Error())
- t.Fail()
- return
- }
-
- // Wait 2 minutes
- time.Sleep(120 * time.Second)
-
- // Execute a read request
- rrb := connection.ReadRequestBuilder()
- rrb.AddQuery("energy-consumption", "1/1/211:DPT_Value_Power")
- rrb.AddQuery("actual-temperatures", "*/*/10:DPT_Value_Temp")
- rrb.AddQuery("set-temperatures", "*/*/11:DPT_Value_Temp")
- rrb.AddQuery("window-status", "*/*/[60,64]:DPT_Value_Temp")
- rrb.AddQuery("power-consumption", "*/*/[111,121,131,141]:DPT_Value_Temp")
- readRequest, err := rrb.Build()
- if err == nil {
- rrr := readRequest.Execute()
- readRequestResult := <-rrr
- if readRequestResult.Err == nil {
- for _, fieldName := range readRequestResult.Response.GetFieldNames() {
- if readRequestResult.Response.GetResponseCode(fieldName) == apiModel.PlcResponseCode_OK {
- fmt.Printf(" - Field %s Value %s\n", fieldName, readRequestResult.Response.GetValue(fieldName).GetString())
- }
- }
- }
- }
-}
-
-func TestKnxNetIpPlc4goPropertyRead(t *testing.T) {
- Init()
-
- driverManager := plc4go.NewPlcDriverManager()
- driverManager.RegisterDriver(knxnetip.NewKnxNetIpDriver())
- driverManager.RegisterTransport(udp.NewUdpTransport())
-
- // Get a connection to a remote PLC
- crc := driverManager.GetConnection("knxnet-ip://192.168.42.11")
-
- // Wait for the driver to connect (or not)
- connectionResult := <-crc
- if connectionResult.Err != nil {
- t.Errorf("error connecting to PLC: %s", connectionResult.Err.Error())
- t.Fail()
- return
- }
- connection := connectionResult.Connection
- defer connection.BlockingClose()
-
- readRequestBuilder := connection.ReadRequestBuilder()
- readRequestBuilder.AddQuery("manufacturerId", "1.1.10/0/12")
- readRequestBuilder.AddQuery("programVersion", "1.1.10/3/13")
- readRequest, _ := readRequestBuilder.Build()
-
- rrr := readRequest.Execute()
- readResult := <-rrr
-
- fmt.Printf("Got result %v", readResult)
-}
-
-func knxEventHandler(event apiModel.PlcSubscriptionEvent) {
- for _, fieldName := range event.GetFieldNames() {
- if event.GetResponseCode(fieldName) == apiModel.PlcResponseCode_OK {
- groupAddress := event.GetAddress(fieldName)
- fmt.Printf("Got update for field %s with address %s. Value changed to: %s\n",
- fieldName, groupAddress, event.GetValue(fieldName).GetString())
- }
- }
-}
-
-func TestKnxNetIpPlc4goMemoryRead(t *testing.T) {
- driverManager := plc4go.NewPlcDriverManager()
- driverManager.RegisterDriver(knxnetip.NewKnxNetIpDriver())
- driverManager.RegisterTransport(udp.NewUdpTransport())
-
- // Get a connection to a remote PLC
- crc := driverManager.GetConnection("knxnet-ip://192.168.42.11")
-
- // Wait for the driver to connect (or not)
- connectionResult := <-crc
- if connectionResult.Err != nil {
- t.Errorf("error connecting to PLC: %s", connectionResult.Err.Error())
- t.Fail()
- return
- }
- connection := connectionResult.Connection
- defer connection.BlockingClose()
-
- /////////////////////////////////////////////////////////////////////////////////////////////////////
- // Group Address Table reading
- /////////////////////////////////////////////////////////////////////////////////////////////////////
-
- // First of all, request the starting address of the group address table
- readRequestBuilder := connection.ReadRequestBuilder()
- readRequestBuilder.AddQuery("groupAddressTableAddress", "1.1.10/1/7")
- readRequest, err := readRequestBuilder.Build()
- if err != nil {
- t.Errorf("error creating read request: %s", err.Error())
- t.Fail()
- return
- }
- rrr := readRequest.Execute()
- readResult := <-rrr
- groupAddressTableStartAddress := readResult.Response.GetValue("groupAddressTableAddress").GetUint16()
-
- // Then read one byte at the given location.
- // This will return the number of entries in the group address table (each 2 bytes)
- readRequestBuilder = connection.ReadRequestBuilder()
- readRequestBuilder.AddQuery("numberOfAddressTableEntries", fmt.Sprintf("1.1.10#%X:USINT",
- groupAddressTableStartAddress))
- readRequest, _ = readRequestBuilder.Build()
- rrr = readRequest.Execute()
- readResult = <-rrr
- numGroupAddresses := readResult.Response.GetValue("numberOfAddressTableEntries").GetUint8()
-
- // Read the data in the group address table
- readRequestBuilder = connection.ReadRequestBuilder()
- // TODO: This request needs to be automatically split up into multiple requests.
- // Reasons for splitting up:
- // - Max APDU Size exceeded
- // - Max 63 bytes readable in one request, due to max of count field
- readRequestBuilder.AddQuery("groupAddressTable", fmt.Sprintf("1.1.10#%X:UINT[%d]",
- groupAddressTableStartAddress+3, numGroupAddresses-1))
- readRequest, _ = readRequestBuilder.Build()
- rrr = readRequest.Execute()
- readResult = <-rrr
-
- // Output the group addresses
- var knxGroupAddresses []*driverModel.KnxGroupAddress
- for _, groupAddress := range readResult.Response.GetValue("groupAddressTable").GetList() {
- groupAddress := knxnetip.Uint16ToKnxGroupAddress(groupAddress.GetUint16(), 3)
- knxGroupAddresses = append(knxGroupAddresses, groupAddress)
- }
-
- /////////////////////////////////////////////////////////////////////////////////////////////////////
- // Group Address Association Table reading
- /////////////////////////////////////////////////////////////////////////////////////////////////////
-
- // Now we read the group address association table address
- readRequestBuilder = connection.ReadRequestBuilder()
- readRequestBuilder.AddQuery("groupAddressAssociationTableAddress", "1.1.10/2/7")
- readRequest, err = readRequestBuilder.Build()
- if err != nil {
- t.Errorf("error creating read request: %s", err.Error())
- t.Fail()
- return
- }
- rrr = readRequest.Execute()
- readResult = <-rrr
- groupAddressAssociationTableAddress := readResult.Response.GetValue("groupAddressAssociationTableAddress").GetUint16()
-
- // Then read one uint16 at the given location.
- // This will return the number of entries in the group address table (each 2 bytes)
- readRequestBuilder = connection.ReadRequestBuilder()
- readRequestBuilder.AddQuery("numberOfGroupAddressAssociationTableEntries", fmt.Sprintf("1.1.10#%X:USINT",
- groupAddressAssociationTableAddress))
- readRequest, _ = readRequestBuilder.Build()
- rrr = readRequest.Execute()
- readResult = <-rrr
- numberOfGroupAddressAssociationTableEntries := readResult.Response.GetValue("numberOfGroupAddressAssociationTableEntries").GetUint8()
-
- // Read the data in the group address table
- readRequestBuilder = connection.ReadRequestBuilder()
- // TODO: This request needs to be automatically split up into multiple requests.
- // Reasons for splitting up:
- // - Max APDU Size exceeded
- // - Max 63 bytes readable in one request, due to max of count field
- readRequestBuilder.AddQuery("groupAddressAssociationTable", fmt.Sprintf("1.1.10#%X:UINT[%d]",
- groupAddressAssociationTableAddress+1, numberOfGroupAddressAssociationTableEntries))
- readRequest, _ = readRequestBuilder.Build()
- rrr = readRequest.Execute()
- readResult = <-rrr
-
- // Output the group addresses
- for _, groupAddressAssociation := range readResult.Response.GetValue("groupAddressAssociationTable").GetList() {
- addressIndex := uint8(groupAddressAssociation.GetUint16() >> 8)
- comObjectNumber := uint8(groupAddressAssociation.GetUint16() & 0xFF)
- if (addressIndex > 0) && (addressIndex < uint8(len(knxGroupAddresses))) {
- groupAddress := knxGroupAddresses[addressIndex-1]
- fmt.Printf("Com Object %d bound to group address %s\n",
- comObjectNumber, knxnetip.GroupAddressToString(groupAddress))
- }
- }
-
- /////////////////////////////////////////////////////////////////////////////////////////////////////
- // Com Object Table reading
- /////////////////////////////////////////////////////////////////////////////////////////////////////
-
- // Now we read the group address association table address
- readRequestBuilder = connection.ReadRequestBuilder()
- readRequestBuilder.AddQuery("comObjectTableAddress", "1.1.10/3/7")
- readRequest, err = readRequestBuilder.Build()
- if err != nil {
- t.Errorf("error creating read request: %s", err.Error())
- t.Fail()
- return
- }
- rrr = readRequest.Execute()
- readResult = <-rrr
- comObjectTableAddress := readResult.Response.GetValue("comObjectTableAddress").GetUint16()
-
- fmt.Printf("%d", comObjectTableAddress)
-}
diff --git a/plc4go/cmd/main/drivers/modbus_test.go b/plc4go/cmd/main/drivers/modbus_test.go
index 1a0f475..65cf1e2 100644
--- a/plc4go/cmd/main/drivers/modbus_test.go
+++ b/plc4go/cmd/main/drivers/modbus_test.go
@@ -22,13 +22,8 @@ import (
"encoding/hex"
"encoding/xml"
"fmt"
- "github.com/apache/plc4x/plc4go/internal/plc4go/modbus"
"github.com/apache/plc4x/plc4go/internal/plc4go/modbus/readwrite/model"
- "github.com/apache/plc4x/plc4go/internal/plc4go/spi/transports/tcp"
"github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
- "github.com/apache/plc4x/plc4go/pkg/plc4go"
- "net"
- "os"
"strings"
"testing"
)
@@ -73,141 +68,3 @@ func test(t *testing.T, rawMessage string, response bool) {
}
}
}
-
-//
-// Test that actually sends a read-request to a remote Modbus Slave
-//
-func TestConnection(t *testing.T) {
-
- pdu := model.NewModbusPDUReadInputRegistersRequest(1, 1)
- adu := model.NewModbusTcpADU(0, 255, pdu)
-
- wb := utils.NewWriteBuffer()
- adu.Serialize(*wb)
-
- servAddr := "192.168.23.30:502"
- tcpAddr, err := net.ResolveTCPAddr("tcp", servAddr)
- if err != nil {
- println("ResolveTCPAddr failed:", err.Error())
- os.Exit(1)
- }
-
- conn, err := net.DialTCP("tcp", nil, tcpAddr)
- if err != nil {
- println("Dial failed:", err.Error())
- os.Exit(1)
- }
-
- _, err = conn.Write(wb.GetBytes())
- if err != nil {
- println("Write to server failed:", err.Error())
- os.Exit(1)
- }
-
- buffer := make([]byte, 1024)
-
- numBytes, err := conn.Read(buffer)
- if err != nil {
- println("Write to server failed:", err.Error())
- os.Exit(1)
- }
-
- rb := utils.NewReadBuffer(buffer[0:numBytes])
- response, err := model.ModbusTcpADUParse(rb, true)
- if err != nil {
- println("Parsing response failed:", err.Error())
- os.Exit(1)
- }
-
- fmt.Println(response)
-
- conn.Close()
-}
-
-func TestPlc4goDriver(t *testing.T) {
- driverManager := plc4go.NewPlcDriverManager()
- driverManager.RegisterDriver(modbus.NewModbusDriver())
- driverManager.RegisterTransport(tcp.NewTcpTransport())
-
- // Get a connection to a remote PLC
- crc := driverManager.GetConnection("modbus://192.168.23.30?unit-identifier=1")
-
- // Wait for the driver to connect (or not)
- connectionResult := <-crc
- if connectionResult.Err != nil {
- t.Errorf("error connecting to PLC: %s", connectionResult.Err.Error())
- t.Fail()
- return
- }
- connection := connectionResult.Connection
-
- if !connection.GetMetadata().CanRead() {
- fmt.Printf("This connection doesn't support read operations")
- return
- }
-
- // Try to ping the remote device
- pingResultChannel := connection.Ping()
- pingResult := <-pingResultChannel
- if pingResult.Err != nil {
- t.Errorf("couldn't ping device: %s", pingResult.Err.Error())
- t.Fail()
- return
- }
-
- // Make sure the connection is closed at the end
- defer connection.BlockingClose()
-
- // Prepare a read-request
- rrb := connection.ReadRequestBuilder()
- rrb.AddQuery("field1", "holding-register:3:WORD")
- rrb.AddQuery("field2", "holding-register:26:REAL")
- readRequest, err := rrb.Build()
- if err != nil {
- t.Errorf("error preparing read-request: %s", connectionResult.Err.Error())
- t.Fail()
- return
- }
-
- // Execute a read-request
- rrc := readRequest.Execute()
-
- // Wait for the response to finish
- rrr := <-rrc
- if rrr.Err != nil {
- t.Errorf("error executing read-request: %s", rrr.Err.Error())
- t.Fail()
- return
- }
-
- // Do something with the response
- value1 := rrr.Response.GetValue("field1")
- value2 := rrr.Response.GetValue("field2")
- fmt.Printf("\n\nResult field1: %f\n", value1.GetFloat32())
- fmt.Printf("\n\nResult field1: %f\n", value2.GetFloat32())
-
- // Prepare a write-request
- wrb := connection.WriteRequestBuilder()
- wrb.AddQuery("field1", "holding-register:1:REAL", 1.2345)
- wrb.AddQuery("field2", "holding-register:3:REAL", 2.3456)
- writeRequest, err := rrb.Build()
- if err != nil {
- t.Errorf("error preparing read-request: %s", connectionResult.Err.Error())
- t.Fail()
- return
- }
-
- // Execute a write-request
- wrc := writeRequest.Execute()
-
- // Wait for the response to finish
- wrr := <-wrc
- if wrr.Err != nil {
- t.Errorf("error executing read-request: %s", rrr.Err.Error())
- t.Fail()
- return
- }
-
- fmt.Printf("\n\nResult field1: %d\n", wrr.Response.GetResponseCode("field1"))
- fmt.Printf("\n\nResult field2: %d\n", wrr.Response.GetResponseCode("field2"))
-}
diff --git a/plc4go/cmd/main/drivers/tests/knx_discovery_test.go b/plc4go/cmd/main/drivers/tests/knx_discovery_test.go
deleted file mode 100644
index b4b0f54..0000000
--- a/plc4go/cmd/main/drivers/tests/knx_discovery_test.go
+++ /dev/null
@@ -1,613 +0,0 @@
-//
-// 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 tests
-
-import (
- "encoding/hex"
- "errors"
- "fmt"
- "github.com/apache/plc4x/plc4go/internal/plc4go/knxnetip/readwrite/model"
- "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
- log "github.com/sirupsen/logrus"
- "net"
- "strconv"
- "strings"
- "testing"
-)
-
-func TestKnxAutoDiscovery(t *testing.T) {
- interfaces, err := net.Interfaces()
- if err != nil {
- log.Errorf("Error getting interefaces: %s", err.Error())
- t.Fail()
- }
-
- for _, interf := range interfaces {
- addrs, err := interf.Addrs()
- if err != nil {
- log.Errorf("Error getting addresses of interface: %s. Got error: %s", interf.Name, err.Error())
- t.Fail()
- }
- for _, addr := range addrs {
- var ipv4Addr net.IP
- switch addr.(type) {
- // If the device is configured to communicate with a subnet
- case *net.IPNet:
- ipv4Addr = addr.(*net.IPNet).IP.To4()
-
- // If the device is configured for a point-to-point connection
- case *net.IPAddr:
- ipv4Addr = addr.(*net.IPAddr).IP.To4()
- }
-
- // Only if this is an IPv4 address, will we open a port for it.
- if ipv4Addr != nil {
- // Open a listening port on a random free port number
- udpIpv4Addr := &net.UDPAddr{IP: ipv4Addr, Port: 0}
-
- udpSocket, err := net.ListenUDP("udp4", udpIpv4Addr)
- if err != nil {
- log.Warnf("Error creating listening port for KNX on address %s", ipv4Addr.String())
- continue
- }
-
- go func() {
- buf := make([]byte, 1024)
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////
- // Send the Search Request using the current network device
- ////////////////////////////////////////////////////////////////////////////////////////////////////
-
- localIp := udpSocket.LocalAddr().(*net.UDPAddr).IP
- localPort := udpSocket.LocalAddr().(*net.UDPAddr).Port
-
- // Prepare the discovery packet data
- searchRequestMessage := model.NewSearchRequest(model.NewHPAIDiscoveryEndpoint(
- model.HostProtocolCode_IPV4_UDP,
- model.NewIPAddress(utils.ByteArrayToInt8Array(localIp.To4())),
- uint16(localPort)))
- writeBuffer := utils.NewWriteBuffer()
- err := searchRequestMessage.Serialize(*writeBuffer)
- if err != nil {
- panic("Failed preparing search request.")
- }
-
- // This is the multicast address and port KNX devices are supposed to listen to.
- destination := &net.UDPAddr{IP: net.IPv4(224, 0, 23, 12), Port: 3671}
-
- // Send the message
- _, err = udpSocket.WriteTo(writeBuffer.GetBytes(), destination)
- if err != nil {
- panic("Failed sending search request.")
- }
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////
- // Wait for a response from a device that supports tunneling
- ////////////////////////////////////////////////////////////////////////////////////////////////////
-
- var searchResponse *model.SearchResponse
- var gatewayAddr *net.UDPAddr
- for searchResponse == nil {
- // Read a new packet from the socket
- _, src, err := udpSocket.ReadFromUDP(buf)
- if err != nil {
- panic("Error reading from KNX UDP socket")
- }
-
- readBuffer := utils.NewReadBuffer(buf)
- knxMessage, err := model.KnxNetIpMessageParse(readBuffer)
- if err != nil {
- hexEncodedPayload := hex.EncodeToString(buf)
- panic(fmt.Sprintf("Error decoding incoming KNX message from %v with payload %s", src, hexEncodedPayload))
- }
-
- switch knxMessage.Child.(type) {
- // If this is a search response and the current device supports tunneling,
- // we've found what we're looking for.
- case *model.SearchResponse:
- curSearchResponse := model.CastSearchResponse(knxMessage)
- for _, serviceId := range curSearchResponse.DibSuppSvcFamilies.ServiceIds {
- switch (*serviceId).Child.(type) {
- case *model.KnxNetIpTunneling:
- searchResponse = curSearchResponse
- gatewayAddr = src
- break
- }
- }
- }
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////
- // Send a connection request to the device we just found
- ////////////////////////////////////////////////////////////////////////////////////////////////////
-
- connectionRequestMessage := model.NewConnectionRequest(
- model.NewHPAIDiscoveryEndpoint(
- model.HostProtocolCode_IPV4_UDP,
- model.NewIPAddress(utils.ByteArrayToInt8Array(localIp.To4())),
- uint16(localPort)),
- model.NewHPAIDataEndpoint(
- model.HostProtocolCode_IPV4_UDP,
- model.NewIPAddress(utils.ByteArrayToInt8Array(localIp.To4())),
- uint16(localPort)),
- model.NewConnectionRequestInformationTunnelConnection(model.KnxLayer_TUNNEL_LINK_LAYER))
- writeBuffer = utils.NewWriteBuffer()
- err = connectionRequestMessage.Serialize(*writeBuffer)
- if err != nil {
- panic("Failed preparing connection request.")
- }
-
- // Send the message
- _, err = udpSocket.WriteTo(writeBuffer.GetBytes(), gatewayAddr)
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////
- // Wait for a connection response
- ////////////////////////////////////////////////////////////////////////////////////////////////////
-
- var communicationChannelId uint8
- for communicationChannelId == 0 {
- // Read a new packet from the socket
- _, src, err := udpSocket.ReadFromUDP(buf)
- if err != nil {
- panic("Error reading from KNX UDP socket")
- }
-
- readBuffer := utils.NewReadBuffer(buf)
- knxMessage, err := model.KnxNetIpMessageParse(readBuffer)
- if err != nil {
- hexEncodedPayload := hex.EncodeToString(buf)
- panic(fmt.Sprintf("Error decoding incoming KNX message from %v with payload %s", src, hexEncodedPayload))
- }
-
- switch knxMessage.Child.(type) {
- case *model.ConnectionResponse:
- connectionResponse := model.CastConnectionResponse(knxMessage)
- if connectionResponse.Status == model.Status_NO_ERROR {
- communicationChannelId = connectionResponse.CommunicationChannelId
- } else {
- panic("Got an error while connecting")
- }
- }
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////
- // Send a config connection request
- ////////////////////////////////////////////////////////////////////////////////////////////////////
-
- /*configConnectionRequestMessage := model.NewConnectionRequest(
- model.NewHPAIDiscoveryEndpoint(
- model.HostProtocolCode_IPV4_UDP,
- model.NewIPAddress(utils.ByteArrayToInt8Array(localIp.To4())),
- uint16(localPort)),
- model.NewHPAIDataEndpoint(
- model.HostProtocolCode_IPV4_UDP,
- model.NewIPAddress(utils.ByteArrayToInt8Array(localIp.To4())),
- uint16(localPort)),
- model.NewConnectionRequestInformationDeviceManagement())
- writeBuffer = utils.NewWriteBuffer()
- err = configConnectionRequestMessage.Serialize(*writeBuffer)
- if err != nil {
- panic("Failed preparing connection request.")
- }
-
- // Send the message
- _, err = udpSocket.WriteTo(writeBuffer.GetBytes(), gatewayAddr)
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////
- // Wait for a config connection response
- ////////////////////////////////////////////////////////////////////////////////////////////////////
-
- var configCommunicationChannelId uint8
- for configCommunicationChannelId == 0 {
- // Read a new packet from the socket
- _, src, err := udpSocket.ReadFromUDP(buf)
- if err != nil {
- panic("Error reading from KNX UDP socket")
- }
-
- readBuffer := utils.NewReadBuffer(buf)
- knxMessage, err := model.KnxNetIpMessageParse(readBuffer)
- if err != nil {
- hexEncodedPayload := hex.EncodeToString(buf)
- panic(fmt.Sprintf("Error decoding incoming KNX message from %v with payload %s", src, hexEncodedPayload))
- }
-
- switch knxMessage.Child.(type) {
- case *model.ConnectionResponse:
- connectionResponse := model.CastConnectionResponse(knxMessage)
- if connectionResponse.Status == model.Status_NO_ERROR {
- configCommunicationChannelId = connectionResponse.CommunicationChannelId
- } else {
- panic("Got an error while connecting")
- }
-
- // Just ACK any incoming tunneling requests
- case *model.TunnelingRequest:
- tunnelingRequest := model.CastTunnelingRequest(knxMessage)
-
- tunnelingResponse := model.NewTunnelingResponse(
- model.NewTunnelingResponseDataBlock(
- tunnelingRequest.TunnelingRequestDataBlock.CommunicationChannelId,
- tunnelingRequest.TunnelingRequestDataBlock.SequenceCounter,
- model.Status_NO_ERROR))
- writeBuffer := utils.NewWriteBuffer()
- err = tunnelingResponse.Serialize(*writeBuffer)
- if err != nil {
- panic("Failed preparing tunneling response.")
- }
-
- // Send the message
- _, err = udpSocket.WriteTo(writeBuffer.GetBytes(), src)
- if err != nil {
- panic("Failed sending tunneling response.")
- }
- }
- }
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////
- // Send a prop-read request for PID_MEDIUM_TYPE
- ////////////////////////////////////////////////////////////////////////////////////////////////////
-
- mediumTypePropRequestMessage := model.NewDeviceConfigurationRequest(
- model.NewDeviceConfigurationRequestDataBlock(configCommunicationChannelId, uint8(0)),
- model.NewMPropReadReq(uint16(8), uint8(1), uint8(51), uint8(1), uint16(1)))
- writeBuffer = utils.NewWriteBuffer()
- err = mediumTypePropRequestMessage.Serialize(*writeBuffer)
- if err != nil {
- panic("Failed preparing config disconnect request.")
- }
-
- // Send the message
- _, err = udpSocket.WriteTo(writeBuffer.GetBytes(), gatewayAddr)
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////
- // Wait for a prop read response
- ////////////////////////////////////////////////////////////////////////////////////////////////////
-
- var mediumType uint16
- for mediumType == 0 {
- // Read a new packet from the socket
- _, src, err := udpSocket.ReadFromUDP(buf)
- if err != nil {
- panic("Error reading from KNX UDP socket")
- }
-
- readBuffer := utils.NewReadBuffer(buf)
- knxMessage, err := model.KnxNetIpMessageParse(readBuffer)
- if err != nil {
- hexEncodedPayload := hex.EncodeToString(buf)
- panic(fmt.Sprintf("Error decoding incoming KNX message from %v with payload %s", src, hexEncodedPayload))
- }
-
- switch knxMessage.Child.(type) {
- case *model.DeviceConfigurationRequest:
- deviceConfigurationRequest := model.CastDeviceConfigurationRequest(knxMessage)
- switch deviceConfigurationRequest.Cemi.Child.(type) {
- case *model.MPropReadCon:
- readCon := model.CastMPropReadCon(deviceConfigurationRequest.Cemi)
- // TODO: This should be renamed to "Data"
- mediumType = readCon.Unknown
-
- // Send and ACK for this response
- tunnelingResponse := model.NewTunnelingResponse(
- model.NewTunnelingResponseDataBlock(
- deviceConfigurationRequest.DeviceConfigurationRequestDataBlock.CommunicationChannelId,
- deviceConfigurationRequest.DeviceConfigurationRequestDataBlock.SequenceCounter,
- model.Status_NO_ERROR))
- writeBuffer := utils.NewWriteBuffer()
- err = tunnelingResponse.Serialize(*writeBuffer)
- if err != nil {
- panic("Failed preparing tunneling response.")
- }
-
- // Send the message
- _, err = udpSocket.WriteTo(writeBuffer.GetBytes(), src)
- if err != nil {
- panic("Failed sending tunneling response.")
- }
- }
-
- // Just ACK any incoming tunneling requests
- case *model.TunnelingRequest:
- tunnelingRequest := model.CastTunnelingRequest(knxMessage)
-
- tunnelingResponse := model.NewTunnelingResponse(
- model.NewTunnelingResponseDataBlock(
- tunnelingRequest.TunnelingRequestDataBlock.CommunicationChannelId,
- tunnelingRequest.TunnelingRequestDataBlock.SequenceCounter,
- model.Status_NO_ERROR))
- writeBuffer := utils.NewWriteBuffer()
- err = tunnelingResponse.Serialize(*writeBuffer)
- if err != nil {
- panic("Failed preparing tunneling response.")
- }
-
- // Send the message
- _, err = udpSocket.WriteTo(writeBuffer.GetBytes(), src)
- if err != nil {
- panic("Failed sending tunneling response.")
- }
- }
- }
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////
- // Send a prop-read request for PID_MAX_APDULENGTH
- ////////////////////////////////////////////////////////////////////////////////////////////////////
-
- maxApdulengthPropRequestMessage := model.NewDeviceConfigurationRequest(
- model.NewDeviceConfigurationRequestDataBlock(configCommunicationChannelId, uint8(1)),
- model.NewMPropReadReq(uint16(0), uint8(1), uint8(56), uint8(1), uint16(1)))
- writeBuffer = utils.NewWriteBuffer()
- err = maxApdulengthPropRequestMessage.Serialize(*writeBuffer)
- if err != nil {
- panic("Failed preparing config disconnect request.")
- }
-
- // Send the message
- _, err = udpSocket.WriteTo(writeBuffer.GetBytes(), gatewayAddr)
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////
- // Wait for a prop read response
- ////////////////////////////////////////////////////////////////////////////////////////////////////
-
- var maxApdulength uint16
- for maxApdulength == 0 {
- // Read a new packet from the socket
- _, src, err := udpSocket.ReadFromUDP(buf)
- if err != nil {
- panic("Error reading from KNX UDP socket")
- }
-
- readBuffer := utils.NewReadBuffer(buf)
- knxMessage, err := model.KnxNetIpMessageParse(readBuffer)
- if err != nil {
- hexEncodedPayload := hex.EncodeToString(buf)
- panic(fmt.Sprintf("Error decoding incoming KNX message from %v with payload %s", src, hexEncodedPayload))
- }
-
- switch knxMessage.Child.(type) {
- case *model.DeviceConfigurationRequest:
- deviceConfigurationRequest := model.CastDeviceConfigurationRequest(knxMessage)
- switch deviceConfigurationRequest.Cemi.Child.(type) {
- case *model.MPropReadCon:
- readCon := model.CastMPropReadCon(deviceConfigurationRequest.Cemi)
- // TODO: This should be renamed to "Data"
- maxApdulength = readCon.Unknown
-
- // Send and ACK for this response
- tunnelingResponse := model.NewTunnelingResponse(
- model.NewTunnelingResponseDataBlock(
- deviceConfigurationRequest.DeviceConfigurationRequestDataBlock.CommunicationChannelId,
- deviceConfigurationRequest.DeviceConfigurationRequestDataBlock.SequenceCounter,
- model.Status_NO_ERROR))
- writeBuffer := utils.NewWriteBuffer()
- err = tunnelingResponse.Serialize(*writeBuffer)
- if err != nil {
- panic("Failed preparing tunneling response.")
- }
-
- // Send the message
- _, err = udpSocket.WriteTo(writeBuffer.GetBytes(), src)
- if err != nil {
- panic("Failed sending tunneling response.")
- }
- }
-
- // Just ACK any incoming tunneling requests
- case *model.TunnelingRequest:
- tunnelingRequest := model.CastTunnelingRequest(knxMessage)
-
- tunnelingResponse := model.NewTunnelingResponse(
- model.NewTunnelingResponseDataBlock(
- tunnelingRequest.TunnelingRequestDataBlock.CommunicationChannelId,
- tunnelingRequest.TunnelingRequestDataBlock.SequenceCounter,
- model.Status_NO_ERROR))
- writeBuffer := utils.NewWriteBuffer()
- err = tunnelingResponse.Serialize(*writeBuffer)
- if err != nil {
- panic("Failed preparing tunneling response.")
- }
-
- // Send the message
- _, err = udpSocket.WriteTo(writeBuffer.GetBytes(), src)
- if err != nil {
- panic("Failed sending tunneling response.")
- }
- }
- }
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////
- // Send a config connection disconnect request
- ////////////////////////////////////////////////////////////////////////////////////////////////////
-
- configConnectionDisconnectRequestMessage := model.NewDisconnectRequest(
- configCommunicationChannelId,
- model.NewHPAIControlEndpoint(
- model.HostProtocolCode_IPV4_UDP,
- model.NewIPAddress(utils.ByteArrayToInt8Array(localIp.To4())),
- uint16(localPort)))
- writeBuffer = utils.NewWriteBuffer()
- err = configConnectionDisconnectRequestMessage.Serialize(*writeBuffer)
- if err != nil {
- panic("Failed preparing config disconnect request.")
- }
-
- // Send the message
- _, err = udpSocket.WriteTo(writeBuffer.GetBytes(), gatewayAddr)
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////
- // Wait for a config disconnect response
- ////////////////////////////////////////////////////////////////////////////////////////////////////
-
- configDisconnected := false
- for !configDisconnected {
- // Read a new packet from the socket
- _, src, err := udpSocket.ReadFromUDP(buf)
- if err != nil {
- panic("Error reading from KNX UDP socket")
- }
-
- readBuffer := utils.NewReadBuffer(buf)
- knxMessage, err := model.KnxNetIpMessageParse(readBuffer)
- if err != nil {
- hexEncodedPayload := hex.EncodeToString(buf)
- panic(fmt.Sprintf("Error decoding incoming KNX message from %v with payload %s", src, hexEncodedPayload))
- }
-
- switch knxMessage.Child.(type) {
- case *model.DisconnectResponse:
- disconnectResponse := model.CastDisconnectResponse(knxMessage)
- if disconnectResponse.Status == model.Status_NO_ERROR {
- configDisconnected = true
- } else {
- panic("Got an error while connecting")
- }
-
- // Just ACK any incoming tunneling requests
- case *model.TunnelingRequest:
- tunnelingRequest := model.CastTunnelingRequest(knxMessage)
-
- tunnelingResponse := model.NewTunnelingResponse(
- model.NewTunnelingResponseDataBlock(
- tunnelingRequest.TunnelingRequestDataBlock.CommunicationChannelId,
- tunnelingRequest.TunnelingRequestDataBlock.SequenceCounter,
- model.Status_NO_ERROR))
- writeBuffer := utils.NewWriteBuffer()
- err = tunnelingResponse.Serialize(*writeBuffer)
- if err != nil {
- panic("Failed preparing tunneling response.")
- }
-
- // Send the message
- _, err = udpSocket.WriteTo(writeBuffer.GetBytes(), src)
- if err != nil {
- panic("Failed sending tunneling response.")
- }
- }
- }*/
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////
- // Send a device connection request to KNX address 1.1.10
- ////////////////////////////////////////////////////////////////////////////////////////////////////
-
- targetAddress, err := ParseKnxAddressString("1.1.10")
- if err != nil {
- panic("Failed preparing discovery request.")
- }
- deviceConnectionRequest := model.NewTunnelingRequest(
- model.NewTunnelingRequestDataBlock(0, 0),
- model.NewLDataReq(0, nil,
- model.NewLDataExtended(false, 6, uint8(0),
- model.NewKnxAddress(0, 0, 0), targetAddress,
- model.NewApduControlContainer(model.NewApduControlConnect(), false, 0),
- true, true, model.CEMIPriority_SYSTEM, false, false)))
- writeBuffer = utils.NewWriteBuffer()
- err = deviceConnectionRequest.Serialize(*writeBuffer)
- if err != nil {
- panic("Failed preparing device connection request.")
- }
-
- // Send the message
- _, err = udpSocket.WriteTo(writeBuffer.GetBytes(), gatewayAddr)
- if err != nil {
- panic("Failed sending device connection request.")
- }
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////
- // Wait for a device connection response
- ////////////////////////////////////////////////////////////////////////////////////////////////////
-
- for {
- // Read a new packet from the socket
- _, src, err := udpSocket.ReadFromUDP(buf)
- if err != nil {
- panic("Error reading from KNX UDP socket")
- }
-
- readBuffer := utils.NewReadBuffer(buf)
- knxMessage, err := model.KnxNetIpMessageParse(readBuffer)
- if err != nil {
- hexEncodedPayload := hex.EncodeToString(buf)
- panic(fmt.Sprintf("Error decoding incoming KNX message from %v with payload %s", src, hexEncodedPayload))
- }
-
- switch knxMessage.Child.(type) {
- case *model.TunnelingRequest:
- tunnelingRequest := model.CastTunnelingRequest(knxMessage)
-
- tunnelingResponse := model.NewTunnelingResponse(
- model.NewTunnelingResponseDataBlock(
- tunnelingRequest.TunnelingRequestDataBlock.CommunicationChannelId,
- tunnelingRequest.TunnelingRequestDataBlock.SequenceCounter,
- model.Status_NO_ERROR))
- writeBuffer := utils.NewWriteBuffer()
- err = tunnelingResponse.Serialize(*writeBuffer)
- if err != nil {
- panic("Failed preparing tunneling response.")
- }
-
- // Send the message
- _, err = udpSocket.WriteTo(writeBuffer.GetBytes(), src)
- if err != nil {
- panic("Failed sending tunneling response.")
- }
- }
- }
- }
- }
- }()
- }
- }
- }
-}
-
-func ParseKnxAddressString(knxAddressString string) ([]int8, error) {
- if strings.Count(knxAddressString, ".") != 2 {
- return nil, errors.New("this is not a valid knx address")
- }
-
- split := strings.Split(knxAddressString, ".")
-
- mainSegment, err := strconv.Atoi(split[0])
- if err != nil {
- return nil, errors.New("this is not a valid knx address")
- }
- if mainSegment < 0 || mainSegment > 15 {
- return nil, errors.New("this is not a valid knx address")
- }
-
- middleSegment, err := strconv.Atoi(split[1])
- if err != nil {
- return nil, errors.New("this is not a valid knx address")
- }
- if middleSegment < 0 || middleSegment > 15 {
- return nil, errors.New("this is not a valid knx address")
- }
-
- subSegment, err := strconv.Atoi(split[2])
- if err != nil {
- return nil, errors.New("this is not a valid knx address")
- }
- if subSegment < 0 || subSegment > 255 {
- return nil, errors.New("this is not a valid knx address")
- }
-
- return []int8{
- int8(mainSegment<<4 | middleSegment),
- int8(subSegment),
- }, nil
-}
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AdsAddDeviceNotificationRequest.go b/plc4go/internal/plc4go/ads/readwrite/model/AdsAddDeviceNotificationRequest.go
index 4d0657e..be0ab91 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AdsAddDeviceNotificationRequest.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AdsAddDeviceNotificationRequest.go
@@ -24,7 +24,6 @@ import (
"github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
log "github.com/sirupsen/logrus"
"io"
- "math/big"
)
// The data-structure of this message
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AdsMultiRequestItem.go b/plc4go/internal/plc4go/ads/readwrite/model/AdsMultiRequestItem.go
index 7470567..0f85551 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AdsMultiRequestItem.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AdsMultiRequestItem.go
@@ -19,189 +19,190 @@
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 AdsMultiRequestItem struct {
- Child IAdsMultiRequestItemChild
- IAdsMultiRequestItem
- IAdsMultiRequestItemParent
+ Child IAdsMultiRequestItemChild
+ IAdsMultiRequestItem
+ IAdsMultiRequestItemParent
}
// The corresponding interface
type IAdsMultiRequestItem interface {
- IndexGroup() uint32
- LengthInBytes() uint16
- LengthInBits() uint16
- Serialize(io utils.WriteBuffer) error
- xml.Marshaler
+ IndexGroup() uint32
+ LengthInBytes() uint16
+ LengthInBits() uint16
+ Serialize(io utils.WriteBuffer) error
+ xml.Marshaler
}
type IAdsMultiRequestItemParent interface {
- SerializeParent(io utils.WriteBuffer, child IAdsMultiRequestItem, serializeChildFunction func() error) error
- GetTypeName() string
+ SerializeParent(io utils.WriteBuffer, child IAdsMultiRequestItem, serializeChildFunction func() error) error
+ GetTypeName() string
}
type IAdsMultiRequestItemChild interface {
- Serialize(io utils.WriteBuffer) error
- InitializeParent(parent *AdsMultiRequestItem)
- GetTypeName() string
- IAdsMultiRequestItem
+ Serialize(io utils.WriteBuffer) error
+ InitializeParent(parent *AdsMultiRequestItem)
+ GetTypeName() string
+ IAdsMultiRequestItem
}
func NewAdsMultiRequestItem() *AdsMultiRequestItem {
- return &AdsMultiRequestItem{}
+ return &AdsMultiRequestItem{}
}
func CastAdsMultiRequestItem(structType interface{}) *AdsMultiRequestItem {
- castFunc := func(typ interface{}) *AdsMultiRequestItem {
- if casted, ok := typ.(AdsMultiRequestItem); ok {
- return &casted
- }
- if casted, ok := typ.(*AdsMultiRequestItem); ok {
- return casted
- }
- return nil
- }
- return castFunc(structType)
+ castFunc := func(typ interface{}) *AdsMultiRequestItem {
+ if casted, ok := typ.(AdsMultiRequestItem); ok {
+ return &casted
+ }
+ if casted, ok := typ.(*AdsMultiRequestItem); ok {
+ return casted
+ }
+ return nil
+ }
+ return castFunc(structType)
}
func (m *AdsMultiRequestItem) GetTypeName() string {
- return "AdsMultiRequestItem"
+ return "AdsMultiRequestItem"
}
func (m *AdsMultiRequestItem) LengthInBits() uint16 {
- lengthInBits := uint16(0)
+ lengthInBits := uint16(0)
- // 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 *AdsMultiRequestItem) LengthInBytes() uint16 {
- return m.LengthInBits() / 8
+ return m.LengthInBits() / 8
}
func AdsMultiRequestItemParse(io *utils.ReadBuffer, indexGroup uint32) (*AdsMultiRequestItem, error) {
- // Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type)
- var _parent *AdsMultiRequestItem
- var typeSwitchError error
- switch {
- case indexGroup == 61568:
- _parent, typeSwitchError = AdsMultiRequestItemReadParse(io)
- case indexGroup == 61569:
- _parent, typeSwitchError = AdsMultiRequestItemWriteParse(io)
- case indexGroup == 61570:
- _parent, typeSwitchError = AdsMultiRequestItemReadWriteParse(io)
- }
- 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
+ // Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type)
+ var _parent *AdsMultiRequestItem
+ var typeSwitchError error
+ switch {
+ case indexGroup == 61568L:
+ _parent, typeSwitchError = AdsMultiRequestItemReadParse(io)
+ case indexGroup == 61569L:
+ _parent, typeSwitchError = AdsMultiRequestItemWriteParse(io)
+ case indexGroup == 61570L:
+ _parent, typeSwitchError = AdsMultiRequestItemReadWriteParse(io)
+ }
+ 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
}
func (m *AdsMultiRequestItem) Serialize(io utils.WriteBuffer) error {
- return m.Child.Serialize(io)
+ return m.Child.Serialize(io)
}
func (m *AdsMultiRequestItem) SerializeParent(io utils.WriteBuffer, child IAdsMultiRequestItem, serializeChildFunction func() error) 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 *AdsMultiRequestItem) 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.ads.readwrite.AdsMultiRequestItemRead":
- var dt *AdsMultiRequestItemRead
- if m.Child != nil {
- dt = m.Child.(*AdsMultiRequestItemRead)
- }
- 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.ads.readwrite.AdsMultiRequestItemWrite":
- var dt *AdsMultiRequestItemWrite
- if m.Child != nil {
- dt = m.Child.(*AdsMultiRequestItemWrite)
- }
- 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.ads.readwrite.AdsMultiRequestItemReadWrite":
- var dt *AdsMultiRequestItemReadWrite
- if m.Child != nil {
- dt = m.Child.(*AdsMultiRequestItemReadWrite)
- }
- 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.ads.readwrite.AdsMultiRequestItemRead":
+ var dt *AdsMultiRequestItemRead
+ if m.Child != nil {
+ dt = m.Child.(*AdsMultiRequestItemRead)
+ }
+ 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.ads.readwrite.AdsMultiRequestItemWrite":
+ var dt *AdsMultiRequestItemWrite
+ if m.Child != nil {
+ dt = m.Child.(*AdsMultiRequestItemWrite)
+ }
+ 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.ads.readwrite.AdsMultiRequestItemReadWrite":
+ var dt *AdsMultiRequestItemReadWrite
+ if m.Child != nil {
+ dt = m.Child.(*AdsMultiRequestItemReadWrite)
+ }
+ if err := d.DecodeElement(&dt, &tok); err != nil {
+ return err
+ }
+ if m.Child == nil {
+ dt.Parent = m
+ m.Child = dt
+ }
+ }
+ }
+ }
+ }
}
func (m *AdsMultiRequestItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
- className := reflect.TypeOf(m.Child).String()
- className = "org.apache.plc4x.java.ads.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")
- }
- if err := marshaller.MarshalXML(e, start); err != nil {
- return err
- }
- 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.ads.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")
+ }
+ if err := marshaller.MarshalXML(e, start); err != nil {
+ return err
+ }
+ if err := e.EncodeToken(xml.EndElement{Name: start.Name}); err != nil {
+ return err
+ }
+ return nil
}
+
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AdsMultiRequestItemRead.go b/plc4go/internal/plc4go/ads/readwrite/model/AdsMultiRequestItemRead.go
index 50b7552..d1baab1 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AdsMultiRequestItemRead.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AdsMultiRequestItemRead.go
@@ -19,200 +19,202 @@
package model
import (
- "encoding/xml"
- "errors"
- "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
- "io"
+ "encoding/xml"
+ "errors"
+ "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+ "io"
)
// The data-structure of this message
type AdsMultiRequestItemRead struct {
- ItemIndexGroup uint32
- ItemIndexOffset uint32
- ItemReadLength uint32
- Parent *AdsMultiRequestItem
- IAdsMultiRequestItemRead
+ ItemIndexGroup uint32
+ ItemIndexOffset uint32
+ ItemReadLength uint32
+ Parent *AdsMultiRequestItem
+ IAdsMultiRequestItemRead
}
// The corresponding interface
type IAdsMultiRequestItemRead 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 *AdsMultiRequestItemRead) IndexGroup() uint32 {
- return 61568
+ return 61568L
}
+
func (m *AdsMultiRequestItemRead) InitializeParent(parent *AdsMultiRequestItem) {
}
func NewAdsMultiRequestItemRead(itemIndexGroup uint32, itemIndexOffset uint32, itemReadLength uint32) *AdsMultiRequestItem {
- child := &AdsMultiRequestItemRead{
- ItemIndexGroup: itemIndexGroup,
- ItemIndexOffset: itemIndexOffset,
- ItemReadLength: itemReadLength,
- Parent: NewAdsMultiRequestItem(),
- }
- child.Parent.Child = child
- return child.Parent
+ child := &AdsMultiRequestItemRead{
+ ItemIndexGroup: itemIndexGroup,
+ ItemIndexOffset: itemIndexOffset,
+ ItemReadLength: itemReadLength,
+ Parent: NewAdsMultiRequestItem(),
+ }
+ child.Parent.Child = child
+ return child.Parent
}
func CastAdsMultiRequestItemRead(structType interface{}) *AdsMultiRequestItemRead {
- castFunc := func(typ interface{}) *AdsMultiRequestItemRead {
- if casted, ok := typ.(AdsMultiRequestItemRead); ok {
- return &casted
- }
- if casted, ok := typ.(*AdsMultiRequestItemRead); ok {
- return casted
- }
- if casted, ok := typ.(AdsMultiRequestItem); ok {
- return CastAdsMultiRequestItemRead(casted.Child)
- }
- if casted, ok := typ.(*AdsMultiRequestItem); ok {
- return CastAdsMultiRequestItemRead(casted.Child)
- }
- return nil
- }
- return castFunc(structType)
+ castFunc := func(typ interface{}) *AdsMultiRequestItemRead {
+ if casted, ok := typ.(AdsMultiRequestItemRead); ok {
+ return &casted
+ }
+ if casted, ok := typ.(*AdsMultiRequestItemRead); ok {
+ return casted
+ }
+ if casted, ok := typ.(AdsMultiRequestItem); ok {
+ return CastAdsMultiRequestItemRead(casted.Child)
+ }
+ if casted, ok := typ.(*AdsMultiRequestItem); ok {
+ return CastAdsMultiRequestItemRead(casted.Child)
+ }
+ return nil
+ }
+ return castFunc(structType)
}
func (m *AdsMultiRequestItemRead) GetTypeName() string {
- return "AdsMultiRequestItemRead"
+ return "AdsMultiRequestItemRead"
}
func (m *AdsMultiRequestItemRead) LengthInBits() uint16 {
- lengthInBits := uint16(0)
+ lengthInBits := uint16(0)
- // Simple field (itemIndexGroup)
- lengthInBits += 32
+ // Simple field (itemIndexGroup)
+ lengthInBits += 32
- // Simple field (itemIndexOffset)
- lengthInBits += 32
+ // Simple field (itemIndexOffset)
+ lengthInBits += 32
- // Simple field (itemReadLength)
- lengthInBits += 32
+ // Simple field (itemReadLength)
+ lengthInBits += 32
- return lengthInBits
+ return lengthInBits
}
func (m *AdsMultiRequestItemRead) LengthInBytes() uint16 {
- return m.LengthInBits() / 8
+ return m.LengthInBits() / 8
}
func AdsMultiRequestItemReadParse(io *utils.ReadBuffer) (*AdsMultiRequestItem, error) {
- // Simple Field (itemIndexGroup)
- itemIndexGroup, _itemIndexGroupErr := io.ReadUint32(32)
- if _itemIndexGroupErr != nil {
- return nil, errors.New("Error parsing 'itemIndexGroup' field " + _itemIndexGroupErr.Error())
- }
-
- // Simple Field (itemIndexOffset)
- itemIndexOffset, _itemIndexOffsetErr := io.ReadUint32(32)
- if _itemIndexOffsetErr != nil {
- return nil, errors.New("Error parsing 'itemIndexOffset' field " + _itemIndexOffsetErr.Error())
- }
-
- // Simple Field (itemReadLength)
- itemReadLength, _itemReadLengthErr := io.ReadUint32(32)
- if _itemReadLengthErr != nil {
- return nil, errors.New("Error parsing 'itemReadLength' field " + _itemReadLengthErr.Error())
- }
-
- // Create a partially initialized instance
- _child := &AdsMultiRequestItemRead{
- ItemIndexGroup: itemIndexGroup,
- ItemIndexOffset: itemIndexOffset,
- ItemReadLength: itemReadLength,
- Parent: &AdsMultiRequestItem{},
- }
- _child.Parent.Child = _child
- return _child.Parent, nil
+ // Simple Field (itemIndexGroup)
+ itemIndexGroup, _itemIndexGroupErr := io.ReadUint32(32)
+ if _itemIndexGroupErr != nil {
+ return nil, errors.New("Error parsing 'itemIndexGroup' field " + _itemIndexGroupErr.Error())
+ }
+
+ // Simple Field (itemIndexOffset)
+ itemIndexOffset, _itemIndexOffsetErr := io.ReadUint32(32)
+ if _itemIndexOffsetErr != nil {
+ return nil, errors.New("Error parsing 'itemIndexOffset' field " + _itemIndexOffsetErr.Error())
+ }
+
+ // Simple Field (itemReadLength)
+ itemReadLength, _itemReadLengthErr := io.ReadUint32(32)
+ if _itemReadLengthErr != nil {
+ return nil, errors.New("Error parsing 'itemReadLength' field " + _itemReadLengthErr.Error())
+ }
+
+ // Create a partially initialized instance
+ _child := &AdsMultiRequestItemRead{
+ ItemIndexGroup: itemIndexGroup,
+ ItemIndexOffset: itemIndexOffset,
+ ItemReadLength: itemReadLength,
+ Parent: &AdsMultiRequestItem{},
+ }
+ _child.Parent.Child = _child
+ return _child.Parent, nil
}
func (m *AdsMultiRequestItemRead) Serialize(io utils.WriteBuffer) error {
- ser := func() error {
-
- // Simple Field (itemIndexGroup)
- itemIndexGroup := uint32(m.ItemIndexGroup)
- _itemIndexGroupErr := io.WriteUint32(32, (itemIndexGroup))
- if _itemIndexGroupErr != nil {
- return errors.New("Error serializing 'itemIndexGroup' field " + _itemIndexGroupErr.Error())
- }
-
- // Simple Field (itemIndexOffset)
- itemIndexOffset := uint32(m.ItemIndexOffset)
- _itemIndexOffsetErr := io.WriteUint32(32, (itemIndexOffset))
- if _itemIndexOffsetErr != nil {
- return errors.New("Error serializing 'itemIndexOffset' field " + _itemIndexOffsetErr.Error())
- }
-
- // Simple Field (itemReadLength)
- itemReadLength := uint32(m.ItemReadLength)
- _itemReadLengthErr := io.WriteUint32(32, (itemReadLength))
- if _itemReadLengthErr != nil {
- return errors.New("Error serializing 'itemReadLength' field " + _itemReadLengthErr.Error())
- }
-
- return nil
- }
- return m.Parent.SerializeParent(io, m, ser)
+ ser := func() error {
+
+ // Simple Field (itemIndexGroup)
+ itemIndexGroup := uint32(m.ItemIndexGroup)
+ _itemIndexGroupErr := io.WriteUint32(32, (itemIndexGroup))
+ if _itemIndexGroupErr != nil {
+ return errors.New("Error serializing 'itemIndexGroup' field " + _itemIndexGroupErr.Error())
+ }
+
+ // Simple Field (itemIndexOffset)
+ itemIndexOffset := uint32(m.ItemIndexOffset)
+ _itemIndexOffsetErr := io.WriteUint32(32, (itemIndexOffset))
+ if _itemIndexOffsetErr != nil {
+ return errors.New("Error serializing 'itemIndexOffset' field " + _itemIndexOffsetErr.Error())
+ }
+
+ // Simple Field (itemReadLength)
+ itemReadLength := uint32(m.ItemReadLength)
+ _itemReadLengthErr := io.WriteUint32(32, (itemReadLength))
+ if _itemReadLengthErr != nil {
+ return errors.New("Error serializing 'itemReadLength' field " + _itemReadLengthErr.Error())
+ }
+
+ return nil
+ }
+ return m.Parent.SerializeParent(io, m, ser)
}
func (m *AdsMultiRequestItemRead) 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 {
- case "itemIndexGroup":
- var data uint32
- if err := d.DecodeElement(&data, &tok); err != nil {
- return err
- }
- m.ItemIndexGroup = data
- case "itemIndexOffset":
- var data uint32
- if err := d.DecodeElement(&data, &tok); err != nil {
- return err
- }
- m.ItemIndexOffset = data
- case "itemReadLength":
- var data uint32
- if err := d.DecodeElement(&data, &tok); err != nil {
- return err
- }
- m.ItemReadLength = data
- }
- }
- 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 "itemIndexGroup":
+ var data uint32
+ if err := d.DecodeElement(&data, &tok); err != nil {
+ return err
+ }
+ m.ItemIndexGroup = data
+ case "itemIndexOffset":
+ var data uint32
+ if err := d.DecodeElement(&data, &tok); err != nil {
+ return err
+ }
+ m.ItemIndexOffset = data
+ case "itemReadLength":
+ var data uint32
+ if err := d.DecodeElement(&data, &tok); err != nil {
+ return err
+ }
+ m.ItemReadLength = data
+ }
+ }
+ token, err = d.Token()
+ if err != nil {
+ if err == io.EOF {
+ return nil
+ }
+ return err
+ }
+ }
}
func (m *AdsMultiRequestItemRead) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
- if err := e.EncodeElement(m.ItemIndexGroup, xml.StartElement{Name: xml.Name{Local: "itemIndexGroup"}}); err != nil {
- return err
- }
- if err := e.EncodeElement(m.ItemIndexOffset, xml.StartElement{Name: xml.Name{Local: "itemIndexOffset"}}); err != nil {
- return err
- }
- if err := e.EncodeElement(m.ItemReadLength, xml.StartElement{Name: xml.Name{Local: "itemReadLength"}}); err != nil {
- return err
- }
- return nil
+ if err := e.EncodeElement(m.ItemIndexGroup, xml.StartElement{Name: xml.Name{Local: "itemIndexGroup"}}); err != nil {
+ return err
+ }
+ if err := e.EncodeElement(m.ItemIndexOffset, xml.StartElement{Name: xml.Name{Local: "itemIndexOffset"}}); err != nil {
+ return err
+ }
+ if err := e.EncodeElement(m.ItemReadLength, xml.StartElement{Name: xml.Name{Local: "itemReadLength"}}); err != nil {
+ return err
+ }
+ return nil
}
+
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AdsMultiRequestItemReadWrite.go b/plc4go/internal/plc4go/ads/readwrite/model/AdsMultiRequestItemReadWrite.go
index 99595b6..749d34e 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AdsMultiRequestItemReadWrite.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AdsMultiRequestItemReadWrite.go
@@ -19,228 +19,230 @@
package model
import (
- "encoding/xml"
- "errors"
- "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
- "io"
+ "encoding/xml"
+ "errors"
+ "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+ "io"
)
// The data-structure of this message
type AdsMultiRequestItemReadWrite struct {
- ItemIndexGroup uint32
- ItemIndexOffset uint32
- ItemReadLength uint32
- ItemWriteLength uint32
- Parent *AdsMultiRequestItem
- IAdsMultiRequestItemReadWrite
+ ItemIndexGroup uint32
+ ItemIndexOffset uint32
+ ItemReadLength uint32
+ ItemWriteLength uint32
+ Parent *AdsMultiRequestItem
+ IAdsMultiRequestItemReadWrite
}
// The corresponding interface
type IAdsMultiRequestItemReadWrite 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 *AdsMultiRequestItemReadWrite) IndexGroup() uint32 {
- return 61570
+ return 61570L
}
+
func (m *AdsMultiRequestItemReadWrite) InitializeParent(parent *AdsMultiRequestItem) {
}
func NewAdsMultiRequestItemReadWrite(itemIndexGroup uint32, itemIndexOffset uint32, itemReadLength uint32, itemWriteLength uint32) *AdsMultiRequestItem {
- child := &AdsMultiRequestItemReadWrite{
- ItemIndexGroup: itemIndexGroup,
- ItemIndexOffset: itemIndexOffset,
- ItemReadLength: itemReadLength,
- ItemWriteLength: itemWriteLength,
- Parent: NewAdsMultiRequestItem(),
- }
- child.Parent.Child = child
- return child.Parent
+ child := &AdsMultiRequestItemReadWrite{
+ ItemIndexGroup: itemIndexGroup,
+ ItemIndexOffset: itemIndexOffset,
+ ItemReadLength: itemReadLength,
+ ItemWriteLength: itemWriteLength,
+ Parent: NewAdsMultiRequestItem(),
+ }
+ child.Parent.Child = child
+ return child.Parent
}
func CastAdsMultiRequestItemReadWrite(structType interface{}) *AdsMultiRequestItemReadWrite {
- castFunc := func(typ interface{}) *AdsMultiRequestItemReadWrite {
- if casted, ok := typ.(AdsMultiRequestItemReadWrite); ok {
- return &casted
- }
- if casted, ok := typ.(*AdsMultiRequestItemReadWrite); ok {
- return casted
- }
- if casted, ok := typ.(AdsMultiRequestItem); ok {
- return CastAdsMultiRequestItemReadWrite(casted.Child)
- }
- if casted, ok := typ.(*AdsMultiRequestItem); ok {
- return CastAdsMultiRequestItemReadWrite(casted.Child)
- }
- return nil
- }
- return castFunc(structType)
+ castFunc := func(typ interface{}) *AdsMultiRequestItemReadWrite {
+ if casted, ok := typ.(AdsMultiRequestItemReadWrite); ok {
+ return &casted
+ }
+ if casted, ok := typ.(*AdsMultiRequestItemReadWrite); ok {
+ return casted
+ }
+ if casted, ok := typ.(AdsMultiRequestItem); ok {
+ return CastAdsMultiRequestItemReadWrite(casted.Child)
+ }
+ if casted, ok := typ.(*AdsMultiRequestItem); ok {
+ return CastAdsMultiRequestItemReadWrite(casted.Child)
+ }
+ return nil
+ }
+ return castFunc(structType)
}
func (m *AdsMultiRequestItemReadWrite) GetTypeName() string {
- return "AdsMultiRequestItemReadWrite"
+ return "AdsMultiRequestItemReadWrite"
}
func (m *AdsMultiRequestItemReadWrite) LengthInBits() uint16 {
- lengthInBits := uint16(0)
+ lengthInBits := uint16(0)
- // Simple field (itemIndexGroup)
- lengthInBits += 32
+ // Simple field (itemIndexGroup)
+ lengthInBits += 32
- // Simple field (itemIndexOffset)
- lengthInBits += 32
+ // Simple field (itemIndexOffset)
+ lengthInBits += 32
- // Simple field (itemReadLength)
- lengthInBits += 32
+ // Simple field (itemReadLength)
+ lengthInBits += 32
- // Simple field (itemWriteLength)
- lengthInBits += 32
+ // Simple field (itemWriteLength)
+ lengthInBits += 32
- return lengthInBits
+ return lengthInBits
}
func (m *AdsMultiRequestItemReadWrite) LengthInBytes() uint16 {
- return m.LengthInBits() / 8
+ return m.LengthInBits() / 8
}
func AdsMultiRequestItemReadWriteParse(io *utils.ReadBuffer) (*AdsMultiRequestItem, error) {
- // Simple Field (itemIndexGroup)
- itemIndexGroup, _itemIndexGroupErr := io.ReadUint32(32)
- if _itemIndexGroupErr != nil {
- return nil, errors.New("Error parsing 'itemIndexGroup' field " + _itemIndexGroupErr.Error())
- }
-
- // Simple Field (itemIndexOffset)
- itemIndexOffset, _itemIndexOffsetErr := io.ReadUint32(32)
- if _itemIndexOffsetErr != nil {
- return nil, errors.New("Error parsing 'itemIndexOffset' field " + _itemIndexOffsetErr.Error())
- }
-
- // Simple Field (itemReadLength)
- itemReadLength, _itemReadLengthErr := io.ReadUint32(32)
- if _itemReadLengthErr != nil {
- return nil, errors.New("Error parsing 'itemReadLength' field " + _itemReadLengthErr.Error())
- }
-
- // Simple Field (itemWriteLength)
- itemWriteLength, _itemWriteLengthErr := io.ReadUint32(32)
- if _itemWriteLengthErr != nil {
- return nil, errors.New("Error parsing 'itemWriteLength' field " + _itemWriteLengthErr.Error())
- }
-
- // Create a partially initialized instance
- _child := &AdsMultiRequestItemReadWrite{
- ItemIndexGroup: itemIndexGroup,
- ItemIndexOffset: itemIndexOffset,
- ItemReadLength: itemReadLength,
- ItemWriteLength: itemWriteLength,
- Parent: &AdsMultiRequestItem{},
- }
- _child.Parent.Child = _child
- return _child.Parent, nil
+ // Simple Field (itemIndexGroup)
+ itemIndexGroup, _itemIndexGroupErr := io.ReadUint32(32)
+ if _itemIndexGroupErr != nil {
+ return nil, errors.New("Error parsing 'itemIndexGroup' field " + _itemIndexGroupErr.Error())
+ }
+
+ // Simple Field (itemIndexOffset)
+ itemIndexOffset, _itemIndexOffsetErr := io.ReadUint32(32)
+ if _itemIndexOffsetErr != nil {
+ return nil, errors.New("Error parsing 'itemIndexOffset' field " + _itemIndexOffsetErr.Error())
+ }
+
+ // Simple Field (itemReadLength)
+ itemReadLength, _itemReadLengthErr := io.ReadUint32(32)
+ if _itemReadLengthErr != nil {
+ return nil, errors.New("Error parsing 'itemReadLength' field " + _itemReadLengthErr.Error())
+ }
+
+ // Simple Field (itemWriteLength)
+ itemWriteLength, _itemWriteLengthErr := io.ReadUint32(32)
+ if _itemWriteLengthErr != nil {
+ return nil, errors.New("Error parsing 'itemWriteLength' field " + _itemWriteLengthErr.Error())
+ }
+
+ // Create a partially initialized instance
+ _child := &AdsMultiRequestItemReadWrite{
+ ItemIndexGroup: itemIndexGroup,
+ ItemIndexOffset: itemIndexOffset,
+ ItemReadLength: itemReadLength,
+ ItemWriteLength: itemWriteLength,
+ Parent: &AdsMultiRequestItem{},
+ }
+ _child.Parent.Child = _child
+ return _child.Parent, nil
}
func (m *AdsMultiRequestItemReadWrite) Serialize(io utils.WriteBuffer) error {
- ser := func() error {
-
- // Simple Field (itemIndexGroup)
- itemIndexGroup := uint32(m.ItemIndexGroup)
- _itemIndexGroupErr := io.WriteUint32(32, (itemIndexGroup))
- if _itemIndexGroupErr != nil {
- return errors.New("Error serializing 'itemIndexGroup' field " + _itemIndexGroupErr.Error())
- }
-
- // Simple Field (itemIndexOffset)
- itemIndexOffset := uint32(m.ItemIndexOffset)
- _itemIndexOffsetErr := io.WriteUint32(32, (itemIndexOffset))
- if _itemIndexOffsetErr != nil {
- return errors.New("Error serializing 'itemIndexOffset' field " + _itemIndexOffsetErr.Error())
- }
-
- // Simple Field (itemReadLength)
- itemReadLength := uint32(m.ItemReadLength)
- _itemReadLengthErr := io.WriteUint32(32, (itemReadLength))
- if _itemReadLengthErr != nil {
- return errors.New("Error serializing 'itemReadLength' field " + _itemReadLengthErr.Error())
- }
-
- // Simple Field (itemWriteLength)
- itemWriteLength := uint32(m.ItemWriteLength)
- _itemWriteLengthErr := io.WriteUint32(32, (itemWriteLength))
- if _itemWriteLengthErr != nil {
- return errors.New("Error serializing 'itemWriteLength' field " + _itemWriteLengthErr.Error())
- }
-
- return nil
- }
- return m.Parent.SerializeParent(io, m, ser)
+ ser := func() error {
+
+ // Simple Field (itemIndexGroup)
+ itemIndexGroup := uint32(m.ItemIndexGroup)
+ _itemIndexGroupErr := io.WriteUint32(32, (itemIndexGroup))
+ if _itemIndexGroupErr != nil {
+ return errors.New("Error serializing 'itemIndexGroup' field " + _itemIndexGroupErr.Error())
+ }
+
+ // Simple Field (itemIndexOffset)
+ itemIndexOffset := uint32(m.ItemIndexOffset)
+ _itemIndexOffsetErr := io.WriteUint32(32, (itemIndexOffset))
+ if _itemIndexOffsetErr != nil {
+ return errors.New("Error serializing 'itemIndexOffset' field " + _itemIndexOffsetErr.Error())
+ }
+
+ // Simple Field (itemReadLength)
+ itemReadLength := uint32(m.ItemReadLength)
+ _itemReadLengthErr := io.WriteUint32(32, (itemReadLength))
+ if _itemReadLengthErr != nil {
+ return errors.New("Error serializing 'itemReadLength' field " + _itemReadLengthErr.Error())
+ }
+
+ // Simple Field (itemWriteLength)
+ itemWriteLength := uint32(m.ItemWriteLength)
+ _itemWriteLengthErr := io.WriteUint32(32, (itemWriteLength))
+ if _itemWriteLengthErr != nil {
+ return errors.New("Error serializing 'itemWriteLength' field " + _itemWriteLengthErr.Error())
+ }
+
+ return nil
+ }
+ return m.Parent.SerializeParent(io, m, ser)
}
func (m *AdsMultiRequestItemReadWrite) 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 {
- case "itemIndexGroup":
- var data uint32
- if err := d.DecodeElement(&data, &tok); err != nil {
- return err
- }
- m.ItemIndexGroup = data
- case "itemIndexOffset":
- var data uint32
- if err := d.DecodeElement(&data, &tok); err != nil {
- return err
- }
- m.ItemIndexOffset = data
- case "itemReadLength":
- var data uint32
- if err := d.DecodeElement(&data, &tok); err != nil {
- return err
- }
- m.ItemReadLength = data
- case "itemWriteLength":
- var data uint32
- if err := d.DecodeElement(&data, &tok); err != nil {
- return err
- }
- m.ItemWriteLength = data
- }
- }
- 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 "itemIndexGroup":
+ var data uint32
+ if err := d.DecodeElement(&data, &tok); err != nil {
+ return err
+ }
+ m.ItemIndexGroup = data
+ case "itemIndexOffset":
+ var data uint32
+ if err := d.DecodeElement(&data, &tok); err != nil {
+ return err
+ }
+ m.ItemIndexOffset = data
+ case "itemReadLength":
+ var data uint32
+ if err := d.DecodeElement(&data, &tok); err != nil {
+ return err
+ }
+ m.ItemReadLength = data
+ case "itemWriteLength":
+ var data uint32
+ if err := d.DecodeElement(&data, &tok); err != nil {
+ return err
+ }
+ m.ItemWriteLength = data
+ }
+ }
+ token, err = d.Token()
+ if err != nil {
+ if err == io.EOF {
+ return nil
+ }
+ return err
+ }
+ }
}
func (m *AdsMultiRequestItemReadWrite) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
- if err := e.EncodeElement(m.ItemIndexGroup, xml.StartElement{Name: xml.Name{Local: "itemIndexGroup"}}); err != nil {
- return err
- }
- if err := e.EncodeElement(m.ItemIndexOffset, xml.StartElement{Name: xml.Name{Local: "itemIndexOffset"}}); err != nil {
- return err
- }
- if err := e.EncodeElement(m.ItemReadLength, xml.StartElement{Name: xml.Name{Local: "itemReadLength"}}); err != nil {
- return err
- }
- if err := e.EncodeElement(m.ItemWriteLength, xml.StartElement{Name: xml.Name{Local: "itemWriteLength"}}); err != nil {
- return err
- }
- return nil
+ if err := e.EncodeElement(m.ItemIndexGroup, xml.StartElement{Name: xml.Name{Local: "itemIndexGroup"}}); err != nil {
+ return err
+ }
+ if err := e.EncodeElement(m.ItemIndexOffset, xml.StartElement{Name: xml.Name{Local: "itemIndexOffset"}}); err != nil {
+ return err
+ }
+ if err := e.EncodeElement(m.ItemReadLength, xml.StartElement{Name: xml.Name{Local: "itemReadLength"}}); err != nil {
+ return err
+ }
+ if err := e.EncodeElement(m.ItemWriteLength, xml.StartElement{Name: xml.Name{Local: "itemWriteLength"}}); err != nil {
+ return err
+ }
+ return nil
}
+
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AdsMultiRequestItemWrite.go b/plc4go/internal/plc4go/ads/readwrite/model/AdsMultiRequestItemWrite.go
index e99f4df..0f8db34 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AdsMultiRequestItemWrite.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AdsMultiRequestItemWrite.go
@@ -19,200 +19,202 @@
package model
import (
- "encoding/xml"
- "errors"
- "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
- "io"
+ "encoding/xml"
+ "errors"
+ "github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+ "io"
)
// The data-structure of this message
type AdsMultiRequestItemWrite struct {
- ItemIndexGroup uint32
- ItemIndexOffset uint32
- ItemWriteLength uint32
- Parent *AdsMultiRequestItem
- IAdsMultiRequestItemWrite
+ ItemIndexGroup uint32
+ ItemIndexOffset uint32
+ ItemWriteLength uint32
+ Parent *AdsMultiRequestItem
+ IAdsMultiRequestItemWrite
}
// The corresponding interface
type IAdsMultiRequestItemWrite 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 *AdsMultiRequestItemWrite) IndexGroup() uint32 {
- return 61569
+ return 61569L
}
+
func (m *AdsMultiRequestItemWrite) InitializeParent(parent *AdsMultiRequestItem) {
}
func NewAdsMultiRequestItemWrite(itemIndexGroup uint32, itemIndexOffset uint32, itemWriteLength uint32) *AdsMultiRequestItem {
- child := &AdsMultiRequestItemWrite{
- ItemIndexGroup: itemIndexGroup,
- ItemIndexOffset: itemIndexOffset,
- ItemWriteLength: itemWriteLength,
- Parent: NewAdsMultiRequestItem(),
- }
- child.Parent.Child = child
- return child.Parent
+ child := &AdsMultiRequestItemWrite{
+ ItemIndexGroup: itemIndexGroup,
+ ItemIndexOffset: itemIndexOffset,
+ ItemWriteLength: itemWriteLength,
+ Parent: NewAdsMultiRequestItem(),
+ }
+ child.Parent.Child = child
+ return child.Parent
}
func CastAdsMultiRequestItemWrite(structType interface{}) *AdsMultiRequestItemWrite {
- castFunc := func(typ interface{}) *AdsMultiRequestItemWrite {
- if casted, ok := typ.(AdsMultiRequestItemWrite); ok {
- return &casted
- }
- if casted, ok := typ.(*AdsMultiRequestItemWrite); ok {
- return casted
- }
- if casted, ok := typ.(AdsMultiRequestItem); ok {
- return CastAdsMultiRequestItemWrite(casted.Child)
- }
- if casted, ok := typ.(*AdsMultiRequestItem); ok {
- return CastAdsMultiRequestItemWrite(casted.Child)
- }
- return nil
- }
- return castFunc(structType)
+ castFunc := func(typ interface{}) *AdsMultiRequestItemWrite {
+ if casted, ok := typ.(AdsMultiRequestItemWrite); ok {
+ return &casted
+ }
+ if casted, ok := typ.(*AdsMultiRequestItemWrite); ok {
+ return casted
+ }
+ if casted, ok := typ.(AdsMultiRequestItem); ok {
+ return CastAdsMultiRequestItemWrite(casted.Child)
+ }
+ if casted, ok := typ.(*AdsMultiRequestItem); ok {
+ return CastAdsMultiRequestItemWrite(casted.Child)
+ }
+ return nil
+ }
+ return castFunc(structType)
}
func (m *AdsMultiRequestItemWrite) GetTypeName() string {
- return "AdsMultiRequestItemWrite"
+ return "AdsMultiRequestItemWrite"
}
func (m *AdsMultiRequestItemWrite) LengthInBits() uint16 {
- lengthInBits := uint16(0)
+ lengthInBits := uint16(0)
- // Simple field (itemIndexGroup)
- lengthInBits += 32
+ // Simple field (itemIndexGroup)
+ lengthInBits += 32
- // Simple field (itemIndexOffset)
- lengthInBits += 32
+ // Simple field (itemIndexOffset)
+ lengthInBits += 32
- // Simple field (itemWriteLength)
- lengthInBits += 32
+ // Simple field (itemWriteLength)
+ lengthInBits += 32
- return lengthInBits
+ return lengthInBits
}
func (m *AdsMultiRequestItemWrite) LengthInBytes() uint16 {
- return m.LengthInBits() / 8
+ return m.LengthInBits() / 8
}
func AdsMultiRequestItemWriteParse(io *utils.ReadBuffer) (*AdsMultiRequestItem, error) {
- // Simple Field (itemIndexGroup)
- itemIndexGroup, _itemIndexGroupErr := io.ReadUint32(32)
- if _itemIndexGroupErr != nil {
- return nil, errors.New("Error parsing 'itemIndexGroup' field " + _itemIndexGroupErr.Error())
- }
-
- // Simple Field (itemIndexOffset)
- itemIndexOffset, _itemIndexOffsetErr := io.ReadUint32(32)
- if _itemIndexOffsetErr != nil {
- return nil, errors.New("Error parsing 'itemIndexOffset' field " + _itemIndexOffsetErr.Error())
- }
-
- // Simple Field (itemWriteLength)
- itemWriteLength, _itemWriteLengthErr := io.ReadUint32(32)
- if _itemWriteLengthErr != nil {
- return nil, errors.New("Error parsing 'itemWriteLength' field " + _itemWriteLengthErr.Error())
- }
-
- // Create a partially initialized instance
- _child := &AdsMultiRequestItemWrite{
- ItemIndexGroup: itemIndexGroup,
- ItemIndexOffset: itemIndexOffset,
- ItemWriteLength: itemWriteLength,
- Parent: &AdsMultiRequestItem{},
- }
- _child.Parent.Child = _child
- return _child.Parent, nil
+ // Simple Field (itemIndexGroup)
+ itemIndexGroup, _itemIndexGroupErr := io.ReadUint32(32)
+ if _itemIndexGroupErr != nil {
+ return nil, errors.New("Error parsing 'itemIndexGroup' field " + _itemIndexGroupErr.Error())
+ }
+
+ // Simple Field (itemIndexOffset)
+ itemIndexOffset, _itemIndexOffsetErr := io.ReadUint32(32)
+ if _itemIndexOffsetErr != nil {
+ return nil, errors.New("Error parsing 'itemIndexOffset' field " + _itemIndexOffsetErr.Error())
+ }
+
+ // Simple Field (itemWriteLength)
+ itemWriteLength, _itemWriteLengthErr := io.ReadUint32(32)
+ if _itemWriteLengthErr != nil {
+ return nil, errors.New("Error parsing 'itemWriteLength' field " + _itemWriteLengthErr.Error())
+ }
+
+ // Create a partially initialized instance
+ _child := &AdsMultiRequestItemWrite{
+ ItemIndexGroup: itemIndexGroup,
+ ItemIndexOffset: itemIndexOffset,
+ ItemWriteLength: itemWriteLength,
+ Parent: &AdsMultiRequestItem{},
+ }
+ _child.Parent.Child = _child
+ return _child.Parent, nil
}
func (m *AdsMultiRequestItemWrite) Serialize(io utils.WriteBuffer) error {
- ser := func() error {
-
- // Simple Field (itemIndexGroup)
- itemIndexGroup := uint32(m.ItemIndexGroup)
- _itemIndexGroupErr := io.WriteUint32(32, (itemIndexGroup))
- if _itemIndexGroupErr != nil {
- return errors.New("Error serializing 'itemIndexGroup' field " + _itemIndexGroupErr.Error())
- }
-
- // Simple Field (itemIndexOffset)
- itemIndexOffset := uint32(m.ItemIndexOffset)
- _itemIndexOffsetErr := io.WriteUint32(32, (itemIndexOffset))
- if _itemIndexOffsetErr != nil {
- return errors.New("Error serializing 'itemIndexOffset' field " + _itemIndexOffsetErr.Error())
- }
-
- // Simple Field (itemWriteLength)
- itemWriteLength := uint32(m.ItemWriteLength)
- _itemWriteLengthErr := io.WriteUint32(32, (itemWriteLength))
- if _itemWriteLengthErr != nil {
- return errors.New("Error serializing 'itemWriteLength' field " + _itemWriteLengthErr.Error())
- }
-
- return nil
- }
- return m.Parent.SerializeParent(io, m, ser)
+ ser := func() error {
+
+ // Simple Field (itemIndexGroup)
+ itemIndexGroup := uint32(m.ItemIndexGroup)
+ _itemIndexGroupErr := io.WriteUint32(32, (itemIndexGroup))
+ if _itemIndexGroupErr != nil {
+ return errors.New("Error serializing 'itemIndexGroup' field " + _itemIndexGroupErr.Error())
+ }
+
+ // Simple Field (itemIndexOffset)
+ itemIndexOffset := uint32(m.ItemIndexOffset)
+ _itemIndexOffsetErr := io.WriteUint32(32, (itemIndexOffset))
+ if _itemIndexOffsetErr != nil {
+ return errors.New("Error serializing 'itemIndexOffset' field " + _itemIndexOffsetErr.Error())
+ }
+
+ // Simple Field (itemWriteLength)
+ itemWriteLength := uint32(m.ItemWriteLength)
+ _itemWriteLengthErr := io.WriteUint32(32, (itemWriteLength))
+ if _itemWriteLengthErr != nil {
+ return errors.New("Error serializing 'itemWriteLength' field " + _itemWriteLengthErr.Error())
+ }
+
+ return nil
+ }
+ return m.Parent.SerializeParent(io, m, ser)
}
func (m *AdsMultiRequestItemWrite) 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 {
- case "itemIndexGroup":
- var data uint32
- if err := d.DecodeElement(&data, &tok); err != nil {
- return err
- }
- m.ItemIndexGroup = data
- case "itemIndexOffset":
- var data uint32
- if err := d.DecodeElement(&data, &tok); err != nil {
- return err
- }
- m.ItemIndexOffset = data
- case "itemWriteLength":
- var data uint32
- if err := d.DecodeElement(&data, &tok); err != nil {
- return err
- }
- m.ItemWriteLength = data
- }
- }
- 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 "itemIndexGroup":
+ var data uint32
+ if err := d.DecodeElement(&data, &tok); err != nil {
+ return err
+ }
+ m.ItemIndexGroup = data
+ case "itemIndexOffset":
+ var data uint32
+ if err := d.DecodeElement(&data, &tok); err != nil {
+ return err
+ }
+ m.ItemIndexOffset = data
+ case "itemWriteLength":
+ var data uint32
+ if err := d.DecodeElement(&data, &tok); err != nil {
+ return err
+ }
+ m.ItemWriteLength = data
+ }
+ }
+ token, err = d.Token()
+ if err != nil {
+ if err == io.EOF {
+ return nil
+ }
+ return err
+ }
+ }
}
func (m *AdsMultiRequestItemWrite) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
- if err := e.EncodeElement(m.ItemIndexGroup, xml.StartElement{Name: xml.Name{Local: "itemIndexGroup"}}); err != nil {
- return err
- }
- if err := e.EncodeElement(m.ItemIndexOffset, xml.StartElement{Name: xml.Name{Local: "itemIndexOffset"}}); err != nil {
- return err
- }
- if err := e.EncodeElement(m.ItemWriteLength, xml.StartElement{Name: xml.Name{Local: "itemWriteLength"}}); err != nil {
- return err
- }
- return nil
+ if err := e.EncodeElement(m.ItemIndexGroup, xml.StartElement{Name: xml.Name{Local: "itemIndexGroup"}}); err != nil {
+ return err
+ }
+ if err := e.EncodeElement(m.ItemIndexOffset, xml.StartElement{Name: xml.Name{Local: "itemIndexOffset"}}); err != nil {
+ return err
+ }
+ if err := e.EncodeElement(m.ItemWriteLength, xml.StartElement{Name: xml.Name{Local: "itemWriteLength"}}); err != nil {
+ return err
+ }
+ return nil
}
+
diff --git a/plc4go/internal/plc4go/knxnetip/readwrite/model/KnxDatapointType.go b/plc4go/internal/plc4go/knxnetip/readwrite/model/KnxDatapointType.go
index 3ab7745..efed0cf 100644
--- a/plc4go/internal/plc4go/knxnetip/readwrite/model/KnxDatapointType.go
+++ b/plc4go/internal/plc4go/knxnetip/readwrite/model/KnxDatapointType.go
@@ -1851,7 +1851,7 @@ func (e KnxDatapointType) Name() string {
}
case 112:
{ /* '112' */
- return "power density (W/m²)"
+ return "power denisity (W/m²)"
}
case 113:
{ /* '113' */
diff --git a/plc4go/internal/plc4go/knxnetip/readwrite/model/KnxManufacturer.go b/plc4go/internal/plc4go/knxnetip/readwrite/model/KnxManufacturer.go
index 9a6308c..38b3389 100644
--- a/plc4go/internal/plc4go/knxnetip/readwrite/model/KnxManufacturer.go
+++ b/plc4go/internal/plc4go/knxnetip/readwrite/model/KnxManufacturer.go
@@ -567,14 +567,8 @@ const (
KnxManufacturer_M_NIETIAN KnxManufacturer = 533
KnxManufacturer_M_SUMSIR KnxManufacturer = 534
KnxManufacturer_M_ORBIS_TECNOLOGIA_ELECTRICA_SA KnxManufacturer = 535
- KnxManufacturer_M_NANJING_ZHONGYI_IOT_TECHNOLOGY_CO___LTD_ KnxManufacturer = 536
- KnxManufacturer_M_ANLIPS KnxManufacturer = 537
- KnxManufacturer_M_GUANGDONG_PAK_CORPORATION_CO___LTD KnxManufacturer = 538
- KnxManufacturer_M_BVK_TECHNOLOGY KnxManufacturer = 539
- KnxManufacturer_M_SOLOMIO_SRL KnxManufacturer = 540
- KnxManufacturer_M_DOMOTICA_LABS KnxManufacturer = 541
- KnxManufacturer_M_ABB___RESERVED KnxManufacturer = 542
- KnxManufacturer_M_BUSCH_JAEGER_ELEKTRO___RESERVED KnxManufacturer = 543
+ KnxManufacturer_M_ABB___RESERVED KnxManufacturer = 536
+ KnxManufacturer_M_BUSCH_JAEGER_ELEKTRO___RESERVED KnxManufacturer = 537
)
func (e KnxManufacturer) Number() uint16 {
@@ -2525,40 +2519,16 @@ func (e KnxManufacturer) Number() uint16 {
}
case 536:
{ /* '536' */
- return 593
+ return 43954
}
case 537:
{ /* '537' */
- return 594
- }
- case 538:
- { /* '538' */
- return 595
- }
- case 539:
- { /* '539' */
- return 596
+ return 43959
}
case 54:
{ /* '54' */
return 92
}
- case 540:
- { /* '540' */
- return 597
- }
- case 541:
- { /* '541' */
- return 598
- }
- case 542:
- { /* '542' */
- return 43954
- }
- case 543:
- { /* '543' */
- return 43959
- }
case 55:
{ /* '55' */
return 93
@@ -4710,40 +4680,16 @@ func (e KnxManufacturer) Name() string {
}
case 536:
{ /* '536' */
- return "Nanjing Zhongyi IoT Technology Co., Ltd."
+ return "ABB - reserved"
}
case 537:
{ /* '537' */
- return "Anlips"
- }
- case 538:
- { /* '538' */
- return "GUANGDONG PAK CORPORATION CO., LTD"
- }
- case 539:
- { /* '539' */
- return "BVK Technology"
+ return "Busch-Jaeger Elektro - reserved"
}
case 54:
{ /* '54' */
return "DORMA GmbH + Co. KG"
}
- case 540:
- { /* '540' */
- return "Solomio srl"
- }
- case 541:
- { /* '541' */
- return "Domotica Labs"
- }
- case 542:
- { /* '542' */
- return "ABB - reserved"
- }
- case 543:
- { /* '543' */
- return "Busch-Jaeger Elektro - reserved"
- }
case 55:
{ /* '55' */
return "WindowMaster A/S"
@@ -5921,23 +5867,11 @@ func KnxManufacturerByValue(value uint16) KnxManufacturer {
case 535:
return KnxManufacturer_M_ORBIS_TECNOLOGIA_ELECTRICA_SA
case 536:
- return KnxManufacturer_M_NANJING_ZHONGYI_IOT_TECHNOLOGY_CO___LTD_
+ return KnxManufacturer_M_ABB___RESERVED
case 537:
- return KnxManufacturer_M_ANLIPS
- case 538:
- return KnxManufacturer_M_GUANGDONG_PAK_CORPORATION_CO___LTD
- case 539:
- return KnxManufacturer_M_BVK_TECHNOLOGY
+ return KnxManufacturer_M_BUSCH_JAEGER_ELEKTRO___RESERVED
case 54:
return KnxManufacturer_M_DORMA_GMBH_Plus_CO__KG
- case 540:
- return KnxManufacturer_M_SOLOMIO_SRL
- case 541:
- return KnxManufacturer_M_DOMOTICA_LABS
- case 542:
- return KnxManufacturer_M_ABB___RESERVED
- case 543:
- return KnxManufacturer_M_BUSCH_JAEGER_ELEKTRO___RESERVED
case 55:
return KnxManufacturer_M_WINDOWMASTER_AS
case 56:
@@ -7014,24 +6948,12 @@ func KnxManufacturerByName(value string) KnxManufacturer {
return KnxManufacturer_M_SUMSIR
case "M_ORBIS_TECNOLOGIA_ELECTRICA_SA":
return KnxManufacturer_M_ORBIS_TECNOLOGIA_ELECTRICA_SA
- case "M_NANJING_ZHONGYI_IOT_TECHNOLOGY_CO___LTD_":
- return KnxManufacturer_M_NANJING_ZHONGYI_IOT_TECHNOLOGY_CO___LTD_
- case "M_ANLIPS":
- return KnxManufacturer_M_ANLIPS
- case "M_GUANGDONG_PAK_CORPORATION_CO___LTD":
- return KnxManufacturer_M_GUANGDONG_PAK_CORPORATION_CO___LTD
- case "M_BVK_TECHNOLOGY":
- return KnxManufacturer_M_BVK_TECHNOLOGY
- case "M_DORMA_GMBH_Plus_CO__KG":
- return KnxManufacturer_M_DORMA_GMBH_Plus_CO__KG
- case "M_SOLOMIO_SRL":
- return KnxManufacturer_M_SOLOMIO_SRL
- case "M_DOMOTICA_LABS":
- return KnxManufacturer_M_DOMOTICA_LABS
case "M_ABB___RESERVED":
return KnxManufacturer_M_ABB___RESERVED
case "M_BUSCH_JAEGER_ELEKTRO___RESERVED":
return KnxManufacturer_M_BUSCH_JAEGER_ELEKTRO___RESERVED
+ case "M_DORMA_GMBH_Plus_CO__KG":
+ return KnxManufacturer_M_DORMA_GMBH_Plus_CO__KG
case "M_WINDOWMASTER_AS":
return KnxManufacturer_M_WINDOWMASTER_AS
case "M_WALTHER_WERKE":
@@ -8139,24 +8061,12 @@ func (e KnxManufacturer) String() string {
return "M_SUMSIR"
case KnxManufacturer_M_ORBIS_TECNOLOGIA_ELECTRICA_SA:
return "M_ORBIS_TECNOLOGIA_ELECTRICA_SA"
- case KnxManufacturer_M_NANJING_ZHONGYI_IOT_TECHNOLOGY_CO___LTD_:
- return "M_NANJING_ZHONGYI_IOT_TECHNOLOGY_CO___LTD_"
- case KnxManufacturer_M_ANLIPS:
- return "M_ANLIPS"
- case KnxManufacturer_M_GUANGDONG_PAK_CORPORATION_CO___LTD:
- return "M_GUANGDONG_PAK_CORPORATION_CO___LTD"
- case KnxManufacturer_M_BVK_TECHNOLOGY:
- return "M_BVK_TECHNOLOGY"
- case KnxManufacturer_M_DORMA_GMBH_Plus_CO__KG:
- return "M_DORMA_GMBH_Plus_CO__KG"
- case KnxManufacturer_M_SOLOMIO_SRL:
- return "M_SOLOMIO_SRL"
- case KnxManufacturer_M_DOMOTICA_LABS:
- return "M_DOMOTICA_LABS"
case KnxManufacturer_M_ABB___RESERVED:
return "M_ABB___RESERVED"
case KnxManufacturer_M_BUSCH_JAEGER_ELEKTRO___RESERVED:
return "M_BUSCH_JAEGER_ELEKTRO___RESERVED"
+ case KnxManufacturer_M_DORMA_GMBH_Plus_CO__KG:
+ return "M_DORMA_GMBH_Plus_CO__KG"
case KnxManufacturer_M_WINDOWMASTER_AS:
return "M_WINDOWMASTER_AS"
case KnxManufacturer_M_WALTHER_WERKE:
diff --git a/plc4go/pom.xml b/plc4go/pom.xml
index 13bfaba..22d07f5 100644
--- a/plc4go/pom.xml
+++ b/plc4go/pom.xml
@@ -203,16 +203,11 @@
<goal>fmt</goal>
</goals>
</execution>
- <execution>
- <id>run-go-vet</id>
- <phase>verify</phase>
- <goals>
- <goal>vet</goal>
- </goals>
- </execution>
+
<!-- Get all dependencies for test cases -->
<execution>
<id>getTestDependencies</id>
+ <phase>process-test-sources</phase>
<goals>
<goal>get</goal>
</goals>
@@ -229,6 +224,7 @@
<!-- Get xunit generator -->
<execution>
<id>test-get</id>
+ <phase>process-test-resources</phase>
<configuration>
<packages>
<package>github.com/tebeka/go2xunit</package>
@@ -239,6 +235,7 @@
<!-- Check all tests with producing report file in Golang format -->
<execution>
<id>default-test</id>
+ <phase>test</phase>
<configuration>
<buildFlags>
<flag>-v</flag>
@@ -269,6 +266,14 @@
</echo>
</configuration>
</execution>
+
+ <execution>
+ <id>run-go-vet</id>
+ <phase>verify</phase>
+ <goals>
+ <goal>vet</goal>
+ </goals>
+ </execution>
</executions>
<configuration>
<packages>