diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 7cb6e43..25228c6 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -16,17 +16,17 @@ jobs: uses: actions/checkout@v3 with: fetch-depth: 0 - + - name: Run check run: | uname -a ls -lah sudo apt-get update sudo apt-get install -y libsystemd-dev libzmq3-dev - sudo apt install pkg-config - wget https://github.com/boschrexroth/ctrlx-automation-sdk/releases/download/2.4.0/ctrlx-datalayer-2.4.5.deb - sudo apt-get install -y -f ./ctrlx-datalayer-2.4.5.deb - + sudo apt install pkg-config + wget https://github.com/boschrexroth/ctrlx-automation-sdk/releases/download/2.6.0/ctrlx-datalayer-2.6.1.deb + sudo apt-get install -y -f ./ctrlx-datalayer-2.6.1.deb + - name: Go uses: actions/setup-go@v3 with: @@ -38,7 +38,7 @@ jobs: go mod vendor go mod tidy go test -race -short -count=1 -mod=vendor ./test/datalayer ./test/sseclient ./test/token - + - name: Set up Go uses: actions/setup-go@v3 with: @@ -49,4 +49,4 @@ jobs: go mod download go mod vendor go test -race -short -count=1 -mod=vendor ./test/datalayer ./test/sseclient ./test/token - + diff --git a/Makefile b/Makefile index 4955f38..13aef57 100644 --- a/Makefile +++ b/Makefile @@ -8,16 +8,18 @@ GOOS := $(shell go env GOOS) GOARCH := $(shell go env GOARCH) BUILD := build/public/$(GOOS)_$(GOARCH) -DATALAYER_DEB_VERSION := 2.4.0 -DATALAYER_DEB_FILE_VERSION := 2.4.5 +DATALAYER_DEB_VERSION := 2.6.0 +DATALAYER_DEB_FILE_VERSION := 2.6.1 .PHONY: all go-dep apt-dep lint vet test test-coverage build clean all: build go-dep: ## Get go dependencies + @go get -u ./... @go mod download @go mod vendor + @go mod tidy apt-dep: ## Get native dependencies @sudo apt-get update diff --git a/README.md b/README.md index eb3bd5e..d66d1b0 100644 --- a/README.md +++ b/README.md @@ -6,7 +6,7 @@ This project provides: It wraps the original ctrlX Data Layer written in C++. - You can find documentation and examples here [ctrlX Software Development Kit](https://boschrexroth.github.io/ctrlx-automation-sdk/) and [GoDoc](https://pkg.go.dev/github.com/boschrexroth/ctrlx-datalayer-golang/pkg/datalayer). + You can find documentation and examples here [ctrlX Software Development Kit](https://boschrexroth.github.io/ctrlx-automation-sdk/) and [GoDoc](https://pkg.go.dev/github.com/boschrexroth/ctrlx-datalayer-golang/v2/pkg/datalayer). 2. Server-Sent Events(SSE) Client @@ -16,7 +16,7 @@ This project provides: The SSE client library can be used to connect to the SSE Server of the ctrlX Data Layer running on the ctrlX Device. It is possible to subscribe to nodes on the server and the server will automatically send new updates on value changes. - You can find documentation here [GoDoc](https://pkg.go.dev/github.com/boschrexroth/ctrlx-datalayer-golang/pkg/sseclient) + You can find documentation here [GoDoc](https://pkg.go.dev/github.com/boschrexroth/ctrlx-datalayer-golang/v2/pkg/sseclient) 3. Token handling @@ -24,7 +24,7 @@ This project provides: The token library can be used to get token from ctrlX Core and later on check if the token is still valid. - You can find documentation here [GoDoc](https://pkg.go.dev/github.com/boschrexroth/ctrlx-datalayer-golang/pkg/token) + You can find documentation here [GoDoc](https://pkg.go.dev/github.com/boschrexroth/ctrlx-datalayer-golang/v2/pkg/token) ## Status @@ -44,8 +44,8 @@ sudo apt-get install libsystemd-dev libsystemd-dev:arm64 libzmq3-dev libzmq3-dev Check the current [ctrlx Data Layer](https://github.com/boschrexroth/ctrlx-automation-sdk/releases) debian package, download and install this, see example. ```bash -wget https://github.com/boschrexroth/ctrlx-automation-sdk/releases/download/2.4.0/ctrlx-datalayer-2.4.5.deb -sudo dpkg -i ctrlx-datalayer-2.4.5.deb +wget https://github.com/boschrexroth/ctrlx-automation-sdk/releases/download/2.6.0/ctrlx-datalayer-2.6.1.deb +sudo dpkg -i ctrlx-datalayer-2.6.1.deb ``` ### Integrate in you project diff --git a/go.mod b/go.mod index 773420d..65e8564 100644 --- a/go.mod +++ b/go.mod @@ -3,11 +3,11 @@ module github.com/boschrexroth/ctrlx-datalayer-golang/v2 go 1.21 require ( - github.com/google/flatbuffers v23.5.26+incompatible + github.com/google/flatbuffers v24.3.25+incompatible github.com/loov/hrtime v1.0.3 github.com/loov/hrtime/hrplot v1.0.2 github.com/oliveagle/jsonpath v0.0.0-20180606110733-2e52cf6e6852 - github.com/stretchr/testify v1.8.4 + github.com/stretchr/testify v1.9.0 gopkg.in/yaml.v2 v2.4.0 ) diff --git a/go.sum b/go.sum index 800099a..7eaf44f 100644 --- a/go.sum +++ b/go.sum @@ -1,7 +1,7 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/google/flatbuffers v23.5.26+incompatible h1:M9dgRyhJemaM4Sw8+66GHBu8ioaQmyPLg1b8VwK5WJg= -github.com/google/flatbuffers v23.5.26+incompatible/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv5+zNeJKJCa8= +github.com/google/flatbuffers v24.3.25+incompatible h1:CX395cjN9Kke9mmalRoL3d81AtFUxJM+yDthflgJGkI= +github.com/google/flatbuffers v24.3.25+incompatible/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv5+zNeJKJCa8= github.com/loov/hrtime v1.0.1/go.mod h1:yDY3Pwv2izeY4sq7YcPX/dtLwzg5NU1AxWuWxKwd0p0= github.com/loov/hrtime v1.0.3 h1:LiWKU3B9skJwRPUf0Urs9+0+OE3TxdMuiRPOTwR0gcU= github.com/loov/hrtime v1.0.3/go.mod h1:yDY3Pwv2izeY4sq7YcPX/dtLwzg5NU1AxWuWxKwd0p0= @@ -14,8 +14,8 @@ github.com/oliveagle/jsonpath v0.0.0-20180606110733-2e52cf6e6852 h1:Yl0tPBa8QPjG github.com/oliveagle/jsonpath v0.0.0-20180606110733-2e52cf6e6852/go.mod h1:eqOVx5Vwu4gd2mmMZvVZsgIqNSaW3xxRThUJ0k/TPk4= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= -github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= +github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= diff --git a/pkg/datalayer/metadatabuilder.go b/pkg/datalayer/metadatabuilder.go index c22d00a..d8841e5 100644 --- a/pkg/datalayer/metadatabuilder.go +++ b/pkg/datalayer/metadatabuilder.go @@ -1,7 +1,7 @@ /** * MIT License * - * Copyright (c) 2021-2023 Bosch Rexroth AG + * Copyright (c) 2021-2024 Bosch Rexroth AG * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal @@ -89,7 +89,10 @@ type MetaDataBuilder struct { } // NewMetaDataBuilder generates MetaDataBuilder instance -func NewMetaDataBuilder(a AllowedOperation, desc string, descurl string) *MetaDataBuilder { +// Parameter operations are the allowed operations of the provider node +// Parameter desc is the description of the provider node and should not be empty ("") +// Parameter descurl is the URL of the description and should not be empty ("") +func NewMetaDataBuilder(operations AllowedOperation, desc string, descurl string) *MetaDataBuilder { m := &MetaDataBuilder{description: desc, descriptionurl: descurl} m.name = "" m.unit = "" @@ -99,7 +102,7 @@ func NewMetaDataBuilder(a AllowedOperation, desc string, descurl string) *MetaDa m.extensions = make(map[string]string) m.descriptions = make(map[string]string) m.displaynames = make(map[string]string) - m.Operations(a) + m.Operations(operations) return m } @@ -123,8 +126,8 @@ func (m *MetaDataBuilder) Build() *Variant { operations := m.operations() meta := fbs.MetadataT{} - meta.Description = m.description - meta.DescriptionUrl = m.descriptionurl + meta.Description = m.fixFlatcOptimizer(m.description) + meta.DescriptionUrl = m.fixFlatcOptimizer(m.descriptionurl) meta.DisplayName = m.name meta.Unit = m.unit meta.DisplayFormat = m.displayformat @@ -286,3 +289,11 @@ func (m *MetaDataBuilder) AddLocalizationDisplayName(id, txt string) *MetaDataBu m.displaynames[id] = txt return m } + +// see flatbuffers commit: https://github.com/google/flatbuffers/commit/96d438df47d +func (m *MetaDataBuilder) fixFlatcOptimizer(val string) string { + if val == "" { + return " " + } + return val +} diff --git a/pkg/fbs/comm/axisprofile/fbtypes/variableType.go b/pkg/fbs/comm/axisprofile/fbtypes/variableType.go index 56bea30..699daa0 100644 --- a/pkg/fbs/comm/axisprofile/fbtypes/variableType.go +++ b/pkg/fbs/comm/axisprofile/fbtypes/variableType.go @@ -19,6 +19,10 @@ const ( variableTypePROBE variableType = 3 /// torque/force type variableTypeTORQUE_FORCE variableType = 4 + /// safe motion + variableTypeSAFE_MOTION variableType = 5 + /// user PDO + variableTypeUSER_PDO variableType = 6 ) var EnumNamesvariableType = map[variableType]string{ @@ -28,6 +32,8 @@ var EnumNamesvariableType = map[variableType]string{ variableTypeHOMING: "HOMING", variableTypePROBE: "PROBE", variableTypeTORQUE_FORCE: "TORQUE_FORCE", + variableTypeSAFE_MOTION: "SAFE_MOTION", + variableTypeUSER_PDO: "USER_PDO", } var EnumValuesvariableType = map[string]variableType{ @@ -37,6 +43,8 @@ var EnumValuesvariableType = map[string]variableType{ "HOMING": variableTypeHOMING, "PROBE": variableTypePROBE, "TORQUE_FORCE": variableTypeTORQUE_FORCE, + "SAFE_MOTION": variableTypeSAFE_MOTION, + "USER_PDO": variableTypeUSER_PDO, } func (v variableType) String() string { diff --git a/pkg/fbs/comm/datalayer/Capabilities.go b/pkg/fbs/comm/datalayer/Capabilities.go new file mode 100644 index 0000000..7385c60 --- /dev/null +++ b/pkg/fbs/comm/datalayer/Capabilities.go @@ -0,0 +1,114 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package datalayer + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type CapabilitiesT struct { + BulkMax uint32 `json:"bulkMax"` + MultiRegister bool `json:"multiRegister"` + MaximumMessageSize uint32 `json:"maximumMessageSize"` +} + +func (t *CapabilitiesT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + CapabilitiesStart(builder) + CapabilitiesAddBulkMax(builder, t.BulkMax) + CapabilitiesAddMultiRegister(builder, t.MultiRegister) + CapabilitiesAddMaximumMessageSize(builder, t.MaximumMessageSize) + return CapabilitiesEnd(builder) +} + +func (rcv *Capabilities) UnPackTo(t *CapabilitiesT) { + t.BulkMax = rcv.BulkMax() + t.MultiRegister = rcv.MultiRegister() + t.MaximumMessageSize = rcv.MaximumMessageSize() +} + +func (rcv *Capabilities) UnPack() *CapabilitiesT { + if rcv == nil { return nil } + t := &CapabilitiesT{} + rcv.UnPackTo(t) + return t +} + +type Capabilities struct { + _tab flatbuffers.Table +} + +func GetRootAsCapabilities(buf []byte, offset flatbuffers.UOffsetT) *Capabilities { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Capabilities{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCapabilities(buf []byte, offset flatbuffers.UOffsetT) *Capabilities { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Capabilities{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Capabilities) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Capabilities) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Capabilities) BulkMax() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *Capabilities) MutateBulkMax(n uint32) bool { + return rcv._tab.MutateUint32Slot(4, n) +} + +func (rcv *Capabilities) MultiRegister() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *Capabilities) MutateMultiRegister(n bool) bool { + return rcv._tab.MutateBoolSlot(6, n) +} + +func (rcv *Capabilities) MaximumMessageSize() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *Capabilities) MutateMaximumMessageSize(n uint32) bool { + return rcv._tab.MutateUint32Slot(8, n) +} + +func CapabilitiesStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func CapabilitiesAddBulkMax(builder *flatbuffers.Builder, bulkMax uint32) { + builder.PrependUint32Slot(0, bulkMax, 0) +} +func CapabilitiesAddMultiRegister(builder *flatbuffers.Builder, multiRegister bool) { + builder.PrependBoolSlot(1, multiRegister, false) +} +func CapabilitiesAddMaximumMessageSize(builder *flatbuffers.Builder, maximumMessageSize uint32) { + builder.PrependUint32Slot(2, maximumMessageSize, 0) +} +func CapabilitiesEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/datalayer/DataChangeTrigger.go b/pkg/fbs/comm/datalayer/DataChangeTrigger.go index ca0b464..c1af7e1 100644 --- a/pkg/fbs/comm/datalayer/DataChangeTrigger.go +++ b/pkg/fbs/comm/datalayer/DataChangeTrigger.go @@ -13,18 +13,26 @@ const ( DataChangeTriggerStatusValue DataChangeTrigger = 1 /// Inform if Status Or Status Or Timestamp changes (inform always) DataChangeTriggerStatusValueTimestamp DataChangeTrigger = 2 + /// Inform about upcoming events + DataChangeTriggerEvent DataChangeTrigger = 3 + /// Inform about value changes and events + DataChangeTriggerStatusValueEvent DataChangeTrigger = 4 ) var EnumNamesDataChangeTrigger = map[DataChangeTrigger]string{ DataChangeTriggerStatus: "Status", DataChangeTriggerStatusValue: "StatusValue", DataChangeTriggerStatusValueTimestamp: "StatusValueTimestamp", + DataChangeTriggerEvent: "Event", + DataChangeTriggerStatusValueEvent: "StatusValueEvent", } var EnumValuesDataChangeTrigger = map[string]DataChangeTrigger{ "Status": DataChangeTriggerStatus, "StatusValue": DataChangeTriggerStatusValue, "StatusValueTimestamp": DataChangeTriggerStatusValueTimestamp, + "Event": DataChangeTriggerEvent, + "StatusValueEvent": DataChangeTriggerStatusValueEvent, } func (v DataChangeTrigger) String() string { diff --git a/pkg/fbs/comm/datalayer/EventInfo.go b/pkg/fbs/comm/datalayer/EventInfo.go new file mode 100644 index 0000000..e2a9e4f --- /dev/null +++ b/pkg/fbs/comm/datalayer/EventInfo.go @@ -0,0 +1,166 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package datalayer + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type EventInfoT struct { + EventType string `json:"eventType"` + SourceNode string `json:"sourceNode"` + SourceName string `json:"sourceName"` + Timestamp uint64 `json:"timestamp"` + SequenceNumber uint64 `json:"sequenceNumber"` +} + +func (t *EventInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + eventTypeOffset := flatbuffers.UOffsetT(0) + if t.EventType != "" { + eventTypeOffset = builder.CreateString(t.EventType) + } + sourceNodeOffset := flatbuffers.UOffsetT(0) + if t.SourceNode != "" { + sourceNodeOffset = builder.CreateString(t.SourceNode) + } + sourceNameOffset := flatbuffers.UOffsetT(0) + if t.SourceName != "" { + sourceNameOffset = builder.CreateString(t.SourceName) + } + EventInfoStart(builder) + EventInfoAddEventType(builder, eventTypeOffset) + EventInfoAddSourceNode(builder, sourceNodeOffset) + EventInfoAddSourceName(builder, sourceNameOffset) + EventInfoAddTimestamp(builder, t.Timestamp) + EventInfoAddSequenceNumber(builder, t.SequenceNumber) + return EventInfoEnd(builder) +} + +func (rcv *EventInfo) UnPackTo(t *EventInfoT) { + t.EventType = string(rcv.EventType()) + t.SourceNode = string(rcv.SourceNode()) + t.SourceName = string(rcv.SourceName()) + t.Timestamp = rcv.Timestamp() + t.SequenceNumber = rcv.SequenceNumber() +} + +func (rcv *EventInfo) UnPack() *EventInfoT { + if rcv == nil { return nil } + t := &EventInfoT{} + rcv.UnPackTo(t) + return t +} + +type EventInfo struct { + _tab flatbuffers.Table +} + +func GetRootAsEventInfo(buf []byte, offset flatbuffers.UOffsetT) *EventInfo { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &EventInfo{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsEventInfo(buf []byte, offset flatbuffers.UOffsetT) *EventInfo { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &EventInfo{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *EventInfo) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *EventInfo) Table() flatbuffers.Table { + return rcv._tab +} + +/// The type of event, that is transfered. +/// E.g.: "types/events/ExampleEvent" +func (rcv *EventInfo) EventType() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// The type of event, that is transfered. +/// E.g.: "types/events/ExampleEvent" +/// The node, that fired the event. +/// E.g.: diagnosis/warning +func (rcv *EventInfo) SourceNode() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// The node, that fired the event. +/// E.g.: diagnosis/warning +/// Description of the source of the event. +func (rcv *EventInfo) SourceName() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// Description of the source of the event. +/// optional, otherwise filled by provider. +/// Format is FILETIME +func (rcv *EventInfo) Timestamp() uint64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetUint64(o + rcv._tab.Pos) + } + return 0 +} + +/// optional, otherwise filled by provider. +/// Format is FILETIME +func (rcv *EventInfo) MutateTimestamp(n uint64) bool { + return rcv._tab.MutateUint64Slot(10, n) +} + +/// optional, otherwise filled by provider. +func (rcv *EventInfo) SequenceNumber() uint64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.GetUint64(o + rcv._tab.Pos) + } + return 0 +} + +/// optional, otherwise filled by provider. +func (rcv *EventInfo) MutateSequenceNumber(n uint64) bool { + return rcv._tab.MutateUint64Slot(12, n) +} + +func EventInfoStart(builder *flatbuffers.Builder) { + builder.StartObject(5) +} +func EventInfoAddEventType(builder *flatbuffers.Builder, eventType flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(eventType), 0) +} +func EventInfoAddSourceNode(builder *flatbuffers.Builder, sourceNode flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(sourceNode), 0) +} +func EventInfoAddSourceName(builder *flatbuffers.Builder, sourceName flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(sourceName), 0) +} +func EventInfoAddTimestamp(builder *flatbuffers.Builder, timestamp uint64) { + builder.PrependUint64Slot(3, timestamp, 0) +} +func EventInfoAddSequenceNumber(builder *flatbuffers.Builder, sequenceNumber uint64) { + builder.PrependUint64Slot(4, sequenceNumber, 0) +} +func EventInfoEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/datalayer/NotifyInfo.go b/pkg/fbs/comm/datalayer/NotifyInfo.go index 1ce1d4e..4683907 100644 --- a/pkg/fbs/comm/datalayer/NotifyInfo.go +++ b/pkg/fbs/comm/datalayer/NotifyInfo.go @@ -10,6 +10,9 @@ type NotifyInfoT struct { Node string `json:"node"` Timestamp uint64 `json:"timestamp"` NotifyType NotifyType `json:"notifyType"` + EventType string `json:"eventType"` + SequenceNumber uint64 `json:"sequenceNumber"` + SourceName string `json:"sourceName"` } func (t *NotifyInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { @@ -18,10 +21,21 @@ func (t *NotifyInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { if t.Node != "" { nodeOffset = builder.CreateString(t.Node) } + eventTypeOffset := flatbuffers.UOffsetT(0) + if t.EventType != "" { + eventTypeOffset = builder.CreateString(t.EventType) + } + sourceNameOffset := flatbuffers.UOffsetT(0) + if t.SourceName != "" { + sourceNameOffset = builder.CreateString(t.SourceName) + } NotifyInfoStart(builder) NotifyInfoAddNode(builder, nodeOffset) NotifyInfoAddTimestamp(builder, t.Timestamp) NotifyInfoAddNotifyType(builder, t.NotifyType) + NotifyInfoAddEventType(builder, eventTypeOffset) + NotifyInfoAddSequenceNumber(builder, t.SequenceNumber) + NotifyInfoAddSourceName(builder, sourceNameOffset) return NotifyInfoEnd(builder) } @@ -29,6 +43,9 @@ func (rcv *NotifyInfo) UnPackTo(t *NotifyInfoT) { t.Node = string(rcv.Node()) t.Timestamp = rcv.Timestamp() t.NotifyType = rcv.NotifyType() + t.EventType = string(rcv.EventType()) + t.SequenceNumber = rcv.SequenceNumber() + t.SourceName = string(rcv.SourceName()) } func (rcv *NotifyInfo) UnPack() *NotifyInfoT { @@ -101,8 +118,42 @@ func (rcv *NotifyInfo) MutateNotifyType(n NotifyType) bool { return rcv._tab.MutateInt32Slot(8, int32(n)) } +/// In case of an event, this string contains the information what EventType has been fired. E.g.: "types/events/ExampleEvent" +func (rcv *NotifyInfo) EventType() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// In case of an event, this string contains the information what EventType has been fired. E.g.: "types/events/ExampleEvent" +/// sequence number of an event +func (rcv *NotifyInfo) SequenceNumber() uint64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.GetUint64(o + rcv._tab.Pos) + } + return 0 +} + +/// sequence number of an event +func (rcv *NotifyInfo) MutateSequenceNumber(n uint64) bool { + return rcv._tab.MutateUint64Slot(12, n) +} + +/// Description of the source of an event +func (rcv *NotifyInfo) SourceName() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// Description of the source of an event func NotifyInfoStart(builder *flatbuffers.Builder) { - builder.StartObject(3) + builder.StartObject(6) } func NotifyInfoAddNode(builder *flatbuffers.Builder, node flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(node), 0) @@ -113,6 +164,15 @@ func NotifyInfoAddTimestamp(builder *flatbuffers.Builder, timestamp uint64) { func NotifyInfoAddNotifyType(builder *flatbuffers.Builder, notifyType NotifyType) { builder.PrependInt32Slot(2, int32(notifyType), 0) } +func NotifyInfoAddEventType(builder *flatbuffers.Builder, eventType flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(eventType), 0) +} +func NotifyInfoAddSequenceNumber(builder *flatbuffers.Builder, sequenceNumber uint64) { + builder.PrependUint64Slot(4, sequenceNumber, 0) +} +func NotifyInfoAddSourceName(builder *flatbuffers.Builder, sourceName flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(sourceName), 0) +} func NotifyInfoEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/pkg/fbs/comm/datalayer/NotifyType.go b/pkg/fbs/comm/datalayer/NotifyType.go index d5bf9cf..29e141e 100644 --- a/pkg/fbs/comm/datalayer/NotifyType.go +++ b/pkg/fbs/comm/datalayer/NotifyType.go @@ -12,6 +12,7 @@ const ( NotifyTypeMetadata NotifyType = 2 NotifyTypeKeepalive NotifyType = 3 NotifyTypeType NotifyType = 4 + NotifyTypeEvent NotifyType = 5 ) var EnumNamesNotifyType = map[NotifyType]string{ @@ -20,6 +21,7 @@ var EnumNamesNotifyType = map[NotifyType]string{ NotifyTypeMetadata: "Metadata", NotifyTypeKeepalive: "Keepalive", NotifyTypeType: "Type", + NotifyTypeEvent: "Event", } var EnumValuesNotifyType = map[string]NotifyType{ @@ -28,6 +30,7 @@ var EnumValuesNotifyType = map[string]NotifyType{ "Metadata": NotifyTypeMetadata, "Keepalive": NotifyTypeKeepalive, "Type": NotifyTypeType, + "Event": NotifyTypeEvent, } func (v NotifyType) String() string { diff --git a/pkg/fbs/comm/datalayer/ProviderStat.go b/pkg/fbs/comm/datalayer/ProviderStat.go index edeb001..c89dc33 100644 --- a/pkg/fbs/comm/datalayer/ProviderStat.go +++ b/pkg/fbs/comm/datalayer/ProviderStat.go @@ -11,6 +11,8 @@ type ProviderStatT struct { Identity string `json:"identity"` Nodes []string `json:"nodes"` RejectedNodes []string `json:"rejectedNodes"` + Scopes []*ScopeT `json:"scopes"` + Capabilities *CapabilitiesT `json:"capabilities"` } func (t *ProviderStatT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { @@ -45,10 +47,26 @@ func (t *ProviderStatT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT } rejectedNodesOffset = builder.EndVector(rejectedNodesLength) } + scopesOffset := flatbuffers.UOffsetT(0) + if t.Scopes != nil { + scopesLength := len(t.Scopes) + scopesOffsets := make([]flatbuffers.UOffsetT, scopesLength) + for j := 0; j < scopesLength; j++ { + scopesOffsets[j] = t.Scopes[j].Pack(builder) + } + ProviderStatStartScopesVector(builder, scopesLength) + for j := scopesLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(scopesOffsets[j]) + } + scopesOffset = builder.EndVector(scopesLength) + } + capabilitiesOffset := t.Capabilities.Pack(builder) ProviderStatStart(builder) ProviderStatAddIdentity(builder, identityOffset) ProviderStatAddNodes(builder, nodesOffset) ProviderStatAddRejectedNodes(builder, rejectedNodesOffset) + ProviderStatAddScopes(builder, scopesOffset) + ProviderStatAddCapabilities(builder, capabilitiesOffset) return ProviderStatEnd(builder) } @@ -64,6 +82,14 @@ func (rcv *ProviderStat) UnPackTo(t *ProviderStatT) { for j := 0; j < rejectedNodesLength; j++ { t.RejectedNodes[j] = string(rcv.RejectedNodes(j)) } + scopesLength := rcv.ScopesLength() + t.Scopes = make([]*ScopeT, scopesLength) + for j := 0; j < scopesLength; j++ { + x := Scope{} + rcv.Scopes(&x, j) + t.Scopes[j] = x.UnPack() + } + t.Capabilities = rcv.Capabilities(nil).UnPack() } func (rcv *ProviderStat) UnPack() *ProviderStatT { @@ -142,8 +168,50 @@ func (rcv *ProviderStat) RejectedNodesLength() int { return 0 } +func (rcv *ProviderStat) Scopes(obj *Scope, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + x := rcv._tab.Vector(o) + x += flatbuffers.UOffsetT(j) * 4 + x = rcv._tab.Indirect(x) + obj.Init(rcv._tab.Bytes, x) + return true + } + return false +} + +func (rcv *ProviderStat) ScopesByKey(obj *Scope, key string) bool{ + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + x := rcv._tab.Vector(o) + return obj.LookupByKey(key, x, rcv._tab.Bytes) + } + return false +} + +func (rcv *ProviderStat) ScopesLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func (rcv *ProviderStat) Capabilities(obj *Capabilities) *Capabilities { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(Capabilities) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + func ProviderStatStart(builder *flatbuffers.Builder) { - builder.StartObject(3) + builder.StartObject(5) } func ProviderStatAddIdentity(builder *flatbuffers.Builder, identity flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(identity), 0) @@ -160,6 +228,15 @@ func ProviderStatAddRejectedNodes(builder *flatbuffers.Builder, rejectedNodes fl func ProviderStatStartRejectedNodesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { return builder.StartVector(4, numElems, 4) } +func ProviderStatAddScopes(builder *flatbuffers.Builder, scopes flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(scopes), 0) +} +func ProviderStatStartScopesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func ProviderStatAddCapabilities(builder *flatbuffers.Builder, capabilities flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(capabilities), 0) +} func ProviderStatEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/pkg/fbs/comm/datalayer/ServerSettings.go b/pkg/fbs/comm/datalayer/ServerSettings.go index d5eb55c..758e3ff 100644 --- a/pkg/fbs/comm/datalayer/ServerSettings.go +++ b/pkg/fbs/comm/datalayer/ServerSettings.go @@ -14,6 +14,11 @@ type ServerSettingsT struct { ServerMaxRtSize uint32 `json:"serverMaxRtSize"` ServerEmulatedNvramSize uint32 `json:"serverEmulatedNvramSize"` ExperimentalFeatures []string `json:"experimentalFeatures"` + TcpPortFrontend uint16 `json:"tcpPortFrontend"` + TcpPortBackend uint16 `json:"tcpPortBackend"` + ForceEmulatedNvram bool `json:"forceEmulatedNvram"` + ServerZmqHighWaterMark uint32 `json:"serverZmqHighWaterMark"` + MaxBulkRequest uint32 `json:"maxBulkRequest"` } func (t *ServerSettingsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { @@ -43,6 +48,11 @@ func (t *ServerSettingsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffset ServerSettingsAddServerMaxRtSize(builder, t.ServerMaxRtSize) ServerSettingsAddServerEmulatedNvramSize(builder, t.ServerEmulatedNvramSize) ServerSettingsAddExperimentalFeatures(builder, experimentalFeaturesOffset) + ServerSettingsAddTcpPortFrontend(builder, t.TcpPortFrontend) + ServerSettingsAddTcpPortBackend(builder, t.TcpPortBackend) + ServerSettingsAddForceEmulatedNvram(builder, t.ForceEmulatedNvram) + ServerSettingsAddServerZmqHighWaterMark(builder, t.ServerZmqHighWaterMark) + ServerSettingsAddMaxBulkRequest(builder, t.MaxBulkRequest) return ServerSettingsEnd(builder) } @@ -58,6 +68,11 @@ func (rcv *ServerSettings) UnPackTo(t *ServerSettingsT) { for j := 0; j < experimentalFeaturesLength; j++ { t.ExperimentalFeatures[j] = string(rcv.ExperimentalFeatures(j)) } + t.TcpPortFrontend = rcv.TcpPortFrontend() + t.TcpPortBackend = rcv.TcpPortBackend() + t.ForceEmulatedNvram = rcv.ForceEmulatedNvram() + t.ServerZmqHighWaterMark = rcv.ServerZmqHighWaterMark() + t.MaxBulkRequest = rcv.MaxBulkRequest() } func (rcv *ServerSettings) UnPack() *ServerSettingsT { @@ -114,7 +129,7 @@ func (rcv *ServerSettings) ServerWaitResponseTimeout() uint32 { if o != 0 { return rcv._tab.GetUint32(o + rcv._tab.Pos) } - return 3000 + return 30000 } /// after this time a response from provider is expected - if there is no answer a provider is assumed to be dead --> kick provider out of routing @@ -152,7 +167,7 @@ func (rcv *ServerSettings) ServerMaxRtSize() uint32 { if o != 0 { return rcv._tab.GetUint32(o + rcv._tab.Pos) } - return 1048576 + return 2097152 } /// Maximum size of a RT area @@ -160,7 +175,8 @@ func (rcv *ServerSettings) MutateServerMaxRtSize(n uint32) bool { return rcv._tab.MutateUint32Slot(12, n) } -/// Emulated NVRam size - will be active after a restart of app.automationcore +/// Emulated NVRam size if no real NVRAM is found +/// Changes will be active after a restart of app.automationcore func (rcv *ServerSettings) ServerEmulatedNvramSize() uint32 { o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) if o != 0 { @@ -169,7 +185,8 @@ func (rcv *ServerSettings) ServerEmulatedNvramSize() uint32 { return 122880 } -/// Emulated NVRam size - will be active after a restart of app.automationcore +/// Emulated NVRam size if no real NVRAM is found +/// Changes will be active after a restart of app.automationcore func (rcv *ServerSettings) MutateServerEmulatedNvramSize(n uint32) bool { return rcv._tab.MutateUint32Slot(14, n) } @@ -193,14 +210,100 @@ func (rcv *ServerSettings) ExperimentalFeaturesLength() int { } /// Add the names of the experimental feature you want to enable here +/// Used port for TCP frontend communication - Use value 0 to deactivate communication +/// Takes effect after reboot of control +func (rcv *ServerSettings) TcpPortFrontend() uint16 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(18)) + if o != 0 { + return rcv._tab.GetUint16(o + rcv._tab.Pos) + } + return 2069 +} + +/// Used port for TCP frontend communication - Use value 0 to deactivate communication +/// Takes effect after reboot of control +func (rcv *ServerSettings) MutateTcpPortFrontend(n uint16) bool { + return rcv._tab.MutateUint16Slot(18, n) +} + +/// Used port for TCP backend communication - Use value 0 to deactivate communication +/// Takes effect after reboot of control +func (rcv *ServerSettings) TcpPortBackend() uint16 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(20)) + if o != 0 { + return rcv._tab.GetUint16(o + rcv._tab.Pos) + } + return 2070 +} + +/// Used port for TCP backend communication - Use value 0 to deactivate communication +/// Takes effect after reboot of control +func (rcv *ServerSettings) MutateTcpPortBackend(n uint16) bool { + return rcv._tab.MutateUint16Slot(20, n) +} + +/// Force emulation of NVRam even if there is a real NVRAM +/// Size of NVRam is serverEmulatedNvramSize +/// Changes will be active after reboot of control +func (rcv *ServerSettings) ForceEmulatedNvram() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(22)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +/// Force emulation of NVRam even if there is a real NVRAM +/// Size of NVRam is serverEmulatedNvramSize +/// Changes will be active after reboot of control +func (rcv *ServerSettings) MutateForceEmulatedNvram(n bool) bool { + return rcv._tab.MutateBoolSlot(22, n) +} + +/// High water mark of ZMQ +/// Takes effect after reboot of control +func (rcv *ServerSettings) ServerZmqHighWaterMark() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(24)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 1000 +} + +/// High water mark of ZMQ +/// Takes effect after reboot of control +func (rcv *ServerSettings) MutateServerZmqHighWaterMark(n uint32) bool { + return rcv._tab.MutateUint32Slot(24, n) +} + +/// Number of requests per bulk +/// If set to 0 - all requests will be single requests. +/// If set to a value unequal to 0 - a bulk request will be +/// splited to this count. +func (rcv *ServerSettings) MaxBulkRequest() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(26)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 1000 +} + +/// Number of requests per bulk +/// If set to 0 - all requests will be single requests. +/// If set to a value unequal to 0 - a bulk request will be +/// splited to this count. +func (rcv *ServerSettings) MutateMaxBulkRequest(n uint32) bool { + return rcv._tab.MutateUint32Slot(26, n) +} + func ServerSettingsStart(builder *flatbuffers.Builder) { - builder.StartObject(7) + builder.StartObject(12) } func ServerSettingsAddServerIdlePingTimeout(builder *flatbuffers.Builder, serverIdlePingTimeout uint32) { builder.PrependUint32Slot(0, serverIdlePingTimeout, 30000) } func ServerSettingsAddServerWaitResponseTimeout(builder *flatbuffers.Builder, serverWaitResponseTimeout uint32) { - builder.PrependUint32Slot(1, serverWaitResponseTimeout, 3000) + builder.PrependUint32Slot(1, serverWaitResponseTimeout, 30000) } func ServerSettingsAddServerMaxMessageSize(builder *flatbuffers.Builder, serverMaxMessageSize uint32) { builder.PrependUint32Slot(2, serverMaxMessageSize, 52428800) @@ -209,7 +312,7 @@ func ServerSettingsAddDebugAddress(builder *flatbuffers.Builder, debugAddress fl builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(debugAddress), 0) } func ServerSettingsAddServerMaxRtSize(builder *flatbuffers.Builder, serverMaxRtSize uint32) { - builder.PrependUint32Slot(4, serverMaxRtSize, 1048576) + builder.PrependUint32Slot(4, serverMaxRtSize, 2097152) } func ServerSettingsAddServerEmulatedNvramSize(builder *flatbuffers.Builder, serverEmulatedNvramSize uint32) { builder.PrependUint32Slot(5, serverEmulatedNvramSize, 122880) @@ -220,6 +323,21 @@ func ServerSettingsAddExperimentalFeatures(builder *flatbuffers.Builder, experim func ServerSettingsStartExperimentalFeaturesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { return builder.StartVector(4, numElems, 4) } +func ServerSettingsAddTcpPortFrontend(builder *flatbuffers.Builder, tcpPortFrontend uint16) { + builder.PrependUint16Slot(7, tcpPortFrontend, 2069) +} +func ServerSettingsAddTcpPortBackend(builder *flatbuffers.Builder, tcpPortBackend uint16) { + builder.PrependUint16Slot(8, tcpPortBackend, 2070) +} +func ServerSettingsAddForceEmulatedNvram(builder *flatbuffers.Builder, forceEmulatedNvram bool) { + builder.PrependBoolSlot(9, forceEmulatedNvram, false) +} +func ServerSettingsAddServerZmqHighWaterMark(builder *flatbuffers.Builder, serverZmqHighWaterMark uint32) { + builder.PrependUint32Slot(10, serverZmqHighWaterMark, 1000) +} +func ServerSettingsAddMaxBulkRequest(builder *flatbuffers.Builder, maxBulkRequest uint32) { + builder.PrependUint32Slot(11, maxBulkRequest, 1000) +} func ServerSettingsEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/pkg/fbs/comm/datalayer/framework/BundleEvent.go b/pkg/fbs/comm/datalayer/framework/BundleEvent.go new file mode 100644 index 0000000..87d368a --- /dev/null +++ b/pkg/fbs/comm/datalayer/framework/BundleEvent.go @@ -0,0 +1,158 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package framework + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type BundleEventT struct { + Name string `json:"name"` + Id int64 `json:"id"` + Event InstallEvent `json:"event"` + Location string `json:"location"` + Version string `json:"version"` +} + +func (t *BundleEventT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := flatbuffers.UOffsetT(0) + if t.Name != "" { + nameOffset = builder.CreateString(t.Name) + } + locationOffset := flatbuffers.UOffsetT(0) + if t.Location != "" { + locationOffset = builder.CreateString(t.Location) + } + versionOffset := flatbuffers.UOffsetT(0) + if t.Version != "" { + versionOffset = builder.CreateString(t.Version) + } + BundleEventStart(builder) + BundleEventAddName(builder, nameOffset) + BundleEventAddId(builder, t.Id) + BundleEventAddEvent(builder, t.Event) + BundleEventAddLocation(builder, locationOffset) + BundleEventAddVersion(builder, versionOffset) + return BundleEventEnd(builder) +} + +func (rcv *BundleEvent) UnPackTo(t *BundleEventT) { + t.Name = string(rcv.Name()) + t.Id = rcv.Id() + t.Event = rcv.Event() + t.Location = string(rcv.Location()) + t.Version = string(rcv.Version()) +} + +func (rcv *BundleEvent) UnPack() *BundleEventT { + if rcv == nil { return nil } + t := &BundleEventT{} + rcv.UnPackTo(t) + return t +} + +type BundleEvent struct { + _tab flatbuffers.Table +} + +func GetRootAsBundleEvent(buf []byte, offset flatbuffers.UOffsetT) *BundleEvent { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &BundleEvent{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsBundleEvent(buf []byte, offset flatbuffers.UOffsetT) *BundleEvent { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &BundleEvent{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *BundleEvent) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *BundleEvent) Table() flatbuffers.Table { + return rcv._tab +} + +/// Name of the bundle +func (rcv *BundleEvent) Name() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// Name of the bundle +func (rcv *BundleEvent) Id() int64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetInt64(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *BundleEvent) MutateId(n int64) bool { + return rcv._tab.MutateInt64Slot(6, n) +} + +/// Type of event +func (rcv *BundleEvent) Event() InstallEvent { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return InstallEvent(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +/// Type of event +func (rcv *BundleEvent) MutateEvent(n InstallEvent) bool { + return rcv._tab.MutateInt8Slot(8, int8(n)) +} + +/// File location of the bundle +func (rcv *BundleEvent) Location() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// File location of the bundle +/// verison of the bundle +func (rcv *BundleEvent) Version() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// verison of the bundle +func BundleEventStart(builder *flatbuffers.Builder) { + builder.StartObject(5) +} +func BundleEventAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0) +} +func BundleEventAddId(builder *flatbuffers.Builder, id int64) { + builder.PrependInt64Slot(1, id, 0) +} +func BundleEventAddEvent(builder *flatbuffers.Builder, event InstallEvent) { + builder.PrependInt8Slot(2, int8(event), 0) +} +func BundleEventAddLocation(builder *flatbuffers.Builder, location flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(location), 0) +} +func BundleEventAddVersion(builder *flatbuffers.Builder, version flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(version), 0) +} +func BundleEventEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/datalayer/framework/InstallEvent.go b/pkg/fbs/comm/datalayer/framework/InstallEvent.go new file mode 100644 index 0000000..e13b4aa --- /dev/null +++ b/pkg/fbs/comm/datalayer/framework/InstallEvent.go @@ -0,0 +1,29 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package framework + +import "strconv" + +type InstallEvent int8 + +const ( + InstallEventInstall InstallEvent = 0 + InstallEventUninstall InstallEvent = 1 +) + +var EnumNamesInstallEvent = map[InstallEvent]string{ + InstallEventInstall: "Install", + InstallEventUninstall: "Uninstall", +} + +var EnumValuesInstallEvent = map[string]InstallEvent{ + "Install": InstallEventInstall, + "Uninstall": InstallEventUninstall, +} + +func (v InstallEvent) String() string { + if s, ok := EnumNamesInstallEvent[v]; ok { + return s + } + return "InstallEvent(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/DcConfigInfoResponse.go b/pkg/fbs/comm/ethercat/master/fbs/DcConfigInfoResponse.go index c31f189..5c90fb3 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/DcConfigInfoResponse.go +++ b/pkg/fbs/comm/ethercat/master/fbs/DcConfigInfoResponse.go @@ -17,6 +17,7 @@ type DcConfigInfoResponseT struct { SendOffset uint32 `json:"sendOffset"` SyncOffset uint32 `json:"syncOffset"` OutputShiftTime uint32 `json:"outputShiftTime"` + InputShiftTime int32 `json:"inputShiftTime"` } func (t *DcConfigInfoResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { @@ -31,6 +32,7 @@ func (t *DcConfigInfoResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.U DcConfigInfoResponseAddSendOffset(builder, t.SendOffset) DcConfigInfoResponseAddSyncOffset(builder, t.SyncOffset) DcConfigInfoResponseAddOutputShiftTime(builder, t.OutputShiftTime) + DcConfigInfoResponseAddInputShiftTime(builder, t.InputShiftTime) return DcConfigInfoResponseEnd(builder) } @@ -44,6 +46,7 @@ func (rcv *DcConfigInfoResponse) UnPackTo(t *DcConfigInfoResponseT) { t.SendOffset = rcv.SendOffset() t.SyncOffset = rcv.SyncOffset() t.OutputShiftTime = rcv.OutputShiftTime() + t.InputShiftTime = rcv.InputShiftTime() } func (rcv *DcConfigInfoResponse) UnPack() *DcConfigInfoResponseT { @@ -220,8 +223,22 @@ func (rcv *DcConfigInfoResponse) MutateOutputShiftTime(n uint32) bool { return rcv._tab.MutateUint32Slot(20, n) } +///Input shift time in nanoseconds +func (rcv *DcConfigInfoResponse) InputShiftTime() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(22)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return 0 +} + +///Input shift time in nanoseconds +func (rcv *DcConfigInfoResponse) MutateInputShiftTime(n int32) bool { + return rcv._tab.MutateInt32Slot(22, n) +} + func DcConfigInfoResponseStart(builder *flatbuffers.Builder) { - builder.StartObject(9) + builder.StartObject(10) } func DcConfigInfoResponseAddSyncMode(builder *flatbuffers.Builder, syncMode SyncMode) { builder.PrependUint32Slot(0, uint32(syncMode), 0) @@ -250,6 +267,9 @@ func DcConfigInfoResponseAddSyncOffset(builder *flatbuffers.Builder, syncOffset func DcConfigInfoResponseAddOutputShiftTime(builder *flatbuffers.Builder, outputShiftTime uint32) { builder.PrependUint32Slot(8, outputShiftTime, 0) } +func DcConfigInfoResponseAddInputShiftTime(builder *flatbuffers.Builder, inputShiftTime int32) { + builder.PrependInt32Slot(9, inputShiftTime, 0) +} func DcConfigInfoResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/pkg/fbs/comm/ethercat/master/fbs/DcOnlineInfoResponse.go b/pkg/fbs/comm/ethercat/master/fbs/DcOnlineInfoResponse.go index b2300ca..2749a38 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/DcOnlineInfoResponse.go +++ b/pkg/fbs/comm/ethercat/master/fbs/DcOnlineInfoResponse.go @@ -18,10 +18,13 @@ type DcOnlineInfoResponseT struct { SendOffset uint32 `json:"sendOffset"` SyncOffset uint32 `json:"syncOffset"` OutputShiftTime uint32 `json:"outputShiftTime"` + InputShiftTime int32 `json:"inputShiftTime"` + TimeInfo *TimeInfoT `json:"timeInfo"` } func (t *DcOnlineInfoResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { if t == nil { return 0 } + timeInfoOffset := t.TimeInfo.Pack(builder) DcOnlineInfoResponseStart(builder) DcOnlineInfoResponseAddSyncMode(builder, t.SyncMode) DcOnlineInfoResponseAddCycleTime(builder, t.CycleTime) @@ -33,6 +36,8 @@ func (t *DcOnlineInfoResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.U DcOnlineInfoResponseAddSendOffset(builder, t.SendOffset) DcOnlineInfoResponseAddSyncOffset(builder, t.SyncOffset) DcOnlineInfoResponseAddOutputShiftTime(builder, t.OutputShiftTime) + DcOnlineInfoResponseAddInputShiftTime(builder, t.InputShiftTime) + DcOnlineInfoResponseAddTimeInfo(builder, timeInfoOffset) return DcOnlineInfoResponseEnd(builder) } @@ -47,6 +52,8 @@ func (rcv *DcOnlineInfoResponse) UnPackTo(t *DcOnlineInfoResponseT) { t.SendOffset = rcv.SendOffset() t.SyncOffset = rcv.SyncOffset() t.OutputShiftTime = rcv.OutputShiftTime() + t.InputShiftTime = rcv.InputShiftTime() + t.TimeInfo = rcv.TimeInfo(nil).UnPack() } func (rcv *DcOnlineInfoResponse) UnPack() *DcOnlineInfoResponseT { @@ -235,8 +242,37 @@ func (rcv *DcOnlineInfoResponse) MutateOutputShiftTime(n uint32) bool { return rcv._tab.MutateUint32Slot(22, n) } +///Input shift time in nanoseconds +func (rcv *DcOnlineInfoResponse) InputShiftTime() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(24)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return 0 +} + +///Input shift time in nanoseconds +func (rcv *DcOnlineInfoResponse) MutateInputShiftTime(n int32) bool { + return rcv._tab.MutateInt32Slot(24, n) +} + +///Operating system time information +func (rcv *DcOnlineInfoResponse) TimeInfo(obj *TimeInfo) *TimeInfo { + o := flatbuffers.UOffsetT(rcv._tab.Offset(26)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(TimeInfo) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +///Operating system time information func DcOnlineInfoResponseStart(builder *flatbuffers.Builder) { - builder.StartObject(10) + builder.StartObject(12) } func DcOnlineInfoResponseAddSyncMode(builder *flatbuffers.Builder, syncMode SyncMode) { builder.PrependUint32Slot(0, uint32(syncMode), 0) @@ -268,6 +304,12 @@ func DcOnlineInfoResponseAddSyncOffset(builder *flatbuffers.Builder, syncOffset func DcOnlineInfoResponseAddOutputShiftTime(builder *flatbuffers.Builder, outputShiftTime uint32) { builder.PrependUint32Slot(9, outputShiftTime, 0) } +func DcOnlineInfoResponseAddInputShiftTime(builder *flatbuffers.Builder, inputShiftTime int32) { + builder.PrependInt32Slot(10, inputShiftTime, 0) +} +func DcOnlineInfoResponseAddTimeInfo(builder *flatbuffers.Builder, timeInfo flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(11, flatbuffers.UOffsetT(timeInfo), 0) +} func DcOnlineInfoResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/pkg/fbs/comm/ethercat/master/fbs/DcSlaveConfigInfo.go b/pkg/fbs/comm/ethercat/master/fbs/DcSlaveConfigInfo.go new file mode 100644 index 0000000..fb90c64 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/DcSlaveConfigInfo.go @@ -0,0 +1,101 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +///This node delivers slave info data of a configured slave from the EtherCAT Master +type DcSlaveConfigInfoT struct { + Request *AddressedRequestT `json:"request"` + Response *DcSlaveConfigInfoResponseT `json:"response"` +} + +func (t *DcSlaveConfigInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + requestOffset := t.Request.Pack(builder) + responseOffset := t.Response.Pack(builder) + DcSlaveConfigInfoStart(builder) + DcSlaveConfigInfoAddRequest(builder, requestOffset) + DcSlaveConfigInfoAddResponse(builder, responseOffset) + return DcSlaveConfigInfoEnd(builder) +} + +func (rcv *DcSlaveConfigInfo) UnPackTo(t *DcSlaveConfigInfoT) { + t.Request = rcv.Request(nil).UnPack() + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *DcSlaveConfigInfo) UnPack() *DcSlaveConfigInfoT { + if rcv == nil { return nil } + t := &DcSlaveConfigInfoT{} + rcv.UnPackTo(t) + return t +} + +type DcSlaveConfigInfo struct { + _tab flatbuffers.Table +} + +func GetRootAsDcSlaveConfigInfo(buf []byte, offset flatbuffers.UOffsetT) *DcSlaveConfigInfo { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &DcSlaveConfigInfo{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsDcSlaveConfigInfo(buf []byte, offset flatbuffers.UOffsetT) *DcSlaveConfigInfo { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &DcSlaveConfigInfo{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *DcSlaveConfigInfo) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *DcSlaveConfigInfo) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *DcSlaveConfigInfo) Request(obj *AddressedRequest) *AddressedRequest { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(AddressedRequest) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *DcSlaveConfigInfo) Response(obj *DcSlaveConfigInfoResponse) *DcSlaveConfigInfoResponse { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(DcSlaveConfigInfoResponse) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func DcSlaveConfigInfoStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func DcSlaveConfigInfoAddRequest(builder *flatbuffers.Builder, request flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(request), 0) +} +func DcSlaveConfigInfoAddResponse(builder *flatbuffers.Builder, response flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(response), 0) +} +func DcSlaveConfigInfoEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/DcSlaveConfigInfoResponse.go b/pkg/fbs/comm/ethercat/master/fbs/DcSlaveConfigInfoResponse.go new file mode 100644 index 0000000..efa76ac --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/DcSlaveConfigInfoResponse.go @@ -0,0 +1,161 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +///DC slave configuration response +type DcSlaveConfigInfoResponseT struct { + DcSupport bool `json:"dcSupport"` + DcReferenceClock bool `json:"dcReferenceClock"` + CycleTime0 uint32 `json:"CycleTime0"` + CycleTime1 uint32 `json:"CycleTime1"` + ShiftTime int32 `json:"ShiftTime"` +} + +func (t *DcSlaveConfigInfoResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + DcSlaveConfigInfoResponseStart(builder) + DcSlaveConfigInfoResponseAddDcSupport(builder, t.DcSupport) + DcSlaveConfigInfoResponseAddDcReferenceClock(builder, t.DcReferenceClock) + DcSlaveConfigInfoResponseAddCycleTime0(builder, t.CycleTime0) + DcSlaveConfigInfoResponseAddCycleTime1(builder, t.CycleTime1) + DcSlaveConfigInfoResponseAddShiftTime(builder, t.ShiftTime) + return DcSlaveConfigInfoResponseEnd(builder) +} + +func (rcv *DcSlaveConfigInfoResponse) UnPackTo(t *DcSlaveConfigInfoResponseT) { + t.DcSupport = rcv.DcSupport() + t.DcReferenceClock = rcv.DcReferenceClock() + t.CycleTime0 = rcv.CycleTime0() + t.CycleTime1 = rcv.CycleTime1() + t.ShiftTime = rcv.ShiftTime() +} + +func (rcv *DcSlaveConfigInfoResponse) UnPack() *DcSlaveConfigInfoResponseT { + if rcv == nil { return nil } + t := &DcSlaveConfigInfoResponseT{} + rcv.UnPackTo(t) + return t +} + +type DcSlaveConfigInfoResponse struct { + _tab flatbuffers.Table +} + +func GetRootAsDcSlaveConfigInfoResponse(buf []byte, offset flatbuffers.UOffsetT) *DcSlaveConfigInfoResponse { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &DcSlaveConfigInfoResponse{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsDcSlaveConfigInfoResponse(buf []byte, offset flatbuffers.UOffsetT) *DcSlaveConfigInfoResponse { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &DcSlaveConfigInfoResponse{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *DcSlaveConfigInfoResponse) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *DcSlaveConfigInfoResponse) Table() flatbuffers.Table { + return rcv._tab +} + +///Slave supports DC (Distributed Clock) +func (rcv *DcSlaveConfigInfoResponse) DcSupport() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +///Slave supports DC (Distributed Clock) +func (rcv *DcSlaveConfigInfoResponse) MutateDcSupport(n bool) bool { + return rcv._tab.MutateBoolSlot(4, n) +} + +///Slave is reference clock +func (rcv *DcSlaveConfigInfoResponse) DcReferenceClock() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +///Slave is reference clock +func (rcv *DcSlaveConfigInfoResponse) MutateDcReferenceClock(n bool) bool { + return rcv._tab.MutateBoolSlot(6, n) +} + +///Cycle time of Sync0 event (as defined in ETG.2100) in nanoseconds +func (rcv *DcSlaveConfigInfoResponse) CycleTime0() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +///Cycle time of Sync0 event (as defined in ETG.2100) in nanoseconds +func (rcv *DcSlaveConfigInfoResponse) MutateCycleTime0(n uint32) bool { + return rcv._tab.MutateUint32Slot(8, n) +} + +///Cycle time of Sync1 (calculated value as defined in ETG.2100) event in nanoseconds +func (rcv *DcSlaveConfigInfoResponse) CycleTime1() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +///Cycle time of Sync1 (calculated value as defined in ETG.2100) event in nanoseconds +func (rcv *DcSlaveConfigInfoResponse) MutateCycleTime1(n uint32) bool { + return rcv._tab.MutateUint32Slot(10, n) +} + +///Shift time of Sync 0 event (as defined in ETG.2100) in nanoseconds +func (rcv *DcSlaveConfigInfoResponse) ShiftTime() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return 0 +} + +///Shift time of Sync 0 event (as defined in ETG.2100) in nanoseconds +func (rcv *DcSlaveConfigInfoResponse) MutateShiftTime(n int32) bool { + return rcv._tab.MutateInt32Slot(12, n) +} + +func DcSlaveConfigInfoResponseStart(builder *flatbuffers.Builder) { + builder.StartObject(5) +} +func DcSlaveConfigInfoResponseAddDcSupport(builder *flatbuffers.Builder, dcSupport bool) { + builder.PrependBoolSlot(0, dcSupport, false) +} +func DcSlaveConfigInfoResponseAddDcReferenceClock(builder *flatbuffers.Builder, dcReferenceClock bool) { + builder.PrependBoolSlot(1, dcReferenceClock, false) +} +func DcSlaveConfigInfoResponseAddCycleTime0(builder *flatbuffers.Builder, cycleTime0 uint32) { + builder.PrependUint32Slot(2, cycleTime0, 0) +} +func DcSlaveConfigInfoResponseAddCycleTime1(builder *flatbuffers.Builder, cycleTime1 uint32) { + builder.PrependUint32Slot(3, cycleTime1, 0) +} +func DcSlaveConfigInfoResponseAddShiftTime(builder *flatbuffers.Builder, shiftTime int32) { + builder.PrependInt32Slot(4, shiftTime, 0) +} +func DcSlaveConfigInfoResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/DcSlaveOnlineInfo.go b/pkg/fbs/comm/ethercat/master/fbs/DcSlaveOnlineInfo.go new file mode 100644 index 0000000..82f520c --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/DcSlaveOnlineInfo.go @@ -0,0 +1,101 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +///This node delivers slave info data of a configured slave from the EtherCAT Master +type DcSlaveOnlineInfoT struct { + Request *AddressedRequestT `json:"request"` + Response *DcSlaveOnlineInfoResponseT `json:"response"` +} + +func (t *DcSlaveOnlineInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + requestOffset := t.Request.Pack(builder) + responseOffset := t.Response.Pack(builder) + DcSlaveOnlineInfoStart(builder) + DcSlaveOnlineInfoAddRequest(builder, requestOffset) + DcSlaveOnlineInfoAddResponse(builder, responseOffset) + return DcSlaveOnlineInfoEnd(builder) +} + +func (rcv *DcSlaveOnlineInfo) UnPackTo(t *DcSlaveOnlineInfoT) { + t.Request = rcv.Request(nil).UnPack() + t.Response = rcv.Response(nil).UnPack() +} + +func (rcv *DcSlaveOnlineInfo) UnPack() *DcSlaveOnlineInfoT { + if rcv == nil { return nil } + t := &DcSlaveOnlineInfoT{} + rcv.UnPackTo(t) + return t +} + +type DcSlaveOnlineInfo struct { + _tab flatbuffers.Table +} + +func GetRootAsDcSlaveOnlineInfo(buf []byte, offset flatbuffers.UOffsetT) *DcSlaveOnlineInfo { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &DcSlaveOnlineInfo{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsDcSlaveOnlineInfo(buf []byte, offset flatbuffers.UOffsetT) *DcSlaveOnlineInfo { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &DcSlaveOnlineInfo{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *DcSlaveOnlineInfo) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *DcSlaveOnlineInfo) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *DcSlaveOnlineInfo) Request(obj *AddressedRequest) *AddressedRequest { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(AddressedRequest) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *DcSlaveOnlineInfo) Response(obj *DcSlaveOnlineInfoResponse) *DcSlaveOnlineInfoResponse { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(DcSlaveOnlineInfoResponse) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func DcSlaveOnlineInfoStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func DcSlaveOnlineInfoAddRequest(builder *flatbuffers.Builder, request flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(request), 0) +} +func DcSlaveOnlineInfoAddResponse(builder *flatbuffers.Builder, response flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(response), 0) +} +func DcSlaveOnlineInfoEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/DcSlaveOnlineInfoResponse.go b/pkg/fbs/comm/ethercat/master/fbs/DcSlaveOnlineInfoResponse.go new file mode 100644 index 0000000..2f3a706 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/DcSlaveOnlineInfoResponse.go @@ -0,0 +1,241 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +///DC slave configuration response +type DcSlaveOnlineInfoResponseT struct { + DcSupport bool `json:"dcSupport"` + Dc64Support bool `json:"dc64Support"` + DcReferenceClock bool `json:"dcReferenceClock"` + CycleTime0 uint32 `json:"CycleTime0"` + CycleTime1 uint32 `json:"CycleTime1"` + ShiftTime int32 `json:"ShiftTime"` + SystemTimeDifference uint32 `json:"systemTimeDifference"` + SlaveDelay uint32 `json:"slaveDelay"` + PropagationDelay uint32 `json:"propagationDelay"` +} + +func (t *DcSlaveOnlineInfoResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + DcSlaveOnlineInfoResponseStart(builder) + DcSlaveOnlineInfoResponseAddDcSupport(builder, t.DcSupport) + DcSlaveOnlineInfoResponseAddDc64Support(builder, t.Dc64Support) + DcSlaveOnlineInfoResponseAddDcReferenceClock(builder, t.DcReferenceClock) + DcSlaveOnlineInfoResponseAddCycleTime0(builder, t.CycleTime0) + DcSlaveOnlineInfoResponseAddCycleTime1(builder, t.CycleTime1) + DcSlaveOnlineInfoResponseAddShiftTime(builder, t.ShiftTime) + DcSlaveOnlineInfoResponseAddSystemTimeDifference(builder, t.SystemTimeDifference) + DcSlaveOnlineInfoResponseAddSlaveDelay(builder, t.SlaveDelay) + DcSlaveOnlineInfoResponseAddPropagationDelay(builder, t.PropagationDelay) + return DcSlaveOnlineInfoResponseEnd(builder) +} + +func (rcv *DcSlaveOnlineInfoResponse) UnPackTo(t *DcSlaveOnlineInfoResponseT) { + t.DcSupport = rcv.DcSupport() + t.Dc64Support = rcv.Dc64Support() + t.DcReferenceClock = rcv.DcReferenceClock() + t.CycleTime0 = rcv.CycleTime0() + t.CycleTime1 = rcv.CycleTime1() + t.ShiftTime = rcv.ShiftTime() + t.SystemTimeDifference = rcv.SystemTimeDifference() + t.SlaveDelay = rcv.SlaveDelay() + t.PropagationDelay = rcv.PropagationDelay() +} + +func (rcv *DcSlaveOnlineInfoResponse) UnPack() *DcSlaveOnlineInfoResponseT { + if rcv == nil { return nil } + t := &DcSlaveOnlineInfoResponseT{} + rcv.UnPackTo(t) + return t +} + +type DcSlaveOnlineInfoResponse struct { + _tab flatbuffers.Table +} + +func GetRootAsDcSlaveOnlineInfoResponse(buf []byte, offset flatbuffers.UOffsetT) *DcSlaveOnlineInfoResponse { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &DcSlaveOnlineInfoResponse{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsDcSlaveOnlineInfoResponse(buf []byte, offset flatbuffers.UOffsetT) *DcSlaveOnlineInfoResponse { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &DcSlaveOnlineInfoResponse{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *DcSlaveOnlineInfoResponse) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *DcSlaveOnlineInfoResponse) Table() flatbuffers.Table { + return rcv._tab +} + +///Slave supports DC (Distributed Clock) +func (rcv *DcSlaveOnlineInfoResponse) DcSupport() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +///Slave supports DC (Distributed Clock) +func (rcv *DcSlaveOnlineInfoResponse) MutateDcSupport(n bool) bool { + return rcv._tab.MutateBoolSlot(4, n) +} + +///Slave supports 64 bit DC +func (rcv *DcSlaveOnlineInfoResponse) Dc64Support() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +///Slave supports 64 bit DC +func (rcv *DcSlaveOnlineInfoResponse) MutateDc64Support(n bool) bool { + return rcv._tab.MutateBoolSlot(6, n) +} + +///Slave is reference clock +func (rcv *DcSlaveOnlineInfoResponse) DcReferenceClock() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +///Slave is reference clock +func (rcv *DcSlaveOnlineInfoResponse) MutateDcReferenceClock(n bool) bool { + return rcv._tab.MutateBoolSlot(8, n) +} + +///Cycle time of Sync0 event (as defined in ETG.2100) in nanoseconds +func (rcv *DcSlaveOnlineInfoResponse) CycleTime0() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +///Cycle time of Sync0 event (as defined in ETG.2100) in nanoseconds +func (rcv *DcSlaveOnlineInfoResponse) MutateCycleTime0(n uint32) bool { + return rcv._tab.MutateUint32Slot(10, n) +} + +///Cycle time of Sync1 (calculated value as defined in ETG.2100) event in nanoseconds +func (rcv *DcSlaveOnlineInfoResponse) CycleTime1() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +///Cycle time of Sync1 (calculated value as defined in ETG.2100) event in nanoseconds +func (rcv *DcSlaveOnlineInfoResponse) MutateCycleTime1(n uint32) bool { + return rcv._tab.MutateUint32Slot(12, n) +} + +///Shift time of Sync 0 event (as defined in ETG.2100) in nanoseconds +func (rcv *DcSlaveOnlineInfoResponse) ShiftTime() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return 0 +} + +///Shift time of Sync 0 event (as defined in ETG.2100) in nanoseconds +func (rcv *DcSlaveOnlineInfoResponse) MutateShiftTime(n int32) bool { + return rcv._tab.MutateInt32Slot(14, n) +} + +///System time difference in nanoseconds (only if DC is configured) (ESC register 0x092C) +func (rcv *DcSlaveOnlineInfoResponse) SystemTimeDifference() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +///System time difference in nanoseconds (only if DC is configured) (ESC register 0x092C) +func (rcv *DcSlaveOnlineInfoResponse) MutateSystemTimeDifference(n uint32) bool { + return rcv._tab.MutateUint32Slot(16, n) +} + +///Time delay "behind" slave in nanoseconds (only if DC is configured) +func (rcv *DcSlaveOnlineInfoResponse) SlaveDelay() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(18)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +///Time delay "behind" slave in nanoseconds (only if DC is configured) +func (rcv *DcSlaveOnlineInfoResponse) MutateSlaveDelay(n uint32) bool { + return rcv._tab.MutateUint32Slot(18, n) +} + +///Propagation delay in nanoseconds (only if DC is configured) (ESC register 0x0928) +func (rcv *DcSlaveOnlineInfoResponse) PropagationDelay() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(20)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +///Propagation delay in nanoseconds (only if DC is configured) (ESC register 0x0928) +func (rcv *DcSlaveOnlineInfoResponse) MutatePropagationDelay(n uint32) bool { + return rcv._tab.MutateUint32Slot(20, n) +} + +func DcSlaveOnlineInfoResponseStart(builder *flatbuffers.Builder) { + builder.StartObject(9) +} +func DcSlaveOnlineInfoResponseAddDcSupport(builder *flatbuffers.Builder, dcSupport bool) { + builder.PrependBoolSlot(0, dcSupport, false) +} +func DcSlaveOnlineInfoResponseAddDc64Support(builder *flatbuffers.Builder, dc64Support bool) { + builder.PrependBoolSlot(1, dc64Support, false) +} +func DcSlaveOnlineInfoResponseAddDcReferenceClock(builder *flatbuffers.Builder, dcReferenceClock bool) { + builder.PrependBoolSlot(2, dcReferenceClock, false) +} +func DcSlaveOnlineInfoResponseAddCycleTime0(builder *flatbuffers.Builder, cycleTime0 uint32) { + builder.PrependUint32Slot(3, cycleTime0, 0) +} +func DcSlaveOnlineInfoResponseAddCycleTime1(builder *flatbuffers.Builder, cycleTime1 uint32) { + builder.PrependUint32Slot(4, cycleTime1, 0) +} +func DcSlaveOnlineInfoResponseAddShiftTime(builder *flatbuffers.Builder, shiftTime int32) { + builder.PrependInt32Slot(5, shiftTime, 0) +} +func DcSlaveOnlineInfoResponseAddSystemTimeDifference(builder *flatbuffers.Builder, systemTimeDifference uint32) { + builder.PrependUint32Slot(6, systemTimeDifference, 0) +} +func DcSlaveOnlineInfoResponseAddSlaveDelay(builder *flatbuffers.Builder, slaveDelay uint32) { + builder.PrependUint32Slot(7, slaveDelay, 0) +} +func DcSlaveOnlineInfoResponseAddPropagationDelay(builder *flatbuffers.Builder, propagationDelay uint32) { + builder.PrependUint32Slot(8, propagationDelay, 0) +} +func DcSlaveOnlineInfoResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/SlaveConfigInfoResponse.go b/pkg/fbs/comm/ethercat/master/fbs/SlaveConfigInfoResponse.go index c1b29f2..af8476a 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/SlaveConfigInfoResponse.go +++ b/pkg/fbs/comm/ethercat/master/fbs/SlaveConfigInfoResponse.go @@ -33,6 +33,16 @@ type SlaveConfigInfoResponseT struct { IsPresent bool `json:"isPresent"` IsHcGroupPresent bool `json:"isHcGroupPresent"` DcSupport bool `json:"dcSupport"` + IsDisabled bool `json:"isDisabled"` + IsDisconnected bool `json:"isDisconnected"` + IsExtended bool `json:"isExtended"` + IsRefClock bool `json:"isRefClock"` + IsPotentialRefClock bool `json:"isPotentialRefClock"` + DcCycleTime0 uint32 `json:"dcCycleTime0"` + DcCycleTime1 uint32 `json:"dcCycleTime1"` + DcShiftTime int32 `json:"dcShiftTime"` + MasterSyncUnitIn []uint16 `json:"masterSyncUnitIn"` + MasterSyncUnitOut []uint16 `json:"masterSyncUnitOut"` } func (t *SlaveConfigInfoResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { @@ -90,6 +100,24 @@ func (t *SlaveConfigInfoResponseT) Pack(builder *flatbuffers.Builder) flatbuffer } reserved02Offset = builder.EndVector(reserved02Length) } + masterSyncUnitInOffset := flatbuffers.UOffsetT(0) + if t.MasterSyncUnitIn != nil { + masterSyncUnitInLength := len(t.MasterSyncUnitIn) + SlaveConfigInfoResponseStartMasterSyncUnitInVector(builder, masterSyncUnitInLength) + for j := masterSyncUnitInLength - 1; j >= 0; j-- { + builder.PrependUint16(t.MasterSyncUnitIn[j]) + } + masterSyncUnitInOffset = builder.EndVector(masterSyncUnitInLength) + } + masterSyncUnitOutOffset := flatbuffers.UOffsetT(0) + if t.MasterSyncUnitOut != nil { + masterSyncUnitOutLength := len(t.MasterSyncUnitOut) + SlaveConfigInfoResponseStartMasterSyncUnitOutVector(builder, masterSyncUnitOutLength) + for j := masterSyncUnitOutLength - 1; j >= 0; j-- { + builder.PrependUint16(t.MasterSyncUnitOut[j]) + } + masterSyncUnitOutOffset = builder.EndVector(masterSyncUnitOutLength) + } SlaveConfigInfoResponseStart(builder) SlaveConfigInfoResponseAddAutoIncAddr(builder, t.AutoIncAddr) SlaveConfigInfoResponseAddEthercatAddr(builder, t.EthercatAddr) @@ -119,6 +147,16 @@ func (t *SlaveConfigInfoResponseT) Pack(builder *flatbuffers.Builder) flatbuffer SlaveConfigInfoResponseAddIsPresent(builder, t.IsPresent) SlaveConfigInfoResponseAddIsHcGroupPresent(builder, t.IsHcGroupPresent) SlaveConfigInfoResponseAddDcSupport(builder, t.DcSupport) + SlaveConfigInfoResponseAddIsDisabled(builder, t.IsDisabled) + SlaveConfigInfoResponseAddIsDisconnected(builder, t.IsDisconnected) + SlaveConfigInfoResponseAddIsExtended(builder, t.IsExtended) + SlaveConfigInfoResponseAddIsRefClock(builder, t.IsRefClock) + SlaveConfigInfoResponseAddIsPotentialRefClock(builder, t.IsPotentialRefClock) + SlaveConfigInfoResponseAddDcCycleTime0(builder, t.DcCycleTime0) + SlaveConfigInfoResponseAddDcCycleTime1(builder, t.DcCycleTime1) + SlaveConfigInfoResponseAddDcShiftTime(builder, t.DcShiftTime) + SlaveConfigInfoResponseAddMasterSyncUnitIn(builder, masterSyncUnitInOffset) + SlaveConfigInfoResponseAddMasterSyncUnitOut(builder, masterSyncUnitOutOffset) return SlaveConfigInfoResponseEnd(builder) } @@ -172,6 +210,24 @@ func (rcv *SlaveConfigInfoResponse) UnPackTo(t *SlaveConfigInfoResponseT) { t.IsPresent = rcv.IsPresent() t.IsHcGroupPresent = rcv.IsHcGroupPresent() t.DcSupport = rcv.DcSupport() + t.IsDisabled = rcv.IsDisabled() + t.IsDisconnected = rcv.IsDisconnected() + t.IsExtended = rcv.IsExtended() + t.IsRefClock = rcv.IsRefClock() + t.IsPotentialRefClock = rcv.IsPotentialRefClock() + t.DcCycleTime0 = rcv.DcCycleTime0() + t.DcCycleTime1 = rcv.DcCycleTime1() + t.DcShiftTime = rcv.DcShiftTime() + masterSyncUnitInLength := rcv.MasterSyncUnitInLength() + t.MasterSyncUnitIn = make([]uint16, masterSyncUnitInLength) + for j := 0; j < masterSyncUnitInLength; j++ { + t.MasterSyncUnitIn[j] = rcv.MasterSyncUnitIn(j) + } + masterSyncUnitOutLength := rcv.MasterSyncUnitOutLength() + t.MasterSyncUnitOut = make([]uint16, masterSyncUnitOutLength) + for j := 0; j < masterSyncUnitOutLength; j++ { + t.MasterSyncUnitOut[j] = rcv.MasterSyncUnitOut(j) + } } func (rcv *SlaveConfigInfoResponse) UnPack() *SlaveConfigInfoResponseT { @@ -653,8 +709,176 @@ func (rcv *SlaveConfigInfoResponse) MutateDcSupport(n bool) bool { return rcv._tab.MutateBoolSlot(52, n) } +///Slave disabled by API +func (rcv *SlaveConfigInfoResponse) IsDisabled() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(54)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +///Slave disabled by API +func (rcv *SlaveConfigInfoResponse) MutateIsDisabled(n bool) bool { + return rcv._tab.MutateBoolSlot(54, n) +} + +///Slave disconnected by API +func (rcv *SlaveConfigInfoResponse) IsDisconnected() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(56)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +///Slave disconnected by API +func (rcv *SlaveConfigInfoResponse) MutateIsDisconnected(n bool) bool { + return rcv._tab.MutateBoolSlot(56, n) +} + +///Slave generated by config extension API +func (rcv *SlaveConfigInfoResponse) IsExtended() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(58)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +///Slave generated by config extension API +func (rcv *SlaveConfigInfoResponse) MutateIsExtended(n bool) bool { + return rcv._tab.MutateBoolSlot(58, n) +} + +///Slave is reference clock +func (rcv *SlaveConfigInfoResponse) IsRefClock() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(60)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +///Slave is reference clock +func (rcv *SlaveConfigInfoResponse) MutateIsRefClock(n bool) bool { + return rcv._tab.MutateBoolSlot(60, n) +} + +///Slave can be used as a reference clock +func (rcv *SlaveConfigInfoResponse) IsPotentialRefClock() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(62)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +///Slave can be used as a reference clock +func (rcv *SlaveConfigInfoResponse) MutateIsPotentialRefClock(n bool) bool { + return rcv._tab.MutateBoolSlot(62, n) +} + +///Cycle time of Sync0 event in unit of ns +func (rcv *SlaveConfigInfoResponse) DcCycleTime0() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(64)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +///Cycle time of Sync0 event in unit of ns +func (rcv *SlaveConfigInfoResponse) MutateDcCycleTime0(n uint32) bool { + return rcv._tab.MutateUint32Slot(64, n) +} + +///Calculated value dwDcCycleTime1 (in unit of ns) = Cycle time of Sync1 event - Cycle time of Sync1 event +Shift time of Sync0 event +func (rcv *SlaveConfigInfoResponse) DcCycleTime1() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(66)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +///Calculated value dwDcCycleTime1 (in unit of ns) = Cycle time of Sync1 event - Cycle time of Sync1 event +Shift time of Sync0 event +func (rcv *SlaveConfigInfoResponse) MutateDcCycleTime1(n uint32) bool { + return rcv._tab.MutateUint32Slot(66, n) +} + +///Shift time of Sync0 event in unit of ns +func (rcv *SlaveConfigInfoResponse) DcShiftTime() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(68)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return 0 +} + +///Shift time of Sync0 event in unit of ns +func (rcv *SlaveConfigInfoResponse) MutateDcShiftTime(n int32) bool { + return rcv._tab.MutateInt32Slot(68, n) +} + +///SyncUnits for process data inputs +func (rcv *SlaveConfigInfoResponse) MasterSyncUnitIn(j int) uint16 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(70)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.GetUint16(a + flatbuffers.UOffsetT(j*2)) + } + return 0 +} + +func (rcv *SlaveConfigInfoResponse) MasterSyncUnitInLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(70)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +///SyncUnits for process data inputs +func (rcv *SlaveConfigInfoResponse) MutateMasterSyncUnitIn(j int, n uint16) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(70)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.MutateUint16(a+flatbuffers.UOffsetT(j*2), n) + } + return false +} + +///SyncUnits for process data outputs +func (rcv *SlaveConfigInfoResponse) MasterSyncUnitOut(j int) uint16 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(72)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.GetUint16(a + flatbuffers.UOffsetT(j*2)) + } + return 0 +} + +func (rcv *SlaveConfigInfoResponse) MasterSyncUnitOutLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(72)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +///SyncUnits for process data outputs +func (rcv *SlaveConfigInfoResponse) MutateMasterSyncUnitOut(j int, n uint16) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(72)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.MutateUint16(a+flatbuffers.UOffsetT(j*2), n) + } + return false +} + func SlaveConfigInfoResponseStart(builder *flatbuffers.Builder) { - builder.StartObject(25) + builder.StartObject(35) } func SlaveConfigInfoResponseAddAutoIncAddr(builder *flatbuffers.Builder, autoIncAddr uint16) { builder.PrependUint16Slot(0, autoIncAddr, 0) @@ -749,6 +973,42 @@ func SlaveConfigInfoResponseAddIsHcGroupPresent(builder *flatbuffers.Builder, is func SlaveConfigInfoResponseAddDcSupport(builder *flatbuffers.Builder, dcSupport bool) { builder.PrependBoolSlot(24, dcSupport, false) } +func SlaveConfigInfoResponseAddIsDisabled(builder *flatbuffers.Builder, isDisabled bool) { + builder.PrependBoolSlot(25, isDisabled, false) +} +func SlaveConfigInfoResponseAddIsDisconnected(builder *flatbuffers.Builder, isDisconnected bool) { + builder.PrependBoolSlot(26, isDisconnected, false) +} +func SlaveConfigInfoResponseAddIsExtended(builder *flatbuffers.Builder, isExtended bool) { + builder.PrependBoolSlot(27, isExtended, false) +} +func SlaveConfigInfoResponseAddIsRefClock(builder *flatbuffers.Builder, isRefClock bool) { + builder.PrependBoolSlot(28, isRefClock, false) +} +func SlaveConfigInfoResponseAddIsPotentialRefClock(builder *flatbuffers.Builder, isPotentialRefClock bool) { + builder.PrependBoolSlot(29, isPotentialRefClock, false) +} +func SlaveConfigInfoResponseAddDcCycleTime0(builder *flatbuffers.Builder, dcCycleTime0 uint32) { + builder.PrependUint32Slot(30, dcCycleTime0, 0) +} +func SlaveConfigInfoResponseAddDcCycleTime1(builder *flatbuffers.Builder, dcCycleTime1 uint32) { + builder.PrependUint32Slot(31, dcCycleTime1, 0) +} +func SlaveConfigInfoResponseAddDcShiftTime(builder *flatbuffers.Builder, dcShiftTime int32) { + builder.PrependInt32Slot(32, dcShiftTime, 0) +} +func SlaveConfigInfoResponseAddMasterSyncUnitIn(builder *flatbuffers.Builder, masterSyncUnitIn flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(33, flatbuffers.UOffsetT(masterSyncUnitIn), 0) +} +func SlaveConfigInfoResponseStartMasterSyncUnitInVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(2, numElems, 2) +} +func SlaveConfigInfoResponseAddMasterSyncUnitOut(builder *flatbuffers.Builder, masterSyncUnitOut flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(34, flatbuffers.UOffsetT(masterSyncUnitOut), 0) +} +func SlaveConfigInfoResponseStartMasterSyncUnitOutVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(2, numElems, 2) +} func SlaveConfigInfoResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/pkg/fbs/comm/ethercat/master/fbs/SlaveOnlineInfoResponse.go b/pkg/fbs/comm/ethercat/master/fbs/SlaveOnlineInfoResponse.go index ab6e23e..d67aff1 100644 --- a/pkg/fbs/comm/ethercat/master/fbs/SlaveOnlineInfoResponse.go +++ b/pkg/fbs/comm/ethercat/master/fbs/SlaveOnlineInfoResponse.go @@ -35,6 +35,11 @@ type SlaveOnlineInfoResponseT struct { Dc64Support bool `json:"dc64Support"` IsRefClock bool `json:"isRefClock"` LineCrossed bool `json:"lineCrossed"` + LineCrossedFlags uint32 `json:"lineCrossedFlags"` + CyclicWkcErrorCnt uint32 `json:"cyclicWkcErrorCnt"` + SlaveAbsentCnt uint32 `json:"slaveAbsentCnt"` + UnexpectedAbsentCnt uint32 `json:"unexpectedAbsentCnt"` + IsDeviceEmulation bool `json:"isDeviceEmulation"` } func (t *SlaveOnlineInfoResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { @@ -86,6 +91,11 @@ func (t *SlaveOnlineInfoResponseT) Pack(builder *flatbuffers.Builder) flatbuffer SlaveOnlineInfoResponseAddDc64Support(builder, t.Dc64Support) SlaveOnlineInfoResponseAddIsRefClock(builder, t.IsRefClock) SlaveOnlineInfoResponseAddLineCrossed(builder, t.LineCrossed) + SlaveOnlineInfoResponseAddLineCrossedFlags(builder, t.LineCrossedFlags) + SlaveOnlineInfoResponseAddCyclicWkcErrorCnt(builder, t.CyclicWkcErrorCnt) + SlaveOnlineInfoResponseAddSlaveAbsentCnt(builder, t.SlaveAbsentCnt) + SlaveOnlineInfoResponseAddUnexpectedAbsentCnt(builder, t.UnexpectedAbsentCnt) + SlaveOnlineInfoResponseAddIsDeviceEmulation(builder, t.IsDeviceEmulation) return SlaveOnlineInfoResponseEnd(builder) } @@ -125,6 +135,11 @@ func (rcv *SlaveOnlineInfoResponse) UnPackTo(t *SlaveOnlineInfoResponseT) { t.Dc64Support = rcv.Dc64Support() t.IsRefClock = rcv.IsRefClock() t.LineCrossed = rcv.LineCrossed() + t.LineCrossedFlags = rcv.LineCrossedFlags() + t.CyclicWkcErrorCnt = rcv.CyclicWkcErrorCnt() + t.SlaveAbsentCnt = rcv.SlaveAbsentCnt() + t.UnexpectedAbsentCnt = rcv.UnexpectedAbsentCnt() + t.IsDeviceEmulation = rcv.IsDeviceEmulation() } func (rcv *SlaveOnlineInfoResponse) UnPack() *SlaveOnlineInfoResponseT { @@ -582,8 +597,94 @@ func (rcv *SlaveOnlineInfoResponse) MutateLineCrossed(n bool) bool { return rcv._tab.MutateBoolSlot(56, n) } +///Line crossed flags indicate in which way(s) lines have been crossed +///Bit 0:Not connected port A +///Bit 1:Unexpected input port +///Bit 2:Unexpected junction port +///Bit 3:Unresolved port connection +///Bit 4:Hidden slave connected +///Bit 5:Physic mismatch +///Bit 6:Invalid port connection +///Bit 7 to 31:Reserved +func (rcv *SlaveOnlineInfoResponse) LineCrossedFlags() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(58)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +///Line crossed flags indicate in which way(s) lines have been crossed +///Bit 0:Not connected port A +///Bit 1:Unexpected input port +///Bit 2:Unexpected junction port +///Bit 3:Unresolved port connection +///Bit 4:Hidden slave connected +///Bit 5:Physic mismatch +///Bit 6:Invalid port connection +///Bit 7 to 31:Reserved +func (rcv *SlaveOnlineInfoResponse) MutateLineCrossedFlags(n uint32) bool { + return rcv._tab.MutateUint32Slot(58, n) +} + +///Counter for Cyclic WKC Errors (over all pd sections) +func (rcv *SlaveOnlineInfoResponse) CyclicWkcErrorCnt() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(60)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +///Counter for Cyclic WKC Errors (over all pd sections) +func (rcv *SlaveOnlineInfoResponse) MutateCyclicWkcErrorCnt(n uint32) bool { + return rcv._tab.MutateUint32Slot(60, n) +} + +///Counter for Absent/Not Present Slaves +func (rcv *SlaveOnlineInfoResponse) SlaveAbsentCnt() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(62)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +///Counter for Absent/Not Present Slaves +func (rcv *SlaveOnlineInfoResponse) MutateSlaveAbsentCnt(n uint32) bool { + return rcv._tab.MutateUint32Slot(62, n) +} + +///Counter for Abnormal State Change +func (rcv *SlaveOnlineInfoResponse) UnexpectedAbsentCnt() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(64)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +///Counter for Abnormal State Change +func (rcv *SlaveOnlineInfoResponse) MutateUnexpectedAbsentCnt(n uint32) bool { + return rcv._tab.MutateUint32Slot(64, n) +} + +///Slave without Firmware. ESC register 0x0141, enabled by EEPROM offset 0x0000.8 +func (rcv *SlaveOnlineInfoResponse) IsDeviceEmulation() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(66)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +///Slave without Firmware. ESC register 0x0141, enabled by EEPROM offset 0x0000.8 +func (rcv *SlaveOnlineInfoResponse) MutateIsDeviceEmulation(n bool) bool { + return rcv._tab.MutateBoolSlot(66, n) +} + func SlaveOnlineInfoResponseStart(builder *flatbuffers.Builder) { - builder.StartObject(27) + builder.StartObject(32) } func SlaveOnlineInfoResponseAddAutoIncAddr(builder *flatbuffers.Builder, autoIncAddr uint16) { builder.PrependUint16Slot(0, autoIncAddr, 0) @@ -672,6 +773,21 @@ func SlaveOnlineInfoResponseAddIsRefClock(builder *flatbuffers.Builder, isRefClo func SlaveOnlineInfoResponseAddLineCrossed(builder *flatbuffers.Builder, lineCrossed bool) { builder.PrependBoolSlot(26, lineCrossed, false) } +func SlaveOnlineInfoResponseAddLineCrossedFlags(builder *flatbuffers.Builder, lineCrossedFlags uint32) { + builder.PrependUint32Slot(27, lineCrossedFlags, 0) +} +func SlaveOnlineInfoResponseAddCyclicWkcErrorCnt(builder *flatbuffers.Builder, cyclicWkcErrorCnt uint32) { + builder.PrependUint32Slot(28, cyclicWkcErrorCnt, 0) +} +func SlaveOnlineInfoResponseAddSlaveAbsentCnt(builder *flatbuffers.Builder, slaveAbsentCnt uint32) { + builder.PrependUint32Slot(29, slaveAbsentCnt, 0) +} +func SlaveOnlineInfoResponseAddUnexpectedAbsentCnt(builder *flatbuffers.Builder, unexpectedAbsentCnt uint32) { + builder.PrependUint32Slot(30, unexpectedAbsentCnt, 0) +} +func SlaveOnlineInfoResponseAddIsDeviceEmulation(builder *flatbuffers.Builder, isDeviceEmulation bool) { + builder.PrependBoolSlot(31, isDeviceEmulation, false) +} func SlaveOnlineInfoResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/pkg/fbs/comm/ethercat/master/fbs/TimeInfo.go b/pkg/fbs/comm/ethercat/master/fbs/TimeInfo.go new file mode 100644 index 0000000..f50a8f0 --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/TimeInfo.go @@ -0,0 +1,147 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +///Time info +type TimeInfoT struct { + Time uint64 `json:"time"` + LocalOffset int64 `json:"localOffset"` + DaylightSavingTime int32 `json:"daylightSavingTime"` + TimeZoneInfo *TimeZoneInfoT `json:"timeZoneInfo"` +} + +func (t *TimeInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + timeZoneInfoOffset := t.TimeZoneInfo.Pack(builder) + TimeInfoStart(builder) + TimeInfoAddTime(builder, t.Time) + TimeInfoAddLocalOffset(builder, t.LocalOffset) + TimeInfoAddDaylightSavingTime(builder, t.DaylightSavingTime) + TimeInfoAddTimeZoneInfo(builder, timeZoneInfoOffset) + return TimeInfoEnd(builder) +} + +func (rcv *TimeInfo) UnPackTo(t *TimeInfoT) { + t.Time = rcv.Time() + t.LocalOffset = rcv.LocalOffset() + t.DaylightSavingTime = rcv.DaylightSavingTime() + t.TimeZoneInfo = rcv.TimeZoneInfo(nil).UnPack() +} + +func (rcv *TimeInfo) UnPack() *TimeInfoT { + if rcv == nil { return nil } + t := &TimeInfoT{} + rcv.UnPackTo(t) + return t +} + +type TimeInfo struct { + _tab flatbuffers.Table +} + +func GetRootAsTimeInfo(buf []byte, offset flatbuffers.UOffsetT) *TimeInfo { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &TimeInfo{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsTimeInfo(buf []byte, offset flatbuffers.UOffsetT) *TimeInfo { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &TimeInfo{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *TimeInfo) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *TimeInfo) Table() flatbuffers.Table { + return rcv._tab +} + +///Time as coordinated universal time (UTC) since start of Unix epoche (1970-01-01) +func (rcv *TimeInfo) Time() uint64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetUint64(o + rcv._tab.Pos) + } + return 0 +} + +///Time as coordinated universal time (UTC) since start of Unix epoche (1970-01-01) +func (rcv *TimeInfo) MutateTime(n uint64) bool { + return rcv._tab.MutateUint64Slot(4, n) +} + +///Local offset (time zone offset and daylight saving time) between UTC and local time +func (rcv *TimeInfo) LocalOffset() int64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetInt64(o + rcv._tab.Pos) + } + return 0 +} + +///Local offset (time zone offset and daylight saving time) between UTC and local time +func (rcv *TimeInfo) MutateLocalOffset(n int64) bool { + return rcv._tab.MutateInt64Slot(6, n) +} + +///Indicates if localOffset includes daylight saving time +/// -1: information not available +/// 0: not included +/// 1: included +func (rcv *TimeInfo) DaylightSavingTime() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return -1 +} + +///Indicates if localOffset includes daylight saving time +/// -1: information not available +/// 0: not included +/// 1: included +func (rcv *TimeInfo) MutateDaylightSavingTime(n int32) bool { + return rcv._tab.MutateInt32Slot(8, n) +} + +func (rcv *TimeInfo) TimeZoneInfo(obj *TimeZoneInfo) *TimeZoneInfo { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(TimeZoneInfo) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func TimeInfoStart(builder *flatbuffers.Builder) { + builder.StartObject(4) +} +func TimeInfoAddTime(builder *flatbuffers.Builder, time uint64) { + builder.PrependUint64Slot(0, time, 0) +} +func TimeInfoAddLocalOffset(builder *flatbuffers.Builder, localOffset int64) { + builder.PrependInt64Slot(1, localOffset, 0) +} +func TimeInfoAddDaylightSavingTime(builder *flatbuffers.Builder, daylightSavingTime int32) { + builder.PrependInt32Slot(2, daylightSavingTime, -1) +} +func TimeInfoAddTimeZoneInfo(builder *flatbuffers.Builder, timeZoneInfo flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(timeZoneInfo), 0) +} +func TimeInfoEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/ethercat/master/fbs/TimeZoneInfo.go b/pkg/fbs/comm/ethercat/master/fbs/TimeZoneInfo.go new file mode 100644 index 0000000..1ac9a3a --- /dev/null +++ b/pkg/fbs/comm/ethercat/master/fbs/TimeZoneInfo.go @@ -0,0 +1,121 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +///Time zone info +type TimeZoneInfoT struct { + Offset int64 `json:"offset"` + Abbreviation string `json:"abbreviation"` + Name string `json:"name"` +} + +func (t *TimeZoneInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + abbreviationOffset := flatbuffers.UOffsetT(0) + if t.Abbreviation != "" { + abbreviationOffset = builder.CreateString(t.Abbreviation) + } + nameOffset := flatbuffers.UOffsetT(0) + if t.Name != "" { + nameOffset = builder.CreateString(t.Name) + } + TimeZoneInfoStart(builder) + TimeZoneInfoAddOffset(builder, t.Offset) + TimeZoneInfoAddAbbreviation(builder, abbreviationOffset) + TimeZoneInfoAddName(builder, nameOffset) + return TimeZoneInfoEnd(builder) +} + +func (rcv *TimeZoneInfo) UnPackTo(t *TimeZoneInfoT) { + t.Offset = rcv.Offset() + t.Abbreviation = string(rcv.Abbreviation()) + t.Name = string(rcv.Name()) +} + +func (rcv *TimeZoneInfo) UnPack() *TimeZoneInfoT { + if rcv == nil { return nil } + t := &TimeZoneInfoT{} + rcv.UnPackTo(t) + return t +} + +type TimeZoneInfo struct { + _tab flatbuffers.Table +} + +func GetRootAsTimeZoneInfo(buf []byte, offset flatbuffers.UOffsetT) *TimeZoneInfo { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &TimeZoneInfo{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsTimeZoneInfo(buf []byte, offset flatbuffers.UOffsetT) *TimeZoneInfo { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &TimeZoneInfo{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *TimeZoneInfo) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *TimeZoneInfo) Table() flatbuffers.Table { + return rcv._tab +} + +///Offset +func (rcv *TimeZoneInfo) Offset() int64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetInt64(o + rcv._tab.Pos) + } + return 0 +} + +///Offset +func (rcv *TimeZoneInfo) MutateOffset(n int64) bool { + return rcv._tab.MutateInt64Slot(4, n) +} + +///Abbreviation, e.g. UTC, CET, CEST, ... +func (rcv *TimeZoneInfo) Abbreviation() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +///Abbreviation, e.g. UTC, CET, CEST, ... +///Name, e.g. Europe/Berlin ... +func (rcv *TimeZoneInfo) Name() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +///Name, e.g. Europe/Berlin ... +func TimeZoneInfoStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func TimeZoneInfoAddOffset(builder *flatbuffers.Builder, offset int64) { + builder.PrependInt64Slot(0, offset, 0) +} +func TimeZoneInfoAddAbbreviation(builder *flatbuffers.Builder, abbreviation flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(abbreviation), 0) +} +func TimeZoneInfoAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(name), 0) +} +func TimeZoneInfoEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/comm/opcua/client/AddressPlaceholders.go b/pkg/fbs/comm/opcua/client/AddressPlaceholders.go index 34f09b5..caae4ba 100644 --- a/pkg/fbs/comm/opcua/client/AddressPlaceholders.go +++ b/pkg/fbs/comm/opcua/client/AddressPlaceholders.go @@ -10,6 +10,8 @@ type AddressPlaceholdersT struct { Ns string `json:"ns"` String string `json:"string"` Integer string `json:"integer"` + Guid string `json:"guid"` + Opaque string `json:"opaque"` } func (t *AddressPlaceholdersT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { @@ -26,10 +28,20 @@ func (t *AddressPlaceholdersT) Pack(builder *flatbuffers.Builder) flatbuffers.UO if t.Integer != "" { integerOffset = builder.CreateString(t.Integer) } + guidOffset := flatbuffers.UOffsetT(0) + if t.Guid != "" { + guidOffset = builder.CreateString(t.Guid) + } + opaqueOffset := flatbuffers.UOffsetT(0) + if t.Opaque != "" { + opaqueOffset = builder.CreateString(t.Opaque) + } AddressPlaceholdersStart(builder) AddressPlaceholdersAddNs(builder, nsOffset) AddressPlaceholdersAddString(builder, stringOffset) AddressPlaceholdersAddInteger(builder, integerOffset) + AddressPlaceholdersAddGuid(builder, guidOffset) + AddressPlaceholdersAddOpaque(builder, opaqueOffset) return AddressPlaceholdersEnd(builder) } @@ -37,6 +49,8 @@ func (rcv *AddressPlaceholders) UnPackTo(t *AddressPlaceholdersT) { t.Ns = string(rcv.Ns()) t.String = string(rcv.String()) t.Integer = string(rcv.Integer()) + t.Guid = string(rcv.Guid()) + t.Opaque = string(rcv.Opaque()) } func (rcv *AddressPlaceholders) UnPack() *AddressPlaceholdersT { @@ -103,8 +117,28 @@ func (rcv *AddressPlaceholders) Integer() []byte { } /// Placeholder for numeric identifiers +/// Placeholder for guid identifiers +func (rcv *AddressPlaceholders) Guid() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// Placeholder for guid identifiers +/// Placeholder for opaque identifiers +func (rcv *AddressPlaceholders) Opaque() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// Placeholder for opaque identifiers func AddressPlaceholdersStart(builder *flatbuffers.Builder) { - builder.StartObject(3) + builder.StartObject(5) } func AddressPlaceholdersAddNs(builder *flatbuffers.Builder, ns flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(ns), 0) @@ -115,6 +149,12 @@ func AddressPlaceholdersAddString(builder *flatbuffers.Builder, string flatbuffe func AddressPlaceholdersAddInteger(builder *flatbuffers.Builder, integer flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(integer), 0) } +func AddressPlaceholdersAddGuid(builder *flatbuffers.Builder, guid flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(guid), 0) +} +func AddressPlaceholdersAddOpaque(builder *flatbuffers.Builder, opaque flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(opaque), 0) +} func AddressPlaceholdersEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/pkg/fbs/comm/osci/fbtypes/OscilloscopeCfg.go b/pkg/fbs/comm/osci/fbtypes/OscilloscopeCfg.go index abe4d08..6a12b83 100644 --- a/pkg/fbs/comm/osci/fbtypes/OscilloscopeCfg.go +++ b/pkg/fbs/comm/osci/fbtypes/OscilloscopeCfg.go @@ -12,6 +12,7 @@ type OscilloscopeCfgT struct { Buffer *BufferCfgT `json:"buffer"` Trigger *TriggerCfgT `json:"trigger"` Diagramview []*DiagramCfgT `json:"diagramview"` + SignalType string `json:"signalType"` } func (t *OscilloscopeCfgT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { @@ -48,12 +49,17 @@ func (t *OscilloscopeCfgT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffse } diagramviewOffset = builder.EndVector(diagramviewLength) } + signalTypeOffset := flatbuffers.UOffsetT(0) + if t.SignalType != "" { + signalTypeOffset = builder.CreateString(t.SignalType) + } OscilloscopeCfgStart(builder) OscilloscopeCfgAddName(builder, nameOffset) OscilloscopeCfgAddChannels(builder, channelsOffset) OscilloscopeCfgAddBuffer(builder, bufferOffset) OscilloscopeCfgAddTrigger(builder, triggerOffset) OscilloscopeCfgAddDiagramview(builder, diagramviewOffset) + OscilloscopeCfgAddSignalType(builder, signalTypeOffset) return OscilloscopeCfgEnd(builder) } @@ -75,6 +81,7 @@ func (rcv *OscilloscopeCfg) UnPackTo(t *OscilloscopeCfgT) { rcv.Diagramview(&x, j) t.Diagramview[j] = x.UnPack() } + t.SignalType = string(rcv.SignalType()) } func (rcv *OscilloscopeCfg) UnPack() *OscilloscopeCfgT { @@ -185,8 +192,16 @@ func (rcv *OscilloscopeCfg) DiagramviewLength() int { return 0 } +func (rcv *OscilloscopeCfg) SignalType() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + func OscilloscopeCfgStart(builder *flatbuffers.Builder) { - builder.StartObject(5) + builder.StartObject(6) } func OscilloscopeCfgAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0) @@ -209,6 +224,9 @@ func OscilloscopeCfgAddDiagramview(builder *flatbuffers.Builder, diagramview fla func OscilloscopeCfgStartDiagramviewVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { return builder.StartVector(4, numElems, 4) } +func OscilloscopeCfgAddSignalType(builder *flatbuffers.Builder, signalType flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(signalType), 0) +} func OscilloscopeCfgEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/pkg/fbs/comm/osci/fbtypes/OscilloscopeStateEnum.go b/pkg/fbs/comm/osci/fbtypes/OscilloscopeStateEnum.go index d9ada29..52d4ad4 100644 --- a/pkg/fbs/comm/osci/fbtypes/OscilloscopeStateEnum.go +++ b/pkg/fbs/comm/osci/fbtypes/OscilloscopeStateEnum.go @@ -15,6 +15,7 @@ const ( OscilloscopeStateEnumRECORDING_COMPLETED OscilloscopeStateEnum = 5 OscilloscopeStateEnumRECORDING OscilloscopeStateEnum = 6 OscilloscopeStateEnumERROR OscilloscopeStateEnum = 7 + OscilloscopeStateEnumSAVEDATA OscilloscopeStateEnum = 8 ) var EnumNamesOscilloscopeStateEnum = map[OscilloscopeStateEnum]string{ @@ -26,6 +27,7 @@ var EnumNamesOscilloscopeStateEnum = map[OscilloscopeStateEnum]string{ OscilloscopeStateEnumRECORDING_COMPLETED: "RECORDING_COMPLETED", OscilloscopeStateEnumRECORDING: "RECORDING", OscilloscopeStateEnumERROR: "ERROR", + OscilloscopeStateEnumSAVEDATA: "SAVEDATA", } var EnumValuesOscilloscopeStateEnum = map[string]OscilloscopeStateEnum{ @@ -37,6 +39,7 @@ var EnumValuesOscilloscopeStateEnum = map[string]OscilloscopeStateEnum{ "RECORDING_COMPLETED": OscilloscopeStateEnumRECORDING_COMPLETED, "RECORDING": OscilloscopeStateEnumRECORDING, "ERROR": OscilloscopeStateEnumERROR, + "SAVEDATA": OscilloscopeStateEnumSAVEDATA, } func (v OscilloscopeStateEnum) String() string { diff --git a/pkg/fbs/comm/osci/fbtypes/TriggerCfg.go b/pkg/fbs/comm/osci/fbtypes/TriggerCfg.go index c80ecc4..cb29323 100644 --- a/pkg/fbs/comm/osci/fbtypes/TriggerCfg.go +++ b/pkg/fbs/comm/osci/fbtypes/TriggerCfg.go @@ -9,7 +9,7 @@ import ( type TriggerCfgT struct { TriggerType TriggerTypeEnumFb `json:"triggerType"` Name string `json:"name"` - Level float64 `json:"level"` + Level string `json:"level"` PreTrigger float64 `json:"preTrigger"` } @@ -19,10 +19,14 @@ func (t *TriggerCfgT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { if t.Name != "" { nameOffset = builder.CreateString(t.Name) } + levelOffset := flatbuffers.UOffsetT(0) + if t.Level != "" { + levelOffset = builder.CreateString(t.Level) + } TriggerCfgStart(builder) TriggerCfgAddTriggerType(builder, t.TriggerType) TriggerCfgAddName(builder, nameOffset) - TriggerCfgAddLevel(builder, t.Level) + TriggerCfgAddLevel(builder, levelOffset) TriggerCfgAddPreTrigger(builder, t.PreTrigger) return TriggerCfgEnd(builder) } @@ -30,7 +34,7 @@ func (t *TriggerCfgT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { func (rcv *TriggerCfg) UnPackTo(t *TriggerCfgT) { t.TriggerType = rcv.TriggerType() t.Name = string(rcv.Name()) - t.Level = rcv.Level() + t.Level = string(rcv.Level()) t.PreTrigger = rcv.PreTrigger() } @@ -88,16 +92,12 @@ func (rcv *TriggerCfg) Name() []byte { return nil } -func (rcv *TriggerCfg) Level() float64 { +func (rcv *TriggerCfg) Level() []byte { o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) if o != 0 { - return rcv._tab.GetFloat64(o + rcv._tab.Pos) + return rcv._tab.ByteVector(o + rcv._tab.Pos) } - return 0.0 -} - -func (rcv *TriggerCfg) MutateLevel(n float64) bool { - return rcv._tab.MutateFloat64Slot(8, n) + return nil } func (rcv *TriggerCfg) PreTrigger() float64 { @@ -121,8 +121,8 @@ func TriggerCfgAddTriggerType(builder *flatbuffers.Builder, triggerType TriggerT func TriggerCfgAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(name), 0) } -func TriggerCfgAddLevel(builder *flatbuffers.Builder, level float64) { - builder.PrependFloat64Slot(2, level, 0.0) +func TriggerCfgAddLevel(builder *flatbuffers.Builder, level flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(level), 0) } func TriggerCfgAddPreTrigger(builder *flatbuffers.Builder, preTrigger float64) { builder.PrependFloat64Slot(3, preTrigger, 0.0) diff --git a/pkg/fbs/common/oblivion/OblivionCurrent.go b/pkg/fbs/common/oblivion/OblivionCurrent.go deleted file mode 100644 index c4cf551..0000000 --- a/pkg/fbs/common/oblivion/OblivionCurrent.go +++ /dev/null @@ -1,114 +0,0 @@ -// Code generated by the FlatBuffers compiler. DO NOT EDIT. - -package oblivion - -import ( - flatbuffers "github.com/google/flatbuffers/go" -) - -type OblivionCurrentT struct { - Count uint32 `json:"count"` - Bytes uint32 `json:"bytes"` - Unobserved uint32 `json:"unobserved"` -} - -func (t *OblivionCurrentT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - if t == nil { return 0 } - OblivionCurrentStart(builder) - OblivionCurrentAddCount(builder, t.Count) - OblivionCurrentAddBytes(builder, t.Bytes) - OblivionCurrentAddUnobserved(builder, t.Unobserved) - return OblivionCurrentEnd(builder) -} - -func (rcv *OblivionCurrent) UnPackTo(t *OblivionCurrentT) { - t.Count = rcv.Count() - t.Bytes = rcv.Bytes() - t.Unobserved = rcv.Unobserved() -} - -func (rcv *OblivionCurrent) UnPack() *OblivionCurrentT { - if rcv == nil { return nil } - t := &OblivionCurrentT{} - rcv.UnPackTo(t) - return t -} - -type OblivionCurrent struct { - _tab flatbuffers.Table -} - -func GetRootAsOblivionCurrent(buf []byte, offset flatbuffers.UOffsetT) *OblivionCurrent { - n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &OblivionCurrent{} - x.Init(buf, n+offset) - return x -} - -func GetSizePrefixedRootAsOblivionCurrent(buf []byte, offset flatbuffers.UOffsetT) *OblivionCurrent { - n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &OblivionCurrent{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) - return x -} - -func (rcv *OblivionCurrent) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *OblivionCurrent) Table() flatbuffers.Table { - return rcv._tab -} - -func (rcv *OblivionCurrent) Count() uint32 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) - if o != 0 { - return rcv._tab.GetUint32(o + rcv._tab.Pos) - } - return 0 -} - -func (rcv *OblivionCurrent) MutateCount(n uint32) bool { - return rcv._tab.MutateUint32Slot(4, n) -} - -func (rcv *OblivionCurrent) Bytes() uint32 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) - if o != 0 { - return rcv._tab.GetUint32(o + rcv._tab.Pos) - } - return 0 -} - -func (rcv *OblivionCurrent) MutateBytes(n uint32) bool { - return rcv._tab.MutateUint32Slot(6, n) -} - -func (rcv *OblivionCurrent) Unobserved() uint32 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) - if o != 0 { - return rcv._tab.GetUint32(o + rcv._tab.Pos) - } - return 0 -} - -func (rcv *OblivionCurrent) MutateUnobserved(n uint32) bool { - return rcv._tab.MutateUint32Slot(8, n) -} - -func OblivionCurrentStart(builder *flatbuffers.Builder) { - builder.StartObject(3) -} -func OblivionCurrentAddCount(builder *flatbuffers.Builder, count uint32) { - builder.PrependUint32Slot(0, count, 0) -} -func OblivionCurrentAddBytes(builder *flatbuffers.Builder, bytes uint32) { - builder.PrependUint32Slot(1, bytes, 0) -} -func OblivionCurrentAddUnobserved(builder *flatbuffers.Builder, unobserved uint32) { - builder.PrependUint32Slot(2, unobserved, 0) -} -func OblivionCurrentEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - return builder.EndObject() -} diff --git a/pkg/fbs/common/oblivion/OblivionOverview.go b/pkg/fbs/common/oblivion/OblivionOverview.go deleted file mode 100644 index 1a4db48..0000000 --- a/pkg/fbs/common/oblivion/OblivionOverview.go +++ /dev/null @@ -1,118 +0,0 @@ -// Code generated by the FlatBuffers compiler. DO NOT EDIT. - -package oblivion - -import ( - flatbuffers "github.com/google/flatbuffers/go" -) - -type OblivionOverviewT struct { - Active bool `json:"active"` - Current *OblivionCurrentT `json:"current"` - Total *OblivionTotalT `json:"total"` -} - -func (t *OblivionOverviewT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - if t == nil { return 0 } - currentOffset := t.Current.Pack(builder) - totalOffset := t.Total.Pack(builder) - OblivionOverviewStart(builder) - OblivionOverviewAddActive(builder, t.Active) - OblivionOverviewAddCurrent(builder, currentOffset) - OblivionOverviewAddTotal(builder, totalOffset) - return OblivionOverviewEnd(builder) -} - -func (rcv *OblivionOverview) UnPackTo(t *OblivionOverviewT) { - t.Active = rcv.Active() - t.Current = rcv.Current(nil).UnPack() - t.Total = rcv.Total(nil).UnPack() -} - -func (rcv *OblivionOverview) UnPack() *OblivionOverviewT { - if rcv == nil { return nil } - t := &OblivionOverviewT{} - rcv.UnPackTo(t) - return t -} - -type OblivionOverview struct { - _tab flatbuffers.Table -} - -func GetRootAsOblivionOverview(buf []byte, offset flatbuffers.UOffsetT) *OblivionOverview { - n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &OblivionOverview{} - x.Init(buf, n+offset) - return x -} - -func GetSizePrefixedRootAsOblivionOverview(buf []byte, offset flatbuffers.UOffsetT) *OblivionOverview { - n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &OblivionOverview{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) - return x -} - -func (rcv *OblivionOverview) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *OblivionOverview) Table() flatbuffers.Table { - return rcv._tab -} - -func (rcv *OblivionOverview) Active() bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) - if o != 0 { - return rcv._tab.GetBool(o + rcv._tab.Pos) - } - return false -} - -func (rcv *OblivionOverview) MutateActive(n bool) bool { - return rcv._tab.MutateBoolSlot(4, n) -} - -func (rcv *OblivionOverview) Current(obj *OblivionCurrent) *OblivionCurrent { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) - if o != 0 { - x := rcv._tab.Indirect(o + rcv._tab.Pos) - if obj == nil { - obj = new(OblivionCurrent) - } - obj.Init(rcv._tab.Bytes, x) - return obj - } - return nil -} - -func (rcv *OblivionOverview) Total(obj *OblivionTotal) *OblivionTotal { - o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) - if o != 0 { - x := rcv._tab.Indirect(o + rcv._tab.Pos) - if obj == nil { - obj = new(OblivionTotal) - } - obj.Init(rcv._tab.Bytes, x) - return obj - } - return nil -} - -func OblivionOverviewStart(builder *flatbuffers.Builder) { - builder.StartObject(3) -} -func OblivionOverviewAddActive(builder *flatbuffers.Builder, active bool) { - builder.PrependBoolSlot(0, active, false) -} -func OblivionOverviewAddCurrent(builder *flatbuffers.Builder, current flatbuffers.UOffsetT) { - builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(current), 0) -} -func OblivionOverviewAddTotal(builder *flatbuffers.Builder, total flatbuffers.UOffsetT) { - builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(total), 0) -} -func OblivionOverviewEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - return builder.EndObject() -} diff --git a/pkg/fbs/common/oblivion/OblivionResult.go b/pkg/fbs/common/oblivion/OblivionResult.go deleted file mode 100644 index b4ce6d7..0000000 --- a/pkg/fbs/common/oblivion/OblivionResult.go +++ /dev/null @@ -1,110 +0,0 @@ -// Code generated by the FlatBuffers compiler. DO NOT EDIT. - -package oblivion - -import ( - flatbuffers "github.com/google/flatbuffers/go" -) - -type OblivionResultT struct { - Unfreed []*OblivionResultItemT `json:"unfreed"` -} - -func (t *OblivionResultT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - if t == nil { return 0 } - unfreedOffset := flatbuffers.UOffsetT(0) - if t.Unfreed != nil { - unfreedLength := len(t.Unfreed) - unfreedOffsets := make([]flatbuffers.UOffsetT, unfreedLength) - for j := 0; j < unfreedLength; j++ { - unfreedOffsets[j] = t.Unfreed[j].Pack(builder) - } - OblivionResultStartUnfreedVector(builder, unfreedLength) - for j := unfreedLength - 1; j >= 0; j-- { - builder.PrependUOffsetT(unfreedOffsets[j]) - } - unfreedOffset = builder.EndVector(unfreedLength) - } - OblivionResultStart(builder) - OblivionResultAddUnfreed(builder, unfreedOffset) - return OblivionResultEnd(builder) -} - -func (rcv *OblivionResult) UnPackTo(t *OblivionResultT) { - unfreedLength := rcv.UnfreedLength() - t.Unfreed = make([]*OblivionResultItemT, unfreedLength) - for j := 0; j < unfreedLength; j++ { - x := OblivionResultItem{} - rcv.Unfreed(&x, j) - t.Unfreed[j] = x.UnPack() - } -} - -func (rcv *OblivionResult) UnPack() *OblivionResultT { - if rcv == nil { return nil } - t := &OblivionResultT{} - rcv.UnPackTo(t) - return t -} - -type OblivionResult struct { - _tab flatbuffers.Table -} - -func GetRootAsOblivionResult(buf []byte, offset flatbuffers.UOffsetT) *OblivionResult { - n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &OblivionResult{} - x.Init(buf, n+offset) - return x -} - -func GetSizePrefixedRootAsOblivionResult(buf []byte, offset flatbuffers.UOffsetT) *OblivionResult { - n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &OblivionResult{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) - return x -} - -func (rcv *OblivionResult) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *OblivionResult) Table() flatbuffers.Table { - return rcv._tab -} - -/// all observed items -func (rcv *OblivionResult) Unfreed(obj *OblivionResultItem, j int) bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) - if o != 0 { - x := rcv._tab.Vector(o) - x += flatbuffers.UOffsetT(j) * 4 - x = rcv._tab.Indirect(x) - obj.Init(rcv._tab.Bytes, x) - return true - } - return false -} - -func (rcv *OblivionResult) UnfreedLength() int { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) - if o != 0 { - return rcv._tab.VectorLen(o) - } - return 0 -} - -/// all observed items -func OblivionResultStart(builder *flatbuffers.Builder) { - builder.StartObject(1) -} -func OblivionResultAddUnfreed(builder *flatbuffers.Builder, unfreed flatbuffers.UOffsetT) { - builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(unfreed), 0) -} -func OblivionResultStartUnfreedVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { - return builder.StartVector(4, numElems, 4) -} -func OblivionResultEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - return builder.EndObject() -} diff --git a/pkg/fbs/common/oblivion/OblivionResultItem.go b/pkg/fbs/common/oblivion/OblivionResultItem.go deleted file mode 100644 index 01399d8..0000000 --- a/pkg/fbs/common/oblivion/OblivionResultItem.go +++ /dev/null @@ -1,225 +0,0 @@ -// Code generated by the FlatBuffers compiler. DO NOT EDIT. - -package oblivion - -import ( - flatbuffers "github.com/google/flatbuffers/go" -) - -type OblivionResultItemT struct { - Count uint32 `json:"count"` - Bytes uint32 `json:"bytes"` - StackTrace []string `json:"stackTrace"` - ThreadName string `json:"threadName"` - TaskId uint64 `json:"taskID"` - CountAlloc uint64 `json:"countAlloc"` - CountFree uint64 `json:"countFree"` -} - -func (t *OblivionResultItemT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - if t == nil { return 0 } - stackTraceOffset := flatbuffers.UOffsetT(0) - if t.StackTrace != nil { - stackTraceLength := len(t.StackTrace) - stackTraceOffsets := make([]flatbuffers.UOffsetT, stackTraceLength) - for j := 0; j < stackTraceLength; j++ { - stackTraceOffsets[j] = builder.CreateString(t.StackTrace[j]) - } - OblivionResultItemStartStackTraceVector(builder, stackTraceLength) - for j := stackTraceLength - 1; j >= 0; j-- { - builder.PrependUOffsetT(stackTraceOffsets[j]) - } - stackTraceOffset = builder.EndVector(stackTraceLength) - } - threadNameOffset := flatbuffers.UOffsetT(0) - if t.ThreadName != "" { - threadNameOffset = builder.CreateString(t.ThreadName) - } - OblivionResultItemStart(builder) - OblivionResultItemAddCount(builder, t.Count) - OblivionResultItemAddBytes(builder, t.Bytes) - OblivionResultItemAddStackTrace(builder, stackTraceOffset) - OblivionResultItemAddThreadName(builder, threadNameOffset) - OblivionResultItemAddTaskId(builder, t.TaskId) - OblivionResultItemAddCountAlloc(builder, t.CountAlloc) - OblivionResultItemAddCountFree(builder, t.CountFree) - return OblivionResultItemEnd(builder) -} - -func (rcv *OblivionResultItem) UnPackTo(t *OblivionResultItemT) { - t.Count = rcv.Count() - t.Bytes = rcv.Bytes() - stackTraceLength := rcv.StackTraceLength() - t.StackTrace = make([]string, stackTraceLength) - for j := 0; j < stackTraceLength; j++ { - t.StackTrace[j] = string(rcv.StackTrace(j)) - } - t.ThreadName = string(rcv.ThreadName()) - t.TaskId = rcv.TaskId() - t.CountAlloc = rcv.CountAlloc() - t.CountFree = rcv.CountFree() -} - -func (rcv *OblivionResultItem) UnPack() *OblivionResultItemT { - if rcv == nil { return nil } - t := &OblivionResultItemT{} - rcv.UnPackTo(t) - return t -} - -type OblivionResultItem struct { - _tab flatbuffers.Table -} - -func GetRootAsOblivionResultItem(buf []byte, offset flatbuffers.UOffsetT) *OblivionResultItem { - n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &OblivionResultItem{} - x.Init(buf, n+offset) - return x -} - -func GetSizePrefixedRootAsOblivionResultItem(buf []byte, offset flatbuffers.UOffsetT) *OblivionResultItem { - n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &OblivionResultItem{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) - return x -} - -func (rcv *OblivionResultItem) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *OblivionResultItem) Table() flatbuffers.Table { - return rcv._tab -} - -/// count of unfreed memory areas -func (rcv *OblivionResultItem) Count() uint32 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) - if o != 0 { - return rcv._tab.GetUint32(o + rcv._tab.Pos) - } - return 0 -} - -/// count of unfreed memory areas -func (rcv *OblivionResultItem) MutateCount(n uint32) bool { - return rcv._tab.MutateUint32Slot(4, n) -} - -/// count of unfreed bytes -func (rcv *OblivionResultItem) Bytes() uint32 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) - if o != 0 { - return rcv._tab.GetUint32(o + rcv._tab.Pos) - } - return 0 -} - -/// count of unfreed bytes -func (rcv *OblivionResultItem) MutateBytes(n uint32) bool { - return rcv._tab.MutateUint32Slot(6, n) -} - -/// stack trace of item -func (rcv *OblivionResultItem) StackTrace(j int) []byte { - o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) - if o != 0 { - a := rcv._tab.Vector(o) - return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4)) - } - return nil -} - -func (rcv *OblivionResultItem) StackTraceLength() int { - o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) - if o != 0 { - return rcv._tab.VectorLen(o) - } - return 0 -} - -/// stack trace of item -/// name of the thread -func (rcv *OblivionResultItem) ThreadName() []byte { - o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) - if o != 0 { - return rcv._tab.ByteVector(o + rcv._tab.Pos) - } - return nil -} - -/// name of the thread -/// task identifier -func (rcv *OblivionResultItem) TaskId() uint64 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) - if o != 0 { - return rcv._tab.GetUint64(o + rcv._tab.Pos) - } - return 0 -} - -/// task identifier -func (rcv *OblivionResultItem) MutateTaskId(n uint64) bool { - return rcv._tab.MutateUint64Slot(12, n) -} - -/// count of allocs -func (rcv *OblivionResultItem) CountAlloc() uint64 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) - if o != 0 { - return rcv._tab.GetUint64(o + rcv._tab.Pos) - } - return 0 -} - -/// count of allocs -func (rcv *OblivionResultItem) MutateCountAlloc(n uint64) bool { - return rcv._tab.MutateUint64Slot(14, n) -} - -/// count of frees -func (rcv *OblivionResultItem) CountFree() uint64 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) - if o != 0 { - return rcv._tab.GetUint64(o + rcv._tab.Pos) - } - return 0 -} - -/// count of frees -func (rcv *OblivionResultItem) MutateCountFree(n uint64) bool { - return rcv._tab.MutateUint64Slot(16, n) -} - -func OblivionResultItemStart(builder *flatbuffers.Builder) { - builder.StartObject(7) -} -func OblivionResultItemAddCount(builder *flatbuffers.Builder, count uint32) { - builder.PrependUint32Slot(0, count, 0) -} -func OblivionResultItemAddBytes(builder *flatbuffers.Builder, bytes uint32) { - builder.PrependUint32Slot(1, bytes, 0) -} -func OblivionResultItemAddStackTrace(builder *flatbuffers.Builder, stackTrace flatbuffers.UOffsetT) { - builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(stackTrace), 0) -} -func OblivionResultItemStartStackTraceVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { - return builder.StartVector(4, numElems, 4) -} -func OblivionResultItemAddThreadName(builder *flatbuffers.Builder, threadName flatbuffers.UOffsetT) { - builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(threadName), 0) -} -func OblivionResultItemAddTaskId(builder *flatbuffers.Builder, taskId uint64) { - builder.PrependUint64Slot(4, taskId, 0) -} -func OblivionResultItemAddCountAlloc(builder *flatbuffers.Builder, countAlloc uint64) { - builder.PrependUint64Slot(5, countAlloc, 0) -} -func OblivionResultItemAddCountFree(builder *flatbuffers.Builder, countFree uint64) { - builder.PrependUint64Slot(6, countFree, 0) -} -func OblivionResultItemEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - return builder.EndObject() -} diff --git a/pkg/fbs/common/oblivion/OblivionSettings.go b/pkg/fbs/common/oblivion/OblivionSettings.go deleted file mode 100644 index 706a57e..0000000 --- a/pkg/fbs/common/oblivion/OblivionSettings.go +++ /dev/null @@ -1,168 +0,0 @@ -// Code generated by the FlatBuffers compiler. DO NOT EDIT. - -package oblivion - -import ( - flatbuffers "github.com/google/flatbuffers/go" -) - -type OblivionSettingsT struct { - HashSize uint32 `json:"hashSize"` - Ignore uint32 `json:"ignore"` - StackDepth uint32 `json:"stackDepth"` - RecordType RecordType `json:"recordType"` - ObserveThread uint64 `json:"observeThread"` - StackUsage bool `json:"stackUsage"` -} - -func (t *OblivionSettingsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - if t == nil { return 0 } - OblivionSettingsStart(builder) - OblivionSettingsAddHashSize(builder, t.HashSize) - OblivionSettingsAddIgnore(builder, t.Ignore) - OblivionSettingsAddStackDepth(builder, t.StackDepth) - OblivionSettingsAddRecordType(builder, t.RecordType) - OblivionSettingsAddObserveThread(builder, t.ObserveThread) - OblivionSettingsAddStackUsage(builder, t.StackUsage) - return OblivionSettingsEnd(builder) -} - -func (rcv *OblivionSettings) UnPackTo(t *OblivionSettingsT) { - t.HashSize = rcv.HashSize() - t.Ignore = rcv.Ignore() - t.StackDepth = rcv.StackDepth() - t.RecordType = rcv.RecordType() - t.ObserveThread = rcv.ObserveThread() - t.StackUsage = rcv.StackUsage() -} - -func (rcv *OblivionSettings) UnPack() *OblivionSettingsT { - if rcv == nil { return nil } - t := &OblivionSettingsT{} - rcv.UnPackTo(t) - return t -} - -type OblivionSettings struct { - _tab flatbuffers.Table -} - -func GetRootAsOblivionSettings(buf []byte, offset flatbuffers.UOffsetT) *OblivionSettings { - n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &OblivionSettings{} - x.Init(buf, n+offset) - return x -} - -func GetSizePrefixedRootAsOblivionSettings(buf []byte, offset flatbuffers.UOffsetT) *OblivionSettings { - n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &OblivionSettings{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) - return x -} - -func (rcv *OblivionSettings) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *OblivionSettings) Table() flatbuffers.Table { - return rcv._tab -} - -func (rcv *OblivionSettings) HashSize() uint32 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) - if o != 0 { - return rcv._tab.GetUint32(o + rcv._tab.Pos) - } - return 4999 -} - -func (rcv *OblivionSettings) MutateHashSize(n uint32) bool { - return rcv._tab.MutateUint32Slot(4, n) -} - -func (rcv *OblivionSettings) Ignore() uint32 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) - if o != 0 { - return rcv._tab.GetUint32(o + rcv._tab.Pos) - } - return 20 -} - -func (rcv *OblivionSettings) MutateIgnore(n uint32) bool { - return rcv._tab.MutateUint32Slot(6, n) -} - -func (rcv *OblivionSettings) StackDepth() uint32 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) - if o != 0 { - return rcv._tab.GetUint32(o + rcv._tab.Pos) - } - return 8 -} - -func (rcv *OblivionSettings) MutateStackDepth(n uint32) bool { - return rcv._tab.MutateUint32Slot(8, n) -} - -func (rcv *OblivionSettings) RecordType() RecordType { - o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) - if o != 0 { - return RecordType(rcv._tab.GetUint32(o + rcv._tab.Pos)) - } - return 1 -} - -func (rcv *OblivionSettings) MutateRecordType(n RecordType) bool { - return rcv._tab.MutateUint32Slot(10, uint32(n)) -} - -func (rcv *OblivionSettings) ObserveThread() uint64 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) - if o != 0 { - return rcv._tab.GetUint64(o + rcv._tab.Pos) - } - return 0 -} - -func (rcv *OblivionSettings) MutateObserveThread(n uint64) bool { - return rcv._tab.MutateUint64Slot(12, n) -} - -func (rcv *OblivionSettings) StackUsage() bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) - if o != 0 { - return rcv._tab.GetBool(o + rcv._tab.Pos) - } - return true -} - -func (rcv *OblivionSettings) MutateStackUsage(n bool) bool { - return rcv._tab.MutateBoolSlot(14, n) -} - -func OblivionSettingsStart(builder *flatbuffers.Builder) { - builder.StartObject(6) -} -func OblivionSettingsAddHashSize(builder *flatbuffers.Builder, hashSize uint32) { - builder.PrependUint32Slot(0, hashSize, 4999) -} -func OblivionSettingsAddIgnore(builder *flatbuffers.Builder, ignore uint32) { - builder.PrependUint32Slot(1, ignore, 20) -} -func OblivionSettingsAddStackDepth(builder *flatbuffers.Builder, stackDepth uint32) { - builder.PrependUint32Slot(2, stackDepth, 8) -} -func OblivionSettingsAddRecordType(builder *flatbuffers.Builder, recordType RecordType) { - builder.PrependUint32Slot(3, uint32(recordType), 1) -} -func OblivionSettingsAddObserveThread(builder *flatbuffers.Builder, observeThread uint64) { - builder.PrependUint64Slot(4, observeThread, 0) -} -func OblivionSettingsAddStackUsage(builder *flatbuffers.Builder, stackUsage bool) { - builder.PrependBoolSlot(5, stackUsage, true) -} -func OblivionSettingsEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - return builder.EndObject() -} diff --git a/pkg/fbs/common/oblivion/OblivionTotal.go b/pkg/fbs/common/oblivion/OblivionTotal.go deleted file mode 100644 index d370390..0000000 --- a/pkg/fbs/common/oblivion/OblivionTotal.go +++ /dev/null @@ -1,96 +0,0 @@ -// Code generated by the FlatBuffers compiler. DO NOT EDIT. - -package oblivion - -import ( - flatbuffers "github.com/google/flatbuffers/go" -) - -type OblivionTotalT struct { - Overhead uint32 `json:"overhead"` - Unobserved uint32 `json:"unobserved"` -} - -func (t *OblivionTotalT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - if t == nil { return 0 } - OblivionTotalStart(builder) - OblivionTotalAddOverhead(builder, t.Overhead) - OblivionTotalAddUnobserved(builder, t.Unobserved) - return OblivionTotalEnd(builder) -} - -func (rcv *OblivionTotal) UnPackTo(t *OblivionTotalT) { - t.Overhead = rcv.Overhead() - t.Unobserved = rcv.Unobserved() -} - -func (rcv *OblivionTotal) UnPack() *OblivionTotalT { - if rcv == nil { return nil } - t := &OblivionTotalT{} - rcv.UnPackTo(t) - return t -} - -type OblivionTotal struct { - _tab flatbuffers.Table -} - -func GetRootAsOblivionTotal(buf []byte, offset flatbuffers.UOffsetT) *OblivionTotal { - n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &OblivionTotal{} - x.Init(buf, n+offset) - return x -} - -func GetSizePrefixedRootAsOblivionTotal(buf []byte, offset flatbuffers.UOffsetT) *OblivionTotal { - n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &OblivionTotal{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) - return x -} - -func (rcv *OblivionTotal) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *OblivionTotal) Table() flatbuffers.Table { - return rcv._tab -} - -func (rcv *OblivionTotal) Overhead() uint32 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) - if o != 0 { - return rcv._tab.GetUint32(o + rcv._tab.Pos) - } - return 0 -} - -func (rcv *OblivionTotal) MutateOverhead(n uint32) bool { - return rcv._tab.MutateUint32Slot(4, n) -} - -func (rcv *OblivionTotal) Unobserved() uint32 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) - if o != 0 { - return rcv._tab.GetUint32(o + rcv._tab.Pos) - } - return 0 -} - -func (rcv *OblivionTotal) MutateUnobserved(n uint32) bool { - return rcv._tab.MutateUint32Slot(6, n) -} - -func OblivionTotalStart(builder *flatbuffers.Builder) { - builder.StartObject(2) -} -func OblivionTotalAddOverhead(builder *flatbuffers.Builder, overhead uint32) { - builder.PrependUint32Slot(0, overhead, 0) -} -func OblivionTotalAddUnobserved(builder *flatbuffers.Builder, unobserved uint32) { - builder.PrependUint32Slot(1, unobserved, 0) -} -func OblivionTotalEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - return builder.EndObject() -} diff --git a/pkg/fbs/common/oblivion/RecordType.go b/pkg/fbs/common/oblivion/RecordType.go deleted file mode 100644 index 6a321a6..0000000 --- a/pkg/fbs/common/oblivion/RecordType.go +++ /dev/null @@ -1,32 +0,0 @@ -// Code generated by the FlatBuffers compiler. DO NOT EDIT. - -package oblivion - -import "strconv" - -type RecordType uint32 - -const ( - RecordTypeStack RecordType = 0 - RecordTypeThread RecordType = 1 - RecordTypeThreadAlloc RecordType = 2 -) - -var EnumNamesRecordType = map[RecordType]string{ - RecordTypeStack: "Stack", - RecordTypeThread: "Thread", - RecordTypeThreadAlloc: "ThreadAlloc", -} - -var EnumValuesRecordType = map[string]RecordType{ - "Stack": RecordTypeStack, - "Thread": RecordTypeThread, - "ThreadAlloc": RecordTypeThreadAlloc, -} - -func (v RecordType) String() string { - if s, ok := EnumNamesRecordType[v]; ok { - return s - } - return "RecordType(" + strconv.FormatInt(int64(v), 10) + ")" -} diff --git a/pkg/fbs/common/oblivion/StackInfo.go b/pkg/fbs/common/oblivion/StackInfo.go deleted file mode 100644 index 685d77d..0000000 --- a/pkg/fbs/common/oblivion/StackInfo.go +++ /dev/null @@ -1,168 +0,0 @@ -// Code generated by the FlatBuffers compiler. DO NOT EDIT. - -package oblivion - -import ( - flatbuffers "github.com/google/flatbuffers/go" -) - -type StackInfoT struct { - Id uint32 `json:"id"` - State State `json:"state"` - Name string `json:"name"` - Size uint32 `json:"size"` - Used uint32 `json:"used"` - Percent uint32 `json:"percent"` -} - -func (t *StackInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - if t == nil { return 0 } - nameOffset := flatbuffers.UOffsetT(0) - if t.Name != "" { - nameOffset = builder.CreateString(t.Name) - } - StackInfoStart(builder) - StackInfoAddId(builder, t.Id) - StackInfoAddState(builder, t.State) - StackInfoAddName(builder, nameOffset) - StackInfoAddSize(builder, t.Size) - StackInfoAddUsed(builder, t.Used) - StackInfoAddPercent(builder, t.Percent) - return StackInfoEnd(builder) -} - -func (rcv *StackInfo) UnPackTo(t *StackInfoT) { - t.Id = rcv.Id() - t.State = rcv.State() - t.Name = string(rcv.Name()) - t.Size = rcv.Size() - t.Used = rcv.Used() - t.Percent = rcv.Percent() -} - -func (rcv *StackInfo) UnPack() *StackInfoT { - if rcv == nil { return nil } - t := &StackInfoT{} - rcv.UnPackTo(t) - return t -} - -type StackInfo struct { - _tab flatbuffers.Table -} - -func GetRootAsStackInfo(buf []byte, offset flatbuffers.UOffsetT) *StackInfo { - n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &StackInfo{} - x.Init(buf, n+offset) - return x -} - -func GetSizePrefixedRootAsStackInfo(buf []byte, offset flatbuffers.UOffsetT) *StackInfo { - n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &StackInfo{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) - return x -} - -func (rcv *StackInfo) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *StackInfo) Table() flatbuffers.Table { - return rcv._tab -} - -func (rcv *StackInfo) Id() uint32 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) - if o != 0 { - return rcv._tab.GetUint32(o + rcv._tab.Pos) - } - return 0 -} - -func (rcv *StackInfo) MutateId(n uint32) bool { - return rcv._tab.MutateUint32Slot(4, n) -} - -func (rcv *StackInfo) State() State { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) - if o != 0 { - return State(rcv._tab.GetInt16(o + rcv._tab.Pos)) - } - return 0 -} - -func (rcv *StackInfo) MutateState(n State) bool { - return rcv._tab.MutateInt16Slot(6, int16(n)) -} - -func (rcv *StackInfo) Name() []byte { - o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) - if o != 0 { - return rcv._tab.ByteVector(o + rcv._tab.Pos) - } - return nil -} - -func (rcv *StackInfo) Size() uint32 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) - if o != 0 { - return rcv._tab.GetUint32(o + rcv._tab.Pos) - } - return 0 -} - -func (rcv *StackInfo) MutateSize(n uint32) bool { - return rcv._tab.MutateUint32Slot(10, n) -} - -func (rcv *StackInfo) Used() uint32 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) - if o != 0 { - return rcv._tab.GetUint32(o + rcv._tab.Pos) - } - return 0 -} - -func (rcv *StackInfo) MutateUsed(n uint32) bool { - return rcv._tab.MutateUint32Slot(12, n) -} - -func (rcv *StackInfo) Percent() uint32 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) - if o != 0 { - return rcv._tab.GetUint32(o + rcv._tab.Pos) - } - return 0 -} - -func (rcv *StackInfo) MutatePercent(n uint32) bool { - return rcv._tab.MutateUint32Slot(14, n) -} - -func StackInfoStart(builder *flatbuffers.Builder) { - builder.StartObject(6) -} -func StackInfoAddId(builder *flatbuffers.Builder, id uint32) { - builder.PrependUint32Slot(0, id, 0) -} -func StackInfoAddState(builder *flatbuffers.Builder, state State) { - builder.PrependInt16Slot(1, int16(state), 0) -} -func StackInfoAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) { - builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(name), 0) -} -func StackInfoAddSize(builder *flatbuffers.Builder, size uint32) { - builder.PrependUint32Slot(3, size, 0) -} -func StackInfoAddUsed(builder *flatbuffers.Builder, used uint32) { - builder.PrependUint32Slot(4, used, 0) -} -func StackInfoAddPercent(builder *flatbuffers.Builder, percent uint32) { - builder.PrependUint32Slot(5, percent, 0) -} -func StackInfoEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - return builder.EndObject() -} diff --git a/pkg/fbs/common/oblivion/StackUsage.go b/pkg/fbs/common/oblivion/StackUsage.go deleted file mode 100644 index 09c0fd5..0000000 --- a/pkg/fbs/common/oblivion/StackUsage.go +++ /dev/null @@ -1,108 +0,0 @@ -// Code generated by the FlatBuffers compiler. DO NOT EDIT. - -package oblivion - -import ( - flatbuffers "github.com/google/flatbuffers/go" -) - -type StackUsageT struct { - Stacks []*StackInfoT `json:"stacks"` -} - -func (t *StackUsageT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - if t == nil { return 0 } - stacksOffset := flatbuffers.UOffsetT(0) - if t.Stacks != nil { - stacksLength := len(t.Stacks) - stacksOffsets := make([]flatbuffers.UOffsetT, stacksLength) - for j := 0; j < stacksLength; j++ { - stacksOffsets[j] = t.Stacks[j].Pack(builder) - } - StackUsageStartStacksVector(builder, stacksLength) - for j := stacksLength - 1; j >= 0; j-- { - builder.PrependUOffsetT(stacksOffsets[j]) - } - stacksOffset = builder.EndVector(stacksLength) - } - StackUsageStart(builder) - StackUsageAddStacks(builder, stacksOffset) - return StackUsageEnd(builder) -} - -func (rcv *StackUsage) UnPackTo(t *StackUsageT) { - stacksLength := rcv.StacksLength() - t.Stacks = make([]*StackInfoT, stacksLength) - for j := 0; j < stacksLength; j++ { - x := StackInfo{} - rcv.Stacks(&x, j) - t.Stacks[j] = x.UnPack() - } -} - -func (rcv *StackUsage) UnPack() *StackUsageT { - if rcv == nil { return nil } - t := &StackUsageT{} - rcv.UnPackTo(t) - return t -} - -type StackUsage struct { - _tab flatbuffers.Table -} - -func GetRootAsStackUsage(buf []byte, offset flatbuffers.UOffsetT) *StackUsage { - n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &StackUsage{} - x.Init(buf, n+offset) - return x -} - -func GetSizePrefixedRootAsStackUsage(buf []byte, offset flatbuffers.UOffsetT) *StackUsage { - n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &StackUsage{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) - return x -} - -func (rcv *StackUsage) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *StackUsage) Table() flatbuffers.Table { - return rcv._tab -} - -func (rcv *StackUsage) Stacks(obj *StackInfo, j int) bool { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) - if o != 0 { - x := rcv._tab.Vector(o) - x += flatbuffers.UOffsetT(j) * 4 - x = rcv._tab.Indirect(x) - obj.Init(rcv._tab.Bytes, x) - return true - } - return false -} - -func (rcv *StackUsage) StacksLength() int { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) - if o != 0 { - return rcv._tab.VectorLen(o) - } - return 0 -} - -func StackUsageStart(builder *flatbuffers.Builder) { - builder.StartObject(1) -} -func StackUsageAddStacks(builder *flatbuffers.Builder, stacks flatbuffers.UOffsetT) { - builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(stacks), 0) -} -func StackUsageStartStacksVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { - return builder.StartVector(4, numElems, 4) -} -func StackUsageEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - return builder.EndObject() -} diff --git a/pkg/fbs/common/oblivion/State.go b/pkg/fbs/common/oblivion/State.go deleted file mode 100644 index da34cc5..0000000 --- a/pkg/fbs/common/oblivion/State.go +++ /dev/null @@ -1,29 +0,0 @@ -// Code generated by the FlatBuffers compiler. DO NOT EDIT. - -package oblivion - -import "strconv" - -type State int16 - -const ( - StateRunning State = 0 - StateFinished State = 1 -) - -var EnumNamesState = map[State]string{ - StateRunning: "Running", - StateFinished: "Finished", -} - -var EnumValuesState = map[string]State{ - "Running": StateRunning, - "Finished": StateFinished, -} - -func (v State) String() string { - if s, ok := EnumNamesState[v]; ok { - return s - } - return "State(" + strconv.FormatInt(int64(v), 10) + ")" -} diff --git a/pkg/fbs/common/scheduler/fbs/Admin.go b/pkg/fbs/common/scheduler/fbs/Admin.go index cfceeaa..987c38c 100644 --- a/pkg/fbs/common/scheduler/fbs/Admin.go +++ b/pkg/fbs/common/scheduler/fbs/Admin.go @@ -20,7 +20,7 @@ type AdminT struct { func (t *AdminT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { if t == nil { return 0 } controlDebugOffset := t.ControlDebug.Pack(builder) - + cpuInfoOffset := t.CpuInfo.Pack(builder) AdminStart(builder) AdminAddStartupState(builder, t.StartupState) diff --git a/pkg/fbs/common/scheduler/fbs2/Admin.go b/pkg/fbs/common/scheduler/fbs2/Admin.go index ecccff4..30550ef 100644 --- a/pkg/fbs/common/scheduler/fbs2/Admin.go +++ b/pkg/fbs/common/scheduler/fbs2/Admin.go @@ -21,12 +21,13 @@ type AdminT struct { WatchdogDefaultValue common__scheduler__fbs.CallableWdgConfig `json:"watchdogDefaultValue"` Utilization *UtilizationThresholdT `json:"utilization"` CallableTimeouts *CallableTimeoutsT `json:"callableTimeouts"` + ProgramConfigurationMode ConfigurationMode `json:"programConfigurationMode"` } func (t *AdminT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { if t == nil { return 0 } controlDebugOffset := t.ControlDebug.Pack(builder) - + cpuInfoOffset := t.CpuInfo.Pack(builder) utilizationOffset := t.Utilization.Pack(builder) callableTimeoutsOffset := t.CallableTimeouts.Pack(builder) @@ -44,6 +45,7 @@ func (t *AdminT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { AdminAddWatchdogDefaultValue(builder, t.WatchdogDefaultValue) AdminAddUtilization(builder, utilizationOffset) AdminAddCallableTimeouts(builder, callableTimeoutsOffset) + AdminAddProgramConfigurationMode(builder, t.ProgramConfigurationMode) return AdminEnd(builder) } @@ -61,6 +63,7 @@ func (rcv *Admin) UnPackTo(t *AdminT) { t.WatchdogDefaultValue = rcv.WatchdogDefaultValue() t.Utilization = rcv.Utilization(nil).UnPack() t.CallableTimeouts = rcv.CallableTimeouts(nil).UnPack() + t.ProgramConfigurationMode = rcv.ProgramConfigurationMode() } func (rcv *Admin) UnPack() *AdminT { @@ -249,8 +252,22 @@ func (rcv *Admin) CallableTimeouts(obj *CallableTimeouts) *CallableTimeouts { } /// General settings for timeouts when switching callable operation states +/// Program configuration mode of the Scheduler +func (rcv *Admin) ProgramConfigurationMode() ConfigurationMode { + o := flatbuffers.UOffsetT(rcv._tab.Offset(26)) + if o != 0 { + return ConfigurationMode(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +/// Program configuration mode of the Scheduler +func (rcv *Admin) MutateProgramConfigurationMode(n ConfigurationMode) bool { + return rcv._tab.MutateInt8Slot(26, int8(n)) +} + func AdminStart(builder *flatbuffers.Builder) { - builder.StartObject(11) + builder.StartObject(12) } func AdminAddStartupState(builder *flatbuffers.Builder, startupState CurrentState) { builder.PrependInt8Slot(0, int8(startupState), 0) @@ -285,6 +302,9 @@ func AdminAddUtilization(builder *flatbuffers.Builder, utilization flatbuffers.U func AdminAddCallableTimeouts(builder *flatbuffers.Builder, callableTimeouts flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(10, flatbuffers.UOffsetT(callableTimeouts), 0) } +func AdminAddProgramConfigurationMode(builder *flatbuffers.Builder, programConfigurationMode ConfigurationMode) { + builder.PrependInt8Slot(11, int8(programConfigurationMode), 0) +} func AdminEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/pkg/fbs/common/scheduler/fbs2/ConfigurationMode.go b/pkg/fbs/common/scheduler/fbs2/ConfigurationMode.go new file mode 100644 index 0000000..21c931f --- /dev/null +++ b/pkg/fbs/common/scheduler/fbs2/ConfigurationMode.go @@ -0,0 +1,32 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs2 + +import "strconv" + +/// Possible program configuration modes +type ConfigurationMode int8 + +const ( + /// Automatic program configuration + ConfigurationModeAUTOMATIC ConfigurationMode = 0 + /// Manual program configuration + ConfigurationModeMANUAL ConfigurationMode = 1 +) + +var EnumNamesConfigurationMode = map[ConfigurationMode]string{ + ConfigurationModeAUTOMATIC: "AUTOMATIC", + ConfigurationModeMANUAL: "MANUAL", +} + +var EnumValuesConfigurationMode = map[string]ConfigurationMode{ + "AUTOMATIC": ConfigurationModeAUTOMATIC, + "MANUAL": ConfigurationModeMANUAL, +} + +func (v ConfigurationMode) String() string { + if s, ok := EnumNamesConfigurationMode[v]; ok { + return s + } + return "ConfigurationMode(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/common/scheduler/fbs2/ProgramConfiguration.go b/pkg/fbs/common/scheduler/fbs2/ProgramConfiguration.go new file mode 100644 index 0000000..062c1be --- /dev/null +++ b/pkg/fbs/common/scheduler/fbs2/ProgramConfiguration.go @@ -0,0 +1,79 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs2 + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// Program configuration mode +type ProgramConfigurationT struct { + Mode ConfigurationMode `json:"mode"` +} + +func (t *ProgramConfigurationT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + ProgramConfigurationStart(builder) + ProgramConfigurationAddMode(builder, t.Mode) + return ProgramConfigurationEnd(builder) +} + +func (rcv *ProgramConfiguration) UnPackTo(t *ProgramConfigurationT) { + t.Mode = rcv.Mode() +} + +func (rcv *ProgramConfiguration) UnPack() *ProgramConfigurationT { + if rcv == nil { return nil } + t := &ProgramConfigurationT{} + rcv.UnPackTo(t) + return t +} + +type ProgramConfiguration struct { + _tab flatbuffers.Table +} + +func GetRootAsProgramConfiguration(buf []byte, offset flatbuffers.UOffsetT) *ProgramConfiguration { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &ProgramConfiguration{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsProgramConfiguration(buf []byte, offset flatbuffers.UOffsetT) *ProgramConfiguration { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &ProgramConfiguration{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *ProgramConfiguration) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *ProgramConfiguration) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *ProgramConfiguration) Mode() ConfigurationMode { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return ConfigurationMode(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *ProgramConfiguration) MutateMode(n ConfigurationMode) bool { + return rcv._tab.MutateInt8Slot(4, int8(n)) +} + +func ProgramConfigurationStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func ProgramConfigurationAddMode(builder *flatbuffers.Builder, mode ConfigurationMode) { + builder.PrependInt8Slot(0, int8(mode), 0) +} +func ProgramConfigurationEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/core/fbtypes/AxsCfgCyclicStatusData.go b/pkg/fbs/motion/core/fbtypes/AxsCfgCyclicStatusData.go new file mode 100644 index 0000000..9ba34de --- /dev/null +++ b/pkg/fbs/motion/core/fbtypes/AxsCfgCyclicStatusData.go @@ -0,0 +1,103 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// Configuration of motion kernel axis function cyclic status data +type AxsCfgCyclicStatusDataT struct { + Windows *AxsCfgWindowsForStateDataT `json:"windows"` + Remanent bool `json:"remanent"` +} + +func (t *AxsCfgCyclicStatusDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + windowsOffset := t.Windows.Pack(builder) + AxsCfgCyclicStatusDataStart(builder) + AxsCfgCyclicStatusDataAddWindows(builder, windowsOffset) + AxsCfgCyclicStatusDataAddRemanent(builder, t.Remanent) + return AxsCfgCyclicStatusDataEnd(builder) +} + +func (rcv *AxsCfgCyclicStatusData) UnPackTo(t *AxsCfgCyclicStatusDataT) { + t.Windows = rcv.Windows(nil).UnPack() + t.Remanent = rcv.Remanent() +} + +func (rcv *AxsCfgCyclicStatusData) UnPack() *AxsCfgCyclicStatusDataT { + if rcv == nil { return nil } + t := &AxsCfgCyclicStatusDataT{} + rcv.UnPackTo(t) + return t +} + +type AxsCfgCyclicStatusData struct { + _tab flatbuffers.Table +} + +func GetRootAsAxsCfgCyclicStatusData(buf []byte, offset flatbuffers.UOffsetT) *AxsCfgCyclicStatusData { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &AxsCfgCyclicStatusData{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsAxsCfgCyclicStatusData(buf []byte, offset flatbuffers.UOffsetT) *AxsCfgCyclicStatusData { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &AxsCfgCyclicStatusData{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *AxsCfgCyclicStatusData) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *AxsCfgCyclicStatusData) Table() flatbuffers.Table { + return rcv._tab +} + +/// windows for cyclic status data +func (rcv *AxsCfgCyclicStatusData) Windows(obj *AxsCfgWindowsForStateData) *AxsCfgWindowsForStateData { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(AxsCfgWindowsForStateData) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// windows for cyclic status data +/// flag in the motion kernel to enable axis function cyclic status data. +func (rcv *AxsCfgCyclicStatusData) Remanent() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +/// flag in the motion kernel to enable axis function cyclic status data. +func (rcv *AxsCfgCyclicStatusData) MutateRemanent(n bool) bool { + return rcv._tab.MutateBoolSlot(6, n) +} + +func AxsCfgCyclicStatusDataStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func AxsCfgCyclicStatusDataAddWindows(builder *flatbuffers.Builder, windows flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(windows), 0) +} +func AxsCfgCyclicStatusDataAddRemanent(builder *flatbuffers.Builder, remanent bool) { + builder.PrependBoolSlot(1, remanent, false) +} +func AxsCfgCyclicStatusDataEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/core/fbtypes/AxsCfgDevNotFollowing.go b/pkg/fbs/motion/core/fbtypes/AxsCfgDevNotFollowing.go new file mode 100644 index 0000000..7560a67 --- /dev/null +++ b/pkg/fbs/motion/core/fbtypes/AxsCfgDevNotFollowing.go @@ -0,0 +1,81 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// configuration of reaction if axis device no longer follows the control's command values +type AxsCfgDevNotFollowingT struct { + ErrReaction ErrReactionType `json:"errReaction"` +} + +func (t *AxsCfgDevNotFollowingT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + AxsCfgDevNotFollowingStart(builder) + AxsCfgDevNotFollowingAddErrReaction(builder, t.ErrReaction) + return AxsCfgDevNotFollowingEnd(builder) +} + +func (rcv *AxsCfgDevNotFollowing) UnPackTo(t *AxsCfgDevNotFollowingT) { + t.ErrReaction = rcv.ErrReaction() +} + +func (rcv *AxsCfgDevNotFollowing) UnPack() *AxsCfgDevNotFollowingT { + if rcv == nil { return nil } + t := &AxsCfgDevNotFollowingT{} + rcv.UnPackTo(t) + return t +} + +type AxsCfgDevNotFollowing struct { + _tab flatbuffers.Table +} + +func GetRootAsAxsCfgDevNotFollowing(buf []byte, offset flatbuffers.UOffsetT) *AxsCfgDevNotFollowing { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &AxsCfgDevNotFollowing{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsAxsCfgDevNotFollowing(buf []byte, offset flatbuffers.UOffsetT) *AxsCfgDevNotFollowing { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &AxsCfgDevNotFollowing{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *AxsCfgDevNotFollowing) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *AxsCfgDevNotFollowing) Table() flatbuffers.Table { + return rcv._tab +} + +/// error reaction +func (rcv *AxsCfgDevNotFollowing) ErrReaction() ErrReactionType { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return ErrReactionType(rcv._tab.GetUint32(o + rcv._tab.Pos)) + } + return 4 +} + +/// error reaction +func (rcv *AxsCfgDevNotFollowing) MutateErrReaction(n ErrReactionType) bool { + return rcv._tab.MutateUint32Slot(4, uint32(n)) +} + +func AxsCfgDevNotFollowingStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func AxsCfgDevNotFollowingAddErrReaction(builder *flatbuffers.Builder, errReaction ErrReactionType) { + builder.PrependUint32Slot(0, uint32(errReaction), 4) +} +func AxsCfgDevNotFollowingEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/core/fbtypes/AxsCfgDeviceErrorReaction.go b/pkg/fbs/motion/core/fbtypes/AxsCfgDeviceErrorReaction.go index f26bbcf..b81ec82 100644 --- a/pkg/fbs/motion/core/fbtypes/AxsCfgDeviceErrorReaction.go +++ b/pkg/fbs/motion/core/fbtypes/AxsCfgDeviceErrorReaction.go @@ -10,21 +10,25 @@ import ( type AxsCfgDeviceErrorReactionT struct { UserEstopLim *AxsCfgEstopDynamicLimitsT `json:"userEstopLim"` EstopSettings *AxsCfgEstopSettingsT `json:"estopSettings"` + DevNotFollowing *AxsCfgDevNotFollowingT `json:"devNotFollowing"` } func (t *AxsCfgDeviceErrorReactionT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { if t == nil { return 0 } userEstopLimOffset := t.UserEstopLim.Pack(builder) estopSettingsOffset := t.EstopSettings.Pack(builder) + devNotFollowingOffset := t.DevNotFollowing.Pack(builder) AxsCfgDeviceErrorReactionStart(builder) AxsCfgDeviceErrorReactionAddUserEstopLim(builder, userEstopLimOffset) AxsCfgDeviceErrorReactionAddEstopSettings(builder, estopSettingsOffset) + AxsCfgDeviceErrorReactionAddDevNotFollowing(builder, devNotFollowingOffset) return AxsCfgDeviceErrorReactionEnd(builder) } func (rcv *AxsCfgDeviceErrorReaction) UnPackTo(t *AxsCfgDeviceErrorReactionT) { t.UserEstopLim = rcv.UserEstopLim(nil).UnPack() t.EstopSettings = rcv.EstopSettings(nil).UnPack() + t.DevNotFollowing = rcv.DevNotFollowing(nil).UnPack() } func (rcv *AxsCfgDeviceErrorReaction) UnPack() *AxsCfgDeviceErrorReactionT { @@ -91,8 +95,23 @@ func (rcv *AxsCfgDeviceErrorReaction) EstopSettings(obj *AxsCfgEstopSettings) *A } /// E-Stop setting to different device errors +/// reaction if axis device does not follow command values +func (rcv *AxsCfgDeviceErrorReaction) DevNotFollowing(obj *AxsCfgDevNotFollowing) *AxsCfgDevNotFollowing { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(AxsCfgDevNotFollowing) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// reaction if axis device does not follow command values func AxsCfgDeviceErrorReactionStart(builder *flatbuffers.Builder) { - builder.StartObject(2) + builder.StartObject(3) } func AxsCfgDeviceErrorReactionAddUserEstopLim(builder *flatbuffers.Builder, userEstopLim flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(userEstopLim), 0) @@ -100,6 +119,9 @@ func AxsCfgDeviceErrorReactionAddUserEstopLim(builder *flatbuffers.Builder, user func AxsCfgDeviceErrorReactionAddEstopSettings(builder *flatbuffers.Builder, estopSettings flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(estopSettings), 0) } +func AxsCfgDeviceErrorReactionAddDevNotFollowing(builder *flatbuffers.Builder, devNotFollowing flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(devNotFollowing), 0) +} func AxsCfgDeviceErrorReactionEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/pkg/fbs/motion/core/fbtypes/AxsCfgDriveSLS.go b/pkg/fbs/motion/core/fbtypes/AxsCfgDriveSLS.go new file mode 100644 index 0000000..c5612ef --- /dev/null +++ b/pkg/fbs/motion/core/fbtypes/AxsCfgDriveSLS.go @@ -0,0 +1,121 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// Configuration of motion kernel monitoring and reaction of drive function 'safe limited speed' +type AxsCfgDriveSLST struct { + Vel float64 `json:"vel"` + VelUnit string `json:"velUnit"` + EnableFlag bool `json:"enableFlag"` +} + +func (t *AxsCfgDriveSLST) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + velUnitOffset := flatbuffers.UOffsetT(0) + if t.VelUnit != "" { + velUnitOffset = builder.CreateString(t.VelUnit) + } + AxsCfgDriveSLSStart(builder) + AxsCfgDriveSLSAddVel(builder, t.Vel) + AxsCfgDriveSLSAddVelUnit(builder, velUnitOffset) + AxsCfgDriveSLSAddEnableFlag(builder, t.EnableFlag) + return AxsCfgDriveSLSEnd(builder) +} + +func (rcv *AxsCfgDriveSLS) UnPackTo(t *AxsCfgDriveSLST) { + t.Vel = rcv.Vel() + t.VelUnit = string(rcv.VelUnit()) + t.EnableFlag = rcv.EnableFlag() +} + +func (rcv *AxsCfgDriveSLS) UnPack() *AxsCfgDriveSLST { + if rcv == nil { return nil } + t := &AxsCfgDriveSLST{} + rcv.UnPackTo(t) + return t +} + +type AxsCfgDriveSLS struct { + _tab flatbuffers.Table +} + +func GetRootAsAxsCfgDriveSLS(buf []byte, offset flatbuffers.UOffsetT) *AxsCfgDriveSLS { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &AxsCfgDriveSLS{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsAxsCfgDriveSLS(buf []byte, offset flatbuffers.UOffsetT) *AxsCfgDriveSLS { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &AxsCfgDriveSLS{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *AxsCfgDriveSLS) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *AxsCfgDriveSLS) Table() flatbuffers.Table { + return rcv._tab +} + +/// velocity limit for the axis in the motion kernel, when drive function 'safe limited speed' is active +func (rcv *AxsCfgDriveSLS) Vel() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +/// velocity limit for the axis in the motion kernel, when drive function 'safe limited speed' is active +func (rcv *AxsCfgDriveSLS) MutateVel(n float64) bool { + return rcv._tab.MutateFloat64Slot(4, n) +} + +/// unit of vel +func (rcv *AxsCfgDriveSLS) VelUnit() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// unit of vel +/// is safe operation mode monitoring in the motion kernel active or not +func (rcv *AxsCfgDriveSLS) EnableFlag() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +/// is safe operation mode monitoring in the motion kernel active or not +func (rcv *AxsCfgDriveSLS) MutateEnableFlag(n bool) bool { + return rcv._tab.MutateBoolSlot(8, n) +} + +func AxsCfgDriveSLSStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func AxsCfgDriveSLSAddVel(builder *flatbuffers.Builder, vel float64) { + builder.PrependFloat64Slot(0, vel, 0.0) +} +func AxsCfgDriveSLSAddVelUnit(builder *flatbuffers.Builder, velUnit flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(velUnit), 0) +} +func AxsCfgDriveSLSAddEnableFlag(builder *flatbuffers.Builder, enableFlag bool) { + builder.PrependBoolSlot(2, enableFlag, false) +} +func AxsCfgDriveSLSEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/core/fbtypes/AxsCfgFunctions.go b/pkg/fbs/motion/core/fbtypes/AxsCfgFunctions.go index fd99018..3c71aae 100644 --- a/pkg/fbs/motion/core/fbtypes/AxsCfgFunctions.go +++ b/pkg/fbs/motion/core/fbtypes/AxsCfgFunctions.go @@ -15,6 +15,8 @@ type AxsCfgFunctionsT struct { PosMode *AxsCfgPosModeT `json:"posMode"` Extrapolation *AxsCfgExtrapolationT `json:"extrapolation"` AxsEncoder *AxsCfgEncoderT `json:"axsEncoder"` + AxsCfgDriveSls *AxsCfgDriveSLST `json:"axsCfgDriveSLS"` + AxsCfgCyclicStatusData *AxsCfgCyclicStatusDataT `json:"axsCfgCyclicStatusData"` } func (t *AxsCfgFunctionsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { @@ -36,12 +38,16 @@ func (t *AxsCfgFunctionsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffse posModeOffset := t.PosMode.Pack(builder) extrapolationOffset := t.Extrapolation.Pack(builder) axsEncoderOffset := t.AxsEncoder.Pack(builder) + axsCfgDriveSlsOffset := t.AxsCfgDriveSls.Pack(builder) + axsCfgCyclicStatusDataOffset := t.AxsCfgCyclicStatusData.Pack(builder) AxsCfgFunctionsStart(builder) AxsCfgFunctionsAddCoupling(builder, couplingOffset) AxsCfgFunctionsAddCalculationPipelines(builder, calculationPipelinesOffset) AxsCfgFunctionsAddPosMode(builder, posModeOffset) AxsCfgFunctionsAddExtrapolation(builder, extrapolationOffset) AxsCfgFunctionsAddAxsEncoder(builder, axsEncoderOffset) + AxsCfgFunctionsAddAxsCfgDriveSls(builder, axsCfgDriveSlsOffset) + AxsCfgFunctionsAddAxsCfgCyclicStatusData(builder, axsCfgCyclicStatusDataOffset) return AxsCfgFunctionsEnd(builder) } @@ -57,6 +63,8 @@ func (rcv *AxsCfgFunctions) UnPackTo(t *AxsCfgFunctionsT) { t.PosMode = rcv.PosMode(nil).UnPack() t.Extrapolation = rcv.Extrapolation(nil).UnPack() t.AxsEncoder = rcv.AxsEncoder(nil).UnPack() + t.AxsCfgDriveSls = rcv.AxsCfgDriveSls(nil).UnPack() + t.AxsCfgCyclicStatusData = rcv.AxsCfgCyclicStatusData(nil).UnPack() } func (rcv *AxsCfgFunctions) UnPack() *AxsCfgFunctionsT { @@ -175,8 +183,38 @@ func (rcv *AxsCfgFunctions) AxsEncoder(obj *AxsCfgEncoder) *AxsCfgEncoder { } /// configuration for encoder axis +/// configuration of monitoring of the safe limited speed in the drive by the motion kernel +func (rcv *AxsCfgFunctions) AxsCfgDriveSls(obj *AxsCfgDriveSLS) *AxsCfgDriveSLS { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(AxsCfgDriveSLS) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// configuration of monitoring of the safe limited speed in the drive by the motion kernel +/// configuration of cyclic status data for an axis +func (rcv *AxsCfgFunctions) AxsCfgCyclicStatusData(obj *AxsCfgCyclicStatusData) *AxsCfgCyclicStatusData { + o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(AxsCfgCyclicStatusData) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// configuration of cyclic status data for an axis func AxsCfgFunctionsStart(builder *flatbuffers.Builder) { - builder.StartObject(5) + builder.StartObject(7) } func AxsCfgFunctionsAddCoupling(builder *flatbuffers.Builder, coupling flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(coupling), 0) @@ -196,6 +234,12 @@ func AxsCfgFunctionsAddExtrapolation(builder *flatbuffers.Builder, extrapolation func AxsCfgFunctionsAddAxsEncoder(builder *flatbuffers.Builder, axsEncoder flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(axsEncoder), 0) } +func AxsCfgFunctionsAddAxsCfgDriveSls(builder *flatbuffers.Builder, axsCfgDriveSls flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(axsCfgDriveSls), 0) +} +func AxsCfgFunctionsAddAxsCfgCyclicStatusData(builder *flatbuffers.Builder, axsCfgCyclicStatusData flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(6, flatbuffers.UOffsetT(axsCfgCyclicStatusData), 0) +} func AxsCfgFunctionsEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/pkg/fbs/motion/core/fbtypes/AxsCfgWindowsForStateData.go b/pkg/fbs/motion/core/fbtypes/AxsCfgWindowsForStateData.go new file mode 100644 index 0000000..e797665 --- /dev/null +++ b/pkg/fbs/motion/core/fbtypes/AxsCfgWindowsForStateData.go @@ -0,0 +1,221 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// all configured cyclic status data windows for an axis +type AxsCfgWindowsForStateDataT struct { + Standstill float64 `json:"standstill"` + InVel float64 `json:"inVel"` + InPos float64 `json:"inPos"` + InTrq float64 `json:"inTrq"` + StandstillUnit string `json:"standstillUnit"` + InVelUnit string `json:"inVelUnit"` + InPosUnit string `json:"inPosUnit"` + InTrqUnit string `json:"inTrqUnit"` +} + +func (t *AxsCfgWindowsForStateDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + standstillUnitOffset := flatbuffers.UOffsetT(0) + if t.StandstillUnit != "" { + standstillUnitOffset = builder.CreateString(t.StandstillUnit) + } + inVelUnitOffset := flatbuffers.UOffsetT(0) + if t.InVelUnit != "" { + inVelUnitOffset = builder.CreateString(t.InVelUnit) + } + inPosUnitOffset := flatbuffers.UOffsetT(0) + if t.InPosUnit != "" { + inPosUnitOffset = builder.CreateString(t.InPosUnit) + } + inTrqUnitOffset := flatbuffers.UOffsetT(0) + if t.InTrqUnit != "" { + inTrqUnitOffset = builder.CreateString(t.InTrqUnit) + } + AxsCfgWindowsForStateDataStart(builder) + AxsCfgWindowsForStateDataAddStandstill(builder, t.Standstill) + AxsCfgWindowsForStateDataAddInVel(builder, t.InVel) + AxsCfgWindowsForStateDataAddInPos(builder, t.InPos) + AxsCfgWindowsForStateDataAddInTrq(builder, t.InTrq) + AxsCfgWindowsForStateDataAddStandstillUnit(builder, standstillUnitOffset) + AxsCfgWindowsForStateDataAddInVelUnit(builder, inVelUnitOffset) + AxsCfgWindowsForStateDataAddInPosUnit(builder, inPosUnitOffset) + AxsCfgWindowsForStateDataAddInTrqUnit(builder, inTrqUnitOffset) + return AxsCfgWindowsForStateDataEnd(builder) +} + +func (rcv *AxsCfgWindowsForStateData) UnPackTo(t *AxsCfgWindowsForStateDataT) { + t.Standstill = rcv.Standstill() + t.InVel = rcv.InVel() + t.InPos = rcv.InPos() + t.InTrq = rcv.InTrq() + t.StandstillUnit = string(rcv.StandstillUnit()) + t.InVelUnit = string(rcv.InVelUnit()) + t.InPosUnit = string(rcv.InPosUnit()) + t.InTrqUnit = string(rcv.InTrqUnit()) +} + +func (rcv *AxsCfgWindowsForStateData) UnPack() *AxsCfgWindowsForStateDataT { + if rcv == nil { return nil } + t := &AxsCfgWindowsForStateDataT{} + rcv.UnPackTo(t) + return t +} + +type AxsCfgWindowsForStateData struct { + _tab flatbuffers.Table +} + +func GetRootAsAxsCfgWindowsForStateData(buf []byte, offset flatbuffers.UOffsetT) *AxsCfgWindowsForStateData { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &AxsCfgWindowsForStateData{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsAxsCfgWindowsForStateData(buf []byte, offset flatbuffers.UOffsetT) *AxsCfgWindowsForStateData { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &AxsCfgWindowsForStateData{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *AxsCfgWindowsForStateData) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *AxsCfgWindowsForStateData) Table() flatbuffers.Table { + return rcv._tab +} + +/// window for standstill +func (rcv *AxsCfgWindowsForStateData) Standstill() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +/// window for standstill +func (rcv *AxsCfgWindowsForStateData) MutateStandstill(n float64) bool { + return rcv._tab.MutateFloat64Slot(4, n) +} + +/// window for inVel +func (rcv *AxsCfgWindowsForStateData) InVel() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +/// window for inVel +func (rcv *AxsCfgWindowsForStateData) MutateInVel(n float64) bool { + return rcv._tab.MutateFloat64Slot(6, n) +} + +/// window for inPos +func (rcv *AxsCfgWindowsForStateData) InPos() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +/// window for inPos +func (rcv *AxsCfgWindowsForStateData) MutateInPos(n float64) bool { + return rcv._tab.MutateFloat64Slot(8, n) +} + +/// window for inTrq +func (rcv *AxsCfgWindowsForStateData) InTrq() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +/// window for inTrq +func (rcv *AxsCfgWindowsForStateData) MutateInTrq(n float64) bool { + return rcv._tab.MutateFloat64Slot(10, n) +} + +/// unit of standstill +func (rcv *AxsCfgWindowsForStateData) StandstillUnit() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// unit of standstill +/// unit of inVel +func (rcv *AxsCfgWindowsForStateData) InVelUnit() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// unit of inVel +/// unit of inPos +func (rcv *AxsCfgWindowsForStateData) InPosUnit() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// unit of inPos +/// unit of inTrq +func (rcv *AxsCfgWindowsForStateData) InTrqUnit() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(18)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// unit of inTrq +func AxsCfgWindowsForStateDataStart(builder *flatbuffers.Builder) { + builder.StartObject(8) +} +func AxsCfgWindowsForStateDataAddStandstill(builder *flatbuffers.Builder, standstill float64) { + builder.PrependFloat64Slot(0, standstill, 0.0) +} +func AxsCfgWindowsForStateDataAddInVel(builder *flatbuffers.Builder, inVel float64) { + builder.PrependFloat64Slot(1, inVel, 0.0) +} +func AxsCfgWindowsForStateDataAddInPos(builder *flatbuffers.Builder, inPos float64) { + builder.PrependFloat64Slot(2, inPos, 0.0) +} +func AxsCfgWindowsForStateDataAddInTrq(builder *flatbuffers.Builder, inTrq float64) { + builder.PrependFloat64Slot(3, inTrq, 0.0) +} +func AxsCfgWindowsForStateDataAddStandstillUnit(builder *flatbuffers.Builder, standstillUnit flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(standstillUnit), 0) +} +func AxsCfgWindowsForStateDataAddInVelUnit(builder *flatbuffers.Builder, inVelUnit flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(inVelUnit), 0) +} +func AxsCfgWindowsForStateDataAddInPosUnit(builder *flatbuffers.Builder, inPosUnit flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(6, flatbuffers.UOffsetT(inPosUnit), 0) +} +func AxsCfgWindowsForStateDataAddInTrqUnit(builder *flatbuffers.Builder, inTrqUnit flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(7, flatbuffers.UOffsetT(inTrqUnit), 0) +} +func AxsCfgWindowsForStateDataEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/core/fbtypes/AxsCmdStopData.go b/pkg/fbs/motion/core/fbtypes/AxsCmdStopData.go new file mode 100644 index 0000000..38a7789 --- /dev/null +++ b/pkg/fbs/motion/core/fbtypes/AxsCmdStopData.go @@ -0,0 +1,121 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// parameters of the axis abort command +type AxsCmdStopDataT struct { + DoStop bool `json:"doStop"` + Dec float64 `json:"dec"` + JrkDec float64 `json:"jrkDec"` +} + +func (t *AxsCmdStopDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + AxsCmdStopDataStart(builder) + AxsCmdStopDataAddDoStop(builder, t.DoStop) + AxsCmdStopDataAddDec(builder, t.Dec) + AxsCmdStopDataAddJrkDec(builder, t.JrkDec) + return AxsCmdStopDataEnd(builder) +} + +func (rcv *AxsCmdStopData) UnPackTo(t *AxsCmdStopDataT) { + t.DoStop = rcv.DoStop() + t.Dec = rcv.Dec() + t.JrkDec = rcv.JrkDec() +} + +func (rcv *AxsCmdStopData) UnPack() *AxsCmdStopDataT { + if rcv == nil { return nil } + t := &AxsCmdStopDataT{} + rcv.UnPackTo(t) + return t +} + +type AxsCmdStopData struct { + _tab flatbuffers.Table +} + +func GetRootAsAxsCmdStopData(buf []byte, offset flatbuffers.UOffsetT) *AxsCmdStopData { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &AxsCmdStopData{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsAxsCmdStopData(buf []byte, offset flatbuffers.UOffsetT) *AxsCmdStopData { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &AxsCmdStopData{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *AxsCmdStopData) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *AxsCmdStopData) Table() flatbuffers.Table { + return rcv._tab +} + +/// execute the stopAxsCommand? doStop=True -> stop command; doStop=False -> unstop command +func (rcv *AxsCmdStopData) DoStop() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return true +} + +/// execute the stopAxsCommand? doStop=True -> stop command; doStop=False -> unstop command +func (rcv *AxsCmdStopData) MutateDoStop(n bool) bool { + return rcv._tab.MutateBoolSlot(4, n) +} + +/// commanded deceleration limit (must be a positive value) +func (rcv *AxsCmdStopData) Dec() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 1.0 +} + +/// commanded deceleration limit (must be a positive value) +func (rcv *AxsCmdStopData) MutateDec(n float64) bool { + return rcv._tab.MutateFloat64Slot(6, n) +} + +/// commanded deceleration jerk limit (must be a positive value OR zero), zero means "not jerk limited" +func (rcv *AxsCmdStopData) JrkDec() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +/// commanded deceleration jerk limit (must be a positive value OR zero), zero means "not jerk limited" +func (rcv *AxsCmdStopData) MutateJrkDec(n float64) bool { + return rcv._tab.MutateFloat64Slot(8, n) +} + +func AxsCmdStopDataStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func AxsCmdStopDataAddDoStop(builder *flatbuffers.Builder, doStop bool) { + builder.PrependBoolSlot(0, doStop, true) +} +func AxsCmdStopDataAddDec(builder *flatbuffers.Builder, dec float64) { + builder.PrependFloat64Slot(1, dec, 1.0) +} +func AxsCmdStopDataAddJrkDec(builder *flatbuffers.Builder, jrkDec float64) { + builder.PrependFloat64Slot(2, jrkDec, 0.0) +} +func AxsCmdStopDataEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/core/fbtypes/CircleMeaning.go b/pkg/fbs/motion/core/fbtypes/CircleMeaning.go deleted file mode 100644 index c65d90d..0000000 --- a/pkg/fbs/motion/core/fbtypes/CircleMeaning.go +++ /dev/null @@ -1,56 +0,0 @@ -// Code generated by the FlatBuffers compiler. DO NOT EDIT. - -package fbtypes - -import "strconv" - -/// Meaning for commanded circle -type CircleMeaning int8 - -const ( - /// radius of the circle commanded - CircleMeaningRADIUS CircleMeaning = 0 - /// center point of the circle X-coordinate - CircleMeaningCP_X CircleMeaning = 1 - /// center point of the circle Y-coordinate - CircleMeaningCP_Y CircleMeaning = 2 - /// center point of the circle Z-coordinate - CircleMeaningCP_Z CircleMeaning = 3 - /// intermediate point of the circle X-coordinate - CircleMeaningIP_X CircleMeaning = 4 - /// intermediate point of the circle Y-coordinate - CircleMeaningIP_Y CircleMeaning = 5 - /// intermediate point of the circle Z-coordinate - CircleMeaningIP_Z CircleMeaning = 6 - /// circle revolutions - CircleMeaningREV CircleMeaning = 7 -) - -var EnumNamesCircleMeaning = map[CircleMeaning]string{ - CircleMeaningRADIUS: "RADIUS", - CircleMeaningCP_X: "CP_X", - CircleMeaningCP_Y: "CP_Y", - CircleMeaningCP_Z: "CP_Z", - CircleMeaningIP_X: "IP_X", - CircleMeaningIP_Y: "IP_Y", - CircleMeaningIP_Z: "IP_Z", - CircleMeaningREV: "REV", -} - -var EnumValuesCircleMeaning = map[string]CircleMeaning{ - "RADIUS": CircleMeaningRADIUS, - "CP_X": CircleMeaningCP_X, - "CP_Y": CircleMeaningCP_Y, - "CP_Z": CircleMeaningCP_Z, - "IP_X": CircleMeaningIP_X, - "IP_Y": CircleMeaningIP_Y, - "IP_Z": CircleMeaningIP_Z, - "REV": CircleMeaningREV, -} - -func (v CircleMeaning) String() string { - if s, ok := EnumNamesCircleMeaning[v]; ok { - return s - } - return "CircleMeaning(" + strconv.FormatInt(int64(v), 10) + ")" -} diff --git a/pkg/fbs/motion/core/fbtypes/CircleMeaning2d.go b/pkg/fbs/motion/core/fbtypes/CircleMeaning2d.go new file mode 100644 index 0000000..c267b3f --- /dev/null +++ b/pkg/fbs/motion/core/fbtypes/CircleMeaning2d.go @@ -0,0 +1,44 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import "strconv" + +/// Meaning for commanded 2d circle +type CircleMeaning2d int8 + +const ( + /// radius of the circle commanded + CircleMeaning2dRADIUS CircleMeaning2d = 0 + /// center point of the circle X-coordinate + CircleMeaning2dCP_X CircleMeaning2d = 1 + /// center point of the circle Y-coordinate + CircleMeaning2dCP_Y CircleMeaning2d = 2 + /// center point of the circle Z-coordinate + CircleMeaning2dCP_Z CircleMeaning2d = 3 + /// circle revolutions + CircleMeaning2dREV CircleMeaning2d = 4 +) + +var EnumNamesCircleMeaning2d = map[CircleMeaning2d]string{ + CircleMeaning2dRADIUS: "RADIUS", + CircleMeaning2dCP_X: "CP_X", + CircleMeaning2dCP_Y: "CP_Y", + CircleMeaning2dCP_Z: "CP_Z", + CircleMeaning2dREV: "REV", +} + +var EnumValuesCircleMeaning2d = map[string]CircleMeaning2d{ + "RADIUS": CircleMeaning2dRADIUS, + "CP_X": CircleMeaning2dCP_X, + "CP_Y": CircleMeaning2dCP_Y, + "CP_Z": CircleMeaning2dCP_Z, + "REV": CircleMeaning2dREV, +} + +func (v CircleMeaning2d) String() string { + if s, ok := EnumNamesCircleMeaning2d[v]; ok { + return s + } + return "CircleMeaning2d(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/motion/core/fbtypes/CircleMeaning2dSettings.go b/pkg/fbs/motion/core/fbtypes/CircleMeaning2dSettings.go new file mode 100644 index 0000000..4ef8a20 --- /dev/null +++ b/pkg/fbs/motion/core/fbtypes/CircleMeaning2dSettings.go @@ -0,0 +1,78 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type CircleMeaning2dSettingsT struct { + Type CircleMeaning2d `json:"type"` +} + +func (t *CircleMeaning2dSettingsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + CircleMeaning2dSettingsStart(builder) + CircleMeaning2dSettingsAddType(builder, t.Type) + return CircleMeaning2dSettingsEnd(builder) +} + +func (rcv *CircleMeaning2dSettings) UnPackTo(t *CircleMeaning2dSettingsT) { + t.Type = rcv.Type() +} + +func (rcv *CircleMeaning2dSettings) UnPack() *CircleMeaning2dSettingsT { + if rcv == nil { return nil } + t := &CircleMeaning2dSettingsT{} + rcv.UnPackTo(t) + return t +} + +type CircleMeaning2dSettings struct { + _tab flatbuffers.Table +} + +func GetRootAsCircleMeaning2dSettings(buf []byte, offset flatbuffers.UOffsetT) *CircleMeaning2dSettings { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &CircleMeaning2dSettings{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCircleMeaning2dSettings(buf []byte, offset flatbuffers.UOffsetT) *CircleMeaning2dSettings { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &CircleMeaning2dSettings{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *CircleMeaning2dSettings) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *CircleMeaning2dSettings) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *CircleMeaning2dSettings) Type() CircleMeaning2d { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return CircleMeaning2d(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *CircleMeaning2dSettings) MutateType(n CircleMeaning2d) bool { + return rcv._tab.MutateInt8Slot(4, int8(n)) +} + +func CircleMeaning2dSettingsStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func CircleMeaning2dSettingsAddType(builder *flatbuffers.Builder, type_ CircleMeaning2d) { + builder.PrependInt8Slot(0, int8(type_), 0) +} +func CircleMeaning2dSettingsEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/core/fbtypes/CircleMeaning3d.go b/pkg/fbs/motion/core/fbtypes/CircleMeaning3d.go new file mode 100644 index 0000000..0906816 --- /dev/null +++ b/pkg/fbs/motion/core/fbtypes/CircleMeaning3d.go @@ -0,0 +1,36 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import "strconv" + +/// Meaning for commanded circle +type CircleMeaning3d int8 + +const ( + /// intermediate point of the circle X-coordinate + CircleMeaning3dIP_X CircleMeaning3d = 0 + /// intermediate point of the circle Y-coordinate + CircleMeaning3dIP_Y CircleMeaning3d = 1 + /// intermediate point of the circle Z-coordinate + CircleMeaning3dIP_Z CircleMeaning3d = 2 +) + +var EnumNamesCircleMeaning3d = map[CircleMeaning3d]string{ + CircleMeaning3dIP_X: "IP_X", + CircleMeaning3dIP_Y: "IP_Y", + CircleMeaning3dIP_Z: "IP_Z", +} + +var EnumValuesCircleMeaning3d = map[string]CircleMeaning3d{ + "IP_X": CircleMeaning3dIP_X, + "IP_Y": CircleMeaning3dIP_Y, + "IP_Z": CircleMeaning3dIP_Z, +} + +func (v CircleMeaning3d) String() string { + if s, ok := EnumNamesCircleMeaning3d[v]; ok { + return s + } + return "CircleMeaning3d(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/motion/core/fbtypes/CircleMeaning3dSettings.go b/pkg/fbs/motion/core/fbtypes/CircleMeaning3dSettings.go new file mode 100644 index 0000000..c80c135 --- /dev/null +++ b/pkg/fbs/motion/core/fbtypes/CircleMeaning3dSettings.go @@ -0,0 +1,78 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type CircleMeaning3dSettingsT struct { + Type CircleMeaning3d `json:"type"` +} + +func (t *CircleMeaning3dSettingsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + CircleMeaning3dSettingsStart(builder) + CircleMeaning3dSettingsAddType(builder, t.Type) + return CircleMeaning3dSettingsEnd(builder) +} + +func (rcv *CircleMeaning3dSettings) UnPackTo(t *CircleMeaning3dSettingsT) { + t.Type = rcv.Type() +} + +func (rcv *CircleMeaning3dSettings) UnPack() *CircleMeaning3dSettingsT { + if rcv == nil { return nil } + t := &CircleMeaning3dSettingsT{} + rcv.UnPackTo(t) + return t +} + +type CircleMeaning3dSettings struct { + _tab flatbuffers.Table +} + +func GetRootAsCircleMeaning3dSettings(buf []byte, offset flatbuffers.UOffsetT) *CircleMeaning3dSettings { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &CircleMeaning3dSettings{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCircleMeaning3dSettings(buf []byte, offset flatbuffers.UOffsetT) *CircleMeaning3dSettings { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &CircleMeaning3dSettings{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *CircleMeaning3dSettings) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *CircleMeaning3dSettings) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *CircleMeaning3dSettings) Type() CircleMeaning3d { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return CircleMeaning3d(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *CircleMeaning3dSettings) MutateType(n CircleMeaning3d) bool { + return rcv._tab.MutateInt8Slot(4, int8(n)) +} + +func CircleMeaning3dSettingsStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func CircleMeaning3dSettingsAddType(builder *flatbuffers.Builder, type_ CircleMeaning3d) { + builder.PrependInt8Slot(0, int8(type_), 0) +} +func CircleMeaning3dSettingsEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/core/fbtypes/CircleMeaningSettings.go b/pkg/fbs/motion/core/fbtypes/CircleMeaningSettings.go deleted file mode 100644 index 8103936..0000000 --- a/pkg/fbs/motion/core/fbtypes/CircleMeaningSettings.go +++ /dev/null @@ -1,78 +0,0 @@ -// Code generated by the FlatBuffers compiler. DO NOT EDIT. - -package fbtypes - -import ( - flatbuffers "github.com/google/flatbuffers/go" -) - -type CircleMeaningSettingsT struct { - Type CircleMeaning `json:"type"` -} - -func (t *CircleMeaningSettingsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - if t == nil { return 0 } - CircleMeaningSettingsStart(builder) - CircleMeaningSettingsAddType(builder, t.Type) - return CircleMeaningSettingsEnd(builder) -} - -func (rcv *CircleMeaningSettings) UnPackTo(t *CircleMeaningSettingsT) { - t.Type = rcv.Type() -} - -func (rcv *CircleMeaningSettings) UnPack() *CircleMeaningSettingsT { - if rcv == nil { return nil } - t := &CircleMeaningSettingsT{} - rcv.UnPackTo(t) - return t -} - -type CircleMeaningSettings struct { - _tab flatbuffers.Table -} - -func GetRootAsCircleMeaningSettings(buf []byte, offset flatbuffers.UOffsetT) *CircleMeaningSettings { - n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &CircleMeaningSettings{} - x.Init(buf, n+offset) - return x -} - -func GetSizePrefixedRootAsCircleMeaningSettings(buf []byte, offset flatbuffers.UOffsetT) *CircleMeaningSettings { - n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &CircleMeaningSettings{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) - return x -} - -func (rcv *CircleMeaningSettings) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *CircleMeaningSettings) Table() flatbuffers.Table { - return rcv._tab -} - -func (rcv *CircleMeaningSettings) Type() CircleMeaning { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) - if o != 0 { - return CircleMeaning(rcv._tab.GetInt8(o + rcv._tab.Pos)) - } - return 0 -} - -func (rcv *CircleMeaningSettings) MutateType(n CircleMeaning) bool { - return rcv._tab.MutateInt8Slot(4, int8(n)) -} - -func CircleMeaningSettingsStart(builder *flatbuffers.Builder) { - builder.StartObject(1) -} -func CircleMeaningSettingsAddType(builder *flatbuffers.Builder, type_ CircleMeaning) { - builder.PrependInt8Slot(0, int8(type_), 0) -} -func CircleMeaningSettingsEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - return builder.EndObject() -} diff --git a/pkg/fbs/motion/core/fbtypes/CmdOptNoParam.go b/pkg/fbs/motion/core/fbtypes/CmdOptNoParam.go index 4e0f3b7..151f903 100644 --- a/pkg/fbs/motion/core/fbtypes/CmdOptNoParam.go +++ b/pkg/fbs/motion/core/fbtypes/CmdOptNoParam.go @@ -60,7 +60,7 @@ func (rcv *CmdOptNoParam) Table() flatbuffers.Table { return rcv._tab } -/// permanent type (e.g. "PermOn") +/// permanent type ("Once", "PermOn" or any other string to switch off; valid options depend on CmdOpt) func (rcv *CmdOptNoParam) PermType() []byte { o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) if o != 0 { @@ -69,7 +69,7 @@ func (rcv *CmdOptNoParam) PermType() []byte { return nil } -/// permanent type (e.g. "PermOn") +/// permanent type ("Once", "PermOn" or any other string to switch off; valid options depend on CmdOpt) func CmdOptNoParamStart(builder *flatbuffers.Builder) { builder.StartObject(1) } diff --git a/pkg/fbs/motion/core/fbtypes/DataItem.go b/pkg/fbs/motion/core/fbtypes/DataItem.go new file mode 100644 index 0000000..d7a1b29 --- /dev/null +++ b/pkg/fbs/motion/core/fbtypes/DataItem.go @@ -0,0 +1,141 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// information on a single data item +type DataItemT struct { + Uri string `json:"uri"` + Value float64 `json:"value"` + Unit string `json:"unit"` + Status string `json:"status"` +} + +func (t *DataItemT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + uriOffset := flatbuffers.UOffsetT(0) + if t.Uri != "" { + uriOffset = builder.CreateString(t.Uri) + } + unitOffset := flatbuffers.UOffsetT(0) + if t.Unit != "" { + unitOffset = builder.CreateString(t.Unit) + } + statusOffset := flatbuffers.UOffsetT(0) + if t.Status != "" { + statusOffset = builder.CreateString(t.Status) + } + DataItemStart(builder) + DataItemAddUri(builder, uriOffset) + DataItemAddValue(builder, t.Value) + DataItemAddUnit(builder, unitOffset) + DataItemAddStatus(builder, statusOffset) + return DataItemEnd(builder) +} + +func (rcv *DataItem) UnPackTo(t *DataItemT) { + t.Uri = string(rcv.Uri()) + t.Value = rcv.Value() + t.Unit = string(rcv.Unit()) + t.Status = string(rcv.Status()) +} + +func (rcv *DataItem) UnPack() *DataItemT { + if rcv == nil { return nil } + t := &DataItemT{} + rcv.UnPackTo(t) + return t +} + +type DataItem struct { + _tab flatbuffers.Table +} + +func GetRootAsDataItem(buf []byte, offset flatbuffers.UOffsetT) *DataItem { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &DataItem{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsDataItem(buf []byte, offset flatbuffers.UOffsetT) *DataItem { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &DataItem{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *DataItem) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *DataItem) Table() flatbuffers.Table { + return rcv._tab +} + +/// URI of the data item +func (rcv *DataItem) Uri() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// URI of the data item +/// value of the data item at the time of the request +func (rcv *DataItem) Value() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +/// value of the data item at the time of the request +func (rcv *DataItem) MutateValue(n float64) bool { + return rcv._tab.MutateFloat64Slot(6, n) +} + +/// unit of the value (or empty for unit-less values) +func (rcv *DataItem) Unit() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// unit of the value (or empty for unit-less values) +/// result of the read-value-call (value is only set on STS_OK) +func (rcv *DataItem) Status() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// result of the read-value-call (value is only set on STS_OK) +func DataItemStart(builder *flatbuffers.Builder) { + builder.StartObject(4) +} +func DataItemAddUri(builder *flatbuffers.Builder, uri flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(uri), 0) +} +func DataItemAddValue(builder *flatbuffers.Builder, value float64) { + builder.PrependFloat64Slot(1, value, 0.0) +} +func DataItemAddUnit(builder *flatbuffers.Builder, unit flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(unit), 0) +} +func DataItemAddStatus(builder *flatbuffers.Builder, status flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(status), 0) +} +func DataItemEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/core/fbtypes/ErrReactionType.go b/pkg/fbs/motion/core/fbtypes/ErrReactionType.go new file mode 100644 index 0000000..e865220 --- /dev/null +++ b/pkg/fbs/motion/core/fbtypes/ErrReactionType.go @@ -0,0 +1,40 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import "strconv" + +/// Error reaction type +type ErrReactionType uint32 + +const ( + /// no reaction but single trace message + ErrReactionTypeNONE ErrReactionType = 1 + /// single axis message + ErrReactionTypeMESSAGE ErrReactionType = 2 + /// single axis warning + ErrReactionTypeWARNING ErrReactionType = 3 + /// axis goes to error state with severe error + ErrReactionTypeSEVERE_ERROR ErrReactionType = 4 +) + +var EnumNamesErrReactionType = map[ErrReactionType]string{ + ErrReactionTypeNONE: "NONE", + ErrReactionTypeMESSAGE: "MESSAGE", + ErrReactionTypeWARNING: "WARNING", + ErrReactionTypeSEVERE_ERROR: "SEVERE_ERROR", +} + +var EnumValuesErrReactionType = map[string]ErrReactionType{ + "NONE": ErrReactionTypeNONE, + "MESSAGE": ErrReactionTypeMESSAGE, + "WARNING": ErrReactionTypeWARNING, + "SEVERE_ERROR": ErrReactionTypeSEVERE_ERROR, +} + +func (v ErrReactionType) String() string { + if s, ok := EnumNamesErrReactionType[v]; ok { + return s + } + return "ErrReactionType(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/motion/core/fbtypes/Ext2dCircleMeaning.go b/pkg/fbs/motion/core/fbtypes/Ext2dCircleMeaning.go new file mode 100644 index 0000000..6a5f4fe --- /dev/null +++ b/pkg/fbs/motion/core/fbtypes/Ext2dCircleMeaning.go @@ -0,0 +1,105 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// Packed pair of target position meaning and attribute +type Ext2dCircleMeaningT struct { + Meaning CircleMeaning2d `json:"meaning"` + AddAttributes AddAttributes `json:"addAttributes"` +} + +func (t *Ext2dCircleMeaningT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + Ext2dCircleMeaningStart(builder) + Ext2dCircleMeaningAddMeaning(builder, t.Meaning) + Ext2dCircleMeaningAddAddAttributes(builder, t.AddAttributes) + return Ext2dCircleMeaningEnd(builder) +} + +func (rcv *Ext2dCircleMeaning) UnPackTo(t *Ext2dCircleMeaningT) { + t.Meaning = rcv.Meaning() + t.AddAttributes = rcv.AddAttributes() +} + +func (rcv *Ext2dCircleMeaning) UnPack() *Ext2dCircleMeaningT { + if rcv == nil { return nil } + t := &Ext2dCircleMeaningT{} + rcv.UnPackTo(t) + return t +} + +type Ext2dCircleMeaning struct { + _tab flatbuffers.Table +} + +func GetRootAsExt2dCircleMeaning(buf []byte, offset flatbuffers.UOffsetT) *Ext2dCircleMeaning { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Ext2dCircleMeaning{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsExt2dCircleMeaning(buf []byte, offset flatbuffers.UOffsetT) *Ext2dCircleMeaning { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Ext2dCircleMeaning{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Ext2dCircleMeaning) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Ext2dCircleMeaning) Table() flatbuffers.Table { + return rcv._tab +} + +/// related meaning of the value +/// possible meanings are: "RADIUS", "CP_X", "CP_Y", "CP_Z", "REV" +func (rcv *Ext2dCircleMeaning) Meaning() CircleMeaning2d { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return CircleMeaning2d(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +/// related meaning of the value +/// possible meanings are: "RADIUS", "CP_X", "CP_Y", "CP_Z", "REV" +func (rcv *Ext2dCircleMeaning) MutateMeaning(n CircleMeaning2d) bool { + return rcv._tab.MutateInt8Slot(4, int8(n)) +} + +/// attributes for the target position meaning +/// possible meanings are: "UNDEF", "INCR_VALUE", "ABS_VALUE", "SHORT_WAY", "POS_ROT_DIR", "NEG_ROT_DIR" +func (rcv *Ext2dCircleMeaning) AddAttributes() AddAttributes { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return AddAttributes(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +/// attributes for the target position meaning +/// possible meanings are: "UNDEF", "INCR_VALUE", "ABS_VALUE", "SHORT_WAY", "POS_ROT_DIR", "NEG_ROT_DIR" +func (rcv *Ext2dCircleMeaning) MutateAddAttributes(n AddAttributes) bool { + return rcv._tab.MutateInt8Slot(6, int8(n)) +} + +func Ext2dCircleMeaningStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func Ext2dCircleMeaningAddMeaning(builder *flatbuffers.Builder, meaning CircleMeaning2d) { + builder.PrependInt8Slot(0, int8(meaning), 0) +} +func Ext2dCircleMeaningAddAddAttributes(builder *flatbuffers.Builder, addAttributes AddAttributes) { + builder.PrependInt8Slot(1, int8(addAttributes), 0) +} +func Ext2dCircleMeaningEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/core/fbtypes/Ext3dCircleMeaning.go b/pkg/fbs/motion/core/fbtypes/Ext3dCircleMeaning.go new file mode 100644 index 0000000..848a6fc --- /dev/null +++ b/pkg/fbs/motion/core/fbtypes/Ext3dCircleMeaning.go @@ -0,0 +1,105 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// Packed pair of target position meaning and attribute +type Ext3dCircleMeaningT struct { + Meaning CircleMeaning3d `json:"meaning"` + AddAttributes AddAttributes `json:"addAttributes"` +} + +func (t *Ext3dCircleMeaningT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + Ext3dCircleMeaningStart(builder) + Ext3dCircleMeaningAddMeaning(builder, t.Meaning) + Ext3dCircleMeaningAddAddAttributes(builder, t.AddAttributes) + return Ext3dCircleMeaningEnd(builder) +} + +func (rcv *Ext3dCircleMeaning) UnPackTo(t *Ext3dCircleMeaningT) { + t.Meaning = rcv.Meaning() + t.AddAttributes = rcv.AddAttributes() +} + +func (rcv *Ext3dCircleMeaning) UnPack() *Ext3dCircleMeaningT { + if rcv == nil { return nil } + t := &Ext3dCircleMeaningT{} + rcv.UnPackTo(t) + return t +} + +type Ext3dCircleMeaning struct { + _tab flatbuffers.Table +} + +func GetRootAsExt3dCircleMeaning(buf []byte, offset flatbuffers.UOffsetT) *Ext3dCircleMeaning { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Ext3dCircleMeaning{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsExt3dCircleMeaning(buf []byte, offset flatbuffers.UOffsetT) *Ext3dCircleMeaning { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Ext3dCircleMeaning{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Ext3dCircleMeaning) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Ext3dCircleMeaning) Table() flatbuffers.Table { + return rcv._tab +} + +/// related meaning of the value +/// possible meanings are: "IP_X", "IP_Y", "IP_Z" +func (rcv *Ext3dCircleMeaning) Meaning() CircleMeaning3d { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return CircleMeaning3d(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +/// related meaning of the value +/// possible meanings are: "IP_X", "IP_Y", "IP_Z" +func (rcv *Ext3dCircleMeaning) MutateMeaning(n CircleMeaning3d) bool { + return rcv._tab.MutateInt8Slot(4, int8(n)) +} + +/// attributes for the target position meaning +/// possible meanings are: "UNDEF", "INCR_VALUE", "ABS_VALUE", "SHORT_WAY", "POS_ROT_DIR", "NEG_ROT_DIR" +func (rcv *Ext3dCircleMeaning) AddAttributes() AddAttributes { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return AddAttributes(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +/// attributes for the target position meaning +/// possible meanings are: "UNDEF", "INCR_VALUE", "ABS_VALUE", "SHORT_WAY", "POS_ROT_DIR", "NEG_ROT_DIR" +func (rcv *Ext3dCircleMeaning) MutateAddAttributes(n AddAttributes) bool { + return rcv._tab.MutateInt8Slot(6, int8(n)) +} + +func Ext3dCircleMeaningStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func Ext3dCircleMeaningAddMeaning(builder *flatbuffers.Builder, meaning CircleMeaning3d) { + builder.PrependInt8Slot(0, int8(meaning), 0) +} +func Ext3dCircleMeaningAddAddAttributes(builder *flatbuffers.Builder, addAttributes AddAttributes) { + builder.PrependInt8Slot(1, int8(addAttributes), 0) +} +func Ext3dCircleMeaningEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/core/fbtypes/ExtCircleMeaning.go b/pkg/fbs/motion/core/fbtypes/ExtCircleMeaning.go deleted file mode 100644 index cfaa082..0000000 --- a/pkg/fbs/motion/core/fbtypes/ExtCircleMeaning.go +++ /dev/null @@ -1,105 +0,0 @@ -// Code generated by the FlatBuffers compiler. DO NOT EDIT. - -package fbtypes - -import ( - flatbuffers "github.com/google/flatbuffers/go" -) - -/// Packed pair of target position meaning and attribute -type ExtCircleMeaningT struct { - Meaning CircleMeaning `json:"meaning"` - AddAttributes AddAttributes `json:"addAttributes"` -} - -func (t *ExtCircleMeaningT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - if t == nil { return 0 } - ExtCircleMeaningStart(builder) - ExtCircleMeaningAddMeaning(builder, t.Meaning) - ExtCircleMeaningAddAddAttributes(builder, t.AddAttributes) - return ExtCircleMeaningEnd(builder) -} - -func (rcv *ExtCircleMeaning) UnPackTo(t *ExtCircleMeaningT) { - t.Meaning = rcv.Meaning() - t.AddAttributes = rcv.AddAttributes() -} - -func (rcv *ExtCircleMeaning) UnPack() *ExtCircleMeaningT { - if rcv == nil { return nil } - t := &ExtCircleMeaningT{} - rcv.UnPackTo(t) - return t -} - -type ExtCircleMeaning struct { - _tab flatbuffers.Table -} - -func GetRootAsExtCircleMeaning(buf []byte, offset flatbuffers.UOffsetT) *ExtCircleMeaning { - n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &ExtCircleMeaning{} - x.Init(buf, n+offset) - return x -} - -func GetSizePrefixedRootAsExtCircleMeaning(buf []byte, offset flatbuffers.UOffsetT) *ExtCircleMeaning { - n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &ExtCircleMeaning{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) - return x -} - -func (rcv *ExtCircleMeaning) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *ExtCircleMeaning) Table() flatbuffers.Table { - return rcv._tab -} - -/// related meaning of the value -/// possible meanings are: "RADIUS", "CP_X", "CP_Y", "CP_Z", "IP_X", "IP_Y", "IP_Z", "REV" -func (rcv *ExtCircleMeaning) Meaning() CircleMeaning { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) - if o != 0 { - return CircleMeaning(rcv._tab.GetInt8(o + rcv._tab.Pos)) - } - return 0 -} - -/// related meaning of the value -/// possible meanings are: "RADIUS", "CP_X", "CP_Y", "CP_Z", "IP_X", "IP_Y", "IP_Z", "REV" -func (rcv *ExtCircleMeaning) MutateMeaning(n CircleMeaning) bool { - return rcv._tab.MutateInt8Slot(4, int8(n)) -} - -/// attributes for the target position meaning -/// possible meanings are: "UNDEF", "INCR_VALUE", "ABS_VALUE", "SHORT_WAY", "POS_ROT_DIR", "NEG_ROT_DIR" -func (rcv *ExtCircleMeaning) AddAttributes() AddAttributes { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) - if o != 0 { - return AddAttributes(rcv._tab.GetInt8(o + rcv._tab.Pos)) - } - return 0 -} - -/// attributes for the target position meaning -/// possible meanings are: "UNDEF", "INCR_VALUE", "ABS_VALUE", "SHORT_WAY", "POS_ROT_DIR", "NEG_ROT_DIR" -func (rcv *ExtCircleMeaning) MutateAddAttributes(n AddAttributes) bool { - return rcv._tab.MutateInt8Slot(6, int8(n)) -} - -func ExtCircleMeaningStart(builder *flatbuffers.Builder) { - builder.StartObject(2) -} -func ExtCircleMeaningAddMeaning(builder *flatbuffers.Builder, meaning CircleMeaning) { - builder.PrependInt8Slot(0, int8(meaning), 0) -} -func ExtCircleMeaningAddAddAttributes(builder *flatbuffers.Builder, addAttributes AddAttributes) { - builder.PrependInt8Slot(1, int8(addAttributes), 0) -} -func ExtCircleMeaningEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - return builder.EndObject() -} diff --git a/pkg/fbs/motion/core/fbtypes/KinCfg.go b/pkg/fbs/motion/core/fbtypes/KinCfg.go index 330821d..edd2c1d 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCfg.go +++ b/pkg/fbs/motion/core/fbtypes/KinCfg.go @@ -17,6 +17,7 @@ type KinCfgT struct { RtInputs *RTInputsCfgT `json:"rtInputs"` Dynamics *KinCfgDynamicsT `json:"dynamics"` Geometry *KinGeoCfgT `json:"geometry"` + Functions *KinCfgFunctionsT `json:"functions"` } func (t *KinCfgT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { @@ -45,6 +46,7 @@ func (t *KinCfgT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { rtInputsOffset := t.RtInputs.Pack(builder) dynamicsOffset := t.Dynamics.Pack(builder) geometryOffset := t.Geometry.Pack(builder) + functionsOffset := t.Functions.Pack(builder) KinCfgStart(builder) KinCfgAddObjectType(builder, objectTypeOffset) KinCfgAddLimits(builder, limitsOffset) @@ -55,6 +57,7 @@ func (t *KinCfgT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { KinCfgAddRtInputs(builder, rtInputsOffset) KinCfgAddDynamics(builder, dynamicsOffset) KinCfgAddGeometry(builder, geometryOffset) + KinCfgAddFunctions(builder, functionsOffset) return KinCfgEnd(builder) } @@ -74,6 +77,7 @@ func (rcv *KinCfg) UnPackTo(t *KinCfgT) { t.RtInputs = rcv.RtInputs(nil).UnPack() t.Dynamics = rcv.Dynamics(nil).UnPack() t.Geometry = rcv.Geometry(nil).UnPack() + t.Functions = rcv.Functions(nil).UnPack() } func (rcv *KinCfg) UnPack() *KinCfgT { @@ -247,8 +251,23 @@ func (rcv *KinCfg) Geometry(obj *KinGeoCfg) *KinGeoCfg { } /// configuration of the geometry functions of the kinematics +/// configuration for specific functions of this axis +func (rcv *KinCfg) Functions(obj *KinCfgFunctions) *KinCfgFunctions { + o := flatbuffers.UOffsetT(rcv._tab.Offset(22)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(KinCfgFunctions) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// configuration for specific functions of this axis func KinCfgStart(builder *flatbuffers.Builder) { - builder.StartObject(9) + builder.StartObject(10) } func KinCfgAddObjectType(builder *flatbuffers.Builder, objectType flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(objectType), 0) @@ -280,6 +299,9 @@ func KinCfgAddDynamics(builder *flatbuffers.Builder, dynamics flatbuffers.UOffse func KinCfgAddGeometry(builder *flatbuffers.Builder, geometry flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(8, flatbuffers.UOffsetT(geometry), 0) } +func KinCfgAddFunctions(builder *flatbuffers.Builder, functions flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(9, flatbuffers.UOffsetT(functions), 0) +} func KinCfgEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/pkg/fbs/motion/core/fbtypes/KinCfgDriveSLS.go b/pkg/fbs/motion/core/fbtypes/KinCfgDriveSLS.go new file mode 100644 index 0000000..5988009 --- /dev/null +++ b/pkg/fbs/motion/core/fbtypes/KinCfgDriveSLS.go @@ -0,0 +1,101 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// Configuration of motion kernel monitoring and reaction of drive function 'safe limited speed' +type KinCfgDriveSLST struct { + Vel float64 `json:"vel"` + VelUnit string `json:"velUnit"` +} + +func (t *KinCfgDriveSLST) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + velUnitOffset := flatbuffers.UOffsetT(0) + if t.VelUnit != "" { + velUnitOffset = builder.CreateString(t.VelUnit) + } + KinCfgDriveSLSStart(builder) + KinCfgDriveSLSAddVel(builder, t.Vel) + KinCfgDriveSLSAddVelUnit(builder, velUnitOffset) + return KinCfgDriveSLSEnd(builder) +} + +func (rcv *KinCfgDriveSLS) UnPackTo(t *KinCfgDriveSLST) { + t.Vel = rcv.Vel() + t.VelUnit = string(rcv.VelUnit()) +} + +func (rcv *KinCfgDriveSLS) UnPack() *KinCfgDriveSLST { + if rcv == nil { return nil } + t := &KinCfgDriveSLST{} + rcv.UnPackTo(t) + return t +} + +type KinCfgDriveSLS struct { + _tab flatbuffers.Table +} + +func GetRootAsKinCfgDriveSLS(buf []byte, offset flatbuffers.UOffsetT) *KinCfgDriveSLS { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &KinCfgDriveSLS{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsKinCfgDriveSLS(buf []byte, offset flatbuffers.UOffsetT) *KinCfgDriveSLS { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &KinCfgDriveSLS{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *KinCfgDriveSLS) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *KinCfgDriveSLS) Table() flatbuffers.Table { + return rcv._tab +} + +/// velocity limit for the kinematic in the motion kernel, when drive function 'safe limited speed' of an axis is active +func (rcv *KinCfgDriveSLS) Vel() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +/// velocity limit for the kinematic in the motion kernel, when drive function 'safe limited speed' of an axis is active +func (rcv *KinCfgDriveSLS) MutateVel(n float64) bool { + return rcv._tab.MutateFloat64Slot(4, n) +} + +/// unit of vel +func (rcv *KinCfgDriveSLS) VelUnit() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// unit of vel +func KinCfgDriveSLSStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func KinCfgDriveSLSAddVel(builder *flatbuffers.Builder, vel float64) { + builder.PrependFloat64Slot(0, vel, 0.0) +} +func KinCfgDriveSLSAddVelUnit(builder *flatbuffers.Builder, velUnit flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(velUnit), 0) +} +func KinCfgDriveSLSEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/core/fbtypes/KinCfgFunctions.go b/pkg/fbs/motion/core/fbtypes/KinCfgFunctions.go new file mode 100644 index 0000000..55b28a2 --- /dev/null +++ b/pkg/fbs/motion/core/fbtypes/KinCfgFunctions.go @@ -0,0 +1,83 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// configuration for specific functions of this axis +type KinCfgFunctionsT struct { + KinCfgDriveSls *KinCfgDriveSLST `json:"kinCfgDriveSLS"` +} + +func (t *KinCfgFunctionsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + kinCfgDriveSlsOffset := t.KinCfgDriveSls.Pack(builder) + KinCfgFunctionsStart(builder) + KinCfgFunctionsAddKinCfgDriveSls(builder, kinCfgDriveSlsOffset) + return KinCfgFunctionsEnd(builder) +} + +func (rcv *KinCfgFunctions) UnPackTo(t *KinCfgFunctionsT) { + t.KinCfgDriveSls = rcv.KinCfgDriveSls(nil).UnPack() +} + +func (rcv *KinCfgFunctions) UnPack() *KinCfgFunctionsT { + if rcv == nil { return nil } + t := &KinCfgFunctionsT{} + rcv.UnPackTo(t) + return t +} + +type KinCfgFunctions struct { + _tab flatbuffers.Table +} + +func GetRootAsKinCfgFunctions(buf []byte, offset flatbuffers.UOffsetT) *KinCfgFunctions { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &KinCfgFunctions{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsKinCfgFunctions(buf []byte, offset flatbuffers.UOffsetT) *KinCfgFunctions { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &KinCfgFunctions{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *KinCfgFunctions) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *KinCfgFunctions) Table() flatbuffers.Table { + return rcv._tab +} + +/// configuration of monitoring of the safe limited speed in the drive by the motion kernel +func (rcv *KinCfgFunctions) KinCfgDriveSls(obj *KinCfgDriveSLS) *KinCfgDriveSLS { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(KinCfgDriveSLS) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// configuration of monitoring of the safe limited speed in the drive by the motion kernel +func KinCfgFunctionsStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func KinCfgFunctionsAddKinCfgDriveSls(builder *flatbuffers.Builder, kinCfgDriveSls flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(kinCfgDriveSls), 0) +} +func KinCfgFunctionsEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/core/fbtypes/KinCfgJntTrafoSet.go b/pkg/fbs/motion/core/fbtypes/KinCfgJntTrafoSet.go index 62bfa27..bbe4bc0 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCfgJntTrafoSet.go +++ b/pkg/fbs/motion/core/fbtypes/KinCfgJntTrafoSet.go @@ -11,6 +11,7 @@ type KinCfgJntTrafoSetT struct { Name string `json:"name"` JntTrafo string `json:"jntTrafo"` Param *KinCfgJntTrafoAllParamT `json:"param"` + UiData string `json:"uiData"` } func (t *KinCfgJntTrafoSetT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { @@ -24,10 +25,15 @@ func (t *KinCfgJntTrafoSetT) Pack(builder *flatbuffers.Builder) flatbuffers.UOff jntTrafoOffset = builder.CreateString(t.JntTrafo) } paramOffset := t.Param.Pack(builder) + uiDataOffset := flatbuffers.UOffsetT(0) + if t.UiData != "" { + uiDataOffset = builder.CreateString(t.UiData) + } KinCfgJntTrafoSetStart(builder) KinCfgJntTrafoSetAddName(builder, nameOffset) KinCfgJntTrafoSetAddJntTrafo(builder, jntTrafoOffset) KinCfgJntTrafoSetAddParam(builder, paramOffset) + KinCfgJntTrafoSetAddUiData(builder, uiDataOffset) return KinCfgJntTrafoSetEnd(builder) } @@ -35,6 +41,7 @@ func (rcv *KinCfgJntTrafoSet) UnPackTo(t *KinCfgJntTrafoSetT) { t.Name = string(rcv.Name()) t.JntTrafo = string(rcv.JntTrafo()) t.Param = rcv.Param(nil).UnPack() + t.UiData = string(rcv.UiData()) } func (rcv *KinCfgJntTrafoSet) UnPack() *KinCfgJntTrafoSetT { @@ -106,8 +113,18 @@ func (rcv *KinCfgJntTrafoSet) Param(obj *KinCfgJntTrafoAllParam) *KinCfgJntTrafo } /// configuration parameter of the joint transformation +/// user interface data of the joint transformation +func (rcv *KinCfgJntTrafoSet) UiData() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// user interface data of the joint transformation func KinCfgJntTrafoSetStart(builder *flatbuffers.Builder) { - builder.StartObject(3) + builder.StartObject(4) } func KinCfgJntTrafoSetAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0) @@ -118,6 +135,9 @@ func KinCfgJntTrafoSetAddJntTrafo(builder *flatbuffers.Builder, jntTrafo flatbuf func KinCfgJntTrafoSetAddParam(builder *flatbuffers.Builder, param flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(param), 0) } +func KinCfgJntTrafoSetAddUiData(builder *flatbuffers.Builder, uiData flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(uiData), 0) +} func KinCfgJntTrafoSetEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/pkg/fbs/motion/core/fbtypes/KinCmd2dCircleData.go b/pkg/fbs/motion/core/fbtypes/KinCmd2dCircleData.go new file mode 100644 index 0000000..40eda74 --- /dev/null +++ b/pkg/fbs/motion/core/fbtypes/KinCmd2dCircleData.go @@ -0,0 +1,203 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// parameters for the move 2D circular commands for a kinematics +type KinCmd2dCircleDataT struct { + CmdKinPose []*KinCmdPosePairT `json:"cmdKinPose"` + CmdCircleData []*KinCmd2dCircleDataPairT `json:"cmdCircleData"` + CoordSys CoordSys `json:"coordSys"` + Lim *DynamicLimitsT `json:"lim"` +} + +func (t *KinCmd2dCircleDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + cmdKinPoseOffset := flatbuffers.UOffsetT(0) + if t.CmdKinPose != nil { + cmdKinPoseLength := len(t.CmdKinPose) + cmdKinPoseOffsets := make([]flatbuffers.UOffsetT, cmdKinPoseLength) + for j := 0; j < cmdKinPoseLength; j++ { + cmdKinPoseOffsets[j] = t.CmdKinPose[j].Pack(builder) + } + KinCmd2dCircleDataStartCmdKinPoseVector(builder, cmdKinPoseLength) + for j := cmdKinPoseLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(cmdKinPoseOffsets[j]) + } + cmdKinPoseOffset = builder.EndVector(cmdKinPoseLength) + } + cmdCircleDataOffset := flatbuffers.UOffsetT(0) + if t.CmdCircleData != nil { + cmdCircleDataLength := len(t.CmdCircleData) + cmdCircleDataOffsets := make([]flatbuffers.UOffsetT, cmdCircleDataLength) + for j := 0; j < cmdCircleDataLength; j++ { + cmdCircleDataOffsets[j] = t.CmdCircleData[j].Pack(builder) + } + KinCmd2dCircleDataStartCmdCircleDataVector(builder, cmdCircleDataLength) + for j := cmdCircleDataLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(cmdCircleDataOffsets[j]) + } + cmdCircleDataOffset = builder.EndVector(cmdCircleDataLength) + } + limOffset := t.Lim.Pack(builder) + KinCmd2dCircleDataStart(builder) + KinCmd2dCircleDataAddCmdKinPose(builder, cmdKinPoseOffset) + KinCmd2dCircleDataAddCmdCircleData(builder, cmdCircleDataOffset) + KinCmd2dCircleDataAddCoordSys(builder, t.CoordSys) + KinCmd2dCircleDataAddLim(builder, limOffset) + return KinCmd2dCircleDataEnd(builder) +} + +func (rcv *KinCmd2dCircleData) UnPackTo(t *KinCmd2dCircleDataT) { + cmdKinPoseLength := rcv.CmdKinPoseLength() + t.CmdKinPose = make([]*KinCmdPosePairT, cmdKinPoseLength) + for j := 0; j < cmdKinPoseLength; j++ { + x := KinCmdPosePair{} + rcv.CmdKinPose(&x, j) + t.CmdKinPose[j] = x.UnPack() + } + cmdCircleDataLength := rcv.CmdCircleDataLength() + t.CmdCircleData = make([]*KinCmd2dCircleDataPairT, cmdCircleDataLength) + for j := 0; j < cmdCircleDataLength; j++ { + x := KinCmd2dCircleDataPair{} + rcv.CmdCircleData(&x, j) + t.CmdCircleData[j] = x.UnPack() + } + t.CoordSys = rcv.CoordSys() + t.Lim = rcv.Lim(nil).UnPack() +} + +func (rcv *KinCmd2dCircleData) UnPack() *KinCmd2dCircleDataT { + if rcv == nil { return nil } + t := &KinCmd2dCircleDataT{} + rcv.UnPackTo(t) + return t +} + +type KinCmd2dCircleData struct { + _tab flatbuffers.Table +} + +func GetRootAsKinCmd2dCircleData(buf []byte, offset flatbuffers.UOffsetT) *KinCmd2dCircleData { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &KinCmd2dCircleData{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsKinCmd2dCircleData(buf []byte, offset flatbuffers.UOffsetT) *KinCmd2dCircleData { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &KinCmd2dCircleData{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *KinCmd2dCircleData) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *KinCmd2dCircleData) Table() flatbuffers.Table { + return rcv._tab +} + +/// commanded target position with meanings +func (rcv *KinCmd2dCircleData) CmdKinPose(obj *KinCmdPosePair, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Vector(o) + x += flatbuffers.UOffsetT(j) * 4 + x = rcv._tab.Indirect(x) + obj.Init(rcv._tab.Bytes, x) + return true + } + return false +} + +func (rcv *KinCmd2dCircleData) CmdKinPoseLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// commanded target position with meanings +/// commanded circle data with 2d circle meanings +func (rcv *KinCmd2dCircleData) CmdCircleData(obj *KinCmd2dCircleDataPair, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + x := rcv._tab.Vector(o) + x += flatbuffers.UOffsetT(j) * 4 + x = rcv._tab.Indirect(x) + obj.Init(rcv._tab.Bytes, x) + return true + } + return false +} + +func (rcv *KinCmd2dCircleData) CmdCircleDataLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// commanded circle data with 2d circle meanings +/// coordSys for commanded target position +func (rcv *KinCmd2dCircleData) CoordSys() CoordSys { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return CoordSys(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +/// coordSys for commanded target position +func (rcv *KinCmd2dCircleData) MutateCoordSys(n CoordSys) bool { + return rcv._tab.MutateInt8Slot(8, int8(n)) +} + +/// dynamic limits for the motion of this command +func (rcv *KinCmd2dCircleData) Lim(obj *DynamicLimits) *DynamicLimits { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(DynamicLimits) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// dynamic limits for the motion of this command +func KinCmd2dCircleDataStart(builder *flatbuffers.Builder) { + builder.StartObject(4) +} +func KinCmd2dCircleDataAddCmdKinPose(builder *flatbuffers.Builder, cmdKinPose flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(cmdKinPose), 0) +} +func KinCmd2dCircleDataStartCmdKinPoseVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func KinCmd2dCircleDataAddCmdCircleData(builder *flatbuffers.Builder, cmdCircleData flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(cmdCircleData), 0) +} +func KinCmd2dCircleDataStartCmdCircleDataVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func KinCmd2dCircleDataAddCoordSys(builder *flatbuffers.Builder, coordSys CoordSys) { + builder.PrependInt8Slot(2, int8(coordSys), 0) +} +func KinCmd2dCircleDataAddLim(builder *flatbuffers.Builder, lim flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(lim), 0) +} +func KinCmd2dCircleDataEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/core/fbtypes/KinCmd2dCircleDataPair.go b/pkg/fbs/motion/core/fbtypes/KinCmd2dCircleDataPair.go new file mode 100644 index 0000000..407bc9b --- /dev/null +++ b/pkg/fbs/motion/core/fbtypes/KinCmd2dCircleDataPair.go @@ -0,0 +1,105 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// One pair with value and meaning for the internal additional circle data (used for commanding) +type KinCmd2dCircleDataPairT struct { + Value float64 `json:"value"` + ExtMeaning *Ext2dCircleMeaningT `json:"extMeaning"` +} + +func (t *KinCmd2dCircleDataPairT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + extMeaningOffset := t.ExtMeaning.Pack(builder) + KinCmd2dCircleDataPairStart(builder) + KinCmd2dCircleDataPairAddValue(builder, t.Value) + KinCmd2dCircleDataPairAddExtMeaning(builder, extMeaningOffset) + return KinCmd2dCircleDataPairEnd(builder) +} + +func (rcv *KinCmd2dCircleDataPair) UnPackTo(t *KinCmd2dCircleDataPairT) { + t.Value = rcv.Value() + t.ExtMeaning = rcv.ExtMeaning(nil).UnPack() +} + +func (rcv *KinCmd2dCircleDataPair) UnPack() *KinCmd2dCircleDataPairT { + if rcv == nil { return nil } + t := &KinCmd2dCircleDataPairT{} + rcv.UnPackTo(t) + return t +} + +type KinCmd2dCircleDataPair struct { + _tab flatbuffers.Table +} + +func GetRootAsKinCmd2dCircleDataPair(buf []byte, offset flatbuffers.UOffsetT) *KinCmd2dCircleDataPair { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &KinCmd2dCircleDataPair{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsKinCmd2dCircleDataPair(buf []byte, offset flatbuffers.UOffsetT) *KinCmd2dCircleDataPair { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &KinCmd2dCircleDataPair{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *KinCmd2dCircleDataPair) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *KinCmd2dCircleDataPair) Table() flatbuffers.Table { + return rcv._tab +} + +/// one value of a circle data +func (rcv *KinCmd2dCircleDataPair) Value() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +/// one value of a circle data +func (rcv *KinCmd2dCircleDataPair) MutateValue(n float64) bool { + return rcv._tab.MutateFloat64Slot(4, n) +} + +/// related meaning of the value +/// possible meanings are: "MP_X", "MP_Y", "MP_Z", "RADIUS", "REV" +func (rcv *KinCmd2dCircleDataPair) ExtMeaning(obj *Ext2dCircleMeaning) *Ext2dCircleMeaning { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(Ext2dCircleMeaning) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// related meaning of the value +/// possible meanings are: "MP_X", "MP_Y", "MP_Z", "RADIUS", "REV" +func KinCmd2dCircleDataPairStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func KinCmd2dCircleDataPairAddValue(builder *flatbuffers.Builder, value float64) { + builder.PrependFloat64Slot(0, value, 0.0) +} +func KinCmd2dCircleDataPairAddExtMeaning(builder *flatbuffers.Builder, extMeaning flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(extMeaning), 0) +} +func KinCmd2dCircleDataPairEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/core/fbtypes/KinCmdCircleData.go b/pkg/fbs/motion/core/fbtypes/KinCmd3dCircleData.go similarity index 59% rename from pkg/fbs/motion/core/fbtypes/KinCmdCircleData.go rename to pkg/fbs/motion/core/fbtypes/KinCmd3dCircleData.go index ac255dd..a82e17f 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCmdCircleData.go +++ b/pkg/fbs/motion/core/fbtypes/KinCmd3dCircleData.go @@ -7,14 +7,14 @@ import ( ) /// parameters for the move 3D circular commands for a kinematics -type KinCmdCircleDataT struct { +type KinCmd3dCircleDataT struct { CmdKinPose []*KinCmdPosePairT `json:"cmdKinPose"` - CmdCircleData []*KinCmdCircleDataPairT `json:"cmdCircleData"` + CmdCircleData []*KinCmd3dCircleDataPairT `json:"cmdCircleData"` CoordSys CoordSys `json:"coordSys"` Lim *DynamicLimitsT `json:"lim"` } -func (t *KinCmdCircleDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { +func (t *KinCmd3dCircleDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { if t == nil { return 0 } cmdKinPoseOffset := flatbuffers.UOffsetT(0) if t.CmdKinPose != nil { @@ -23,7 +23,7 @@ func (t *KinCmdCircleDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffs for j := 0; j < cmdKinPoseLength; j++ { cmdKinPoseOffsets[j] = t.CmdKinPose[j].Pack(builder) } - KinCmdCircleDataStartCmdKinPoseVector(builder, cmdKinPoseLength) + KinCmd3dCircleDataStartCmdKinPoseVector(builder, cmdKinPoseLength) for j := cmdKinPoseLength - 1; j >= 0; j-- { builder.PrependUOffsetT(cmdKinPoseOffsets[j]) } @@ -36,22 +36,22 @@ func (t *KinCmdCircleDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffs for j := 0; j < cmdCircleDataLength; j++ { cmdCircleDataOffsets[j] = t.CmdCircleData[j].Pack(builder) } - KinCmdCircleDataStartCmdCircleDataVector(builder, cmdCircleDataLength) + KinCmd3dCircleDataStartCmdCircleDataVector(builder, cmdCircleDataLength) for j := cmdCircleDataLength - 1; j >= 0; j-- { builder.PrependUOffsetT(cmdCircleDataOffsets[j]) } cmdCircleDataOffset = builder.EndVector(cmdCircleDataLength) } limOffset := t.Lim.Pack(builder) - KinCmdCircleDataStart(builder) - KinCmdCircleDataAddCmdKinPose(builder, cmdKinPoseOffset) - KinCmdCircleDataAddCmdCircleData(builder, cmdCircleDataOffset) - KinCmdCircleDataAddCoordSys(builder, t.CoordSys) - KinCmdCircleDataAddLim(builder, limOffset) - return KinCmdCircleDataEnd(builder) + KinCmd3dCircleDataStart(builder) + KinCmd3dCircleDataAddCmdKinPose(builder, cmdKinPoseOffset) + KinCmd3dCircleDataAddCmdCircleData(builder, cmdCircleDataOffset) + KinCmd3dCircleDataAddCoordSys(builder, t.CoordSys) + KinCmd3dCircleDataAddLim(builder, limOffset) + return KinCmd3dCircleDataEnd(builder) } -func (rcv *KinCmdCircleData) UnPackTo(t *KinCmdCircleDataT) { +func (rcv *KinCmd3dCircleData) UnPackTo(t *KinCmd3dCircleDataT) { cmdKinPoseLength := rcv.CmdKinPoseLength() t.CmdKinPose = make([]*KinCmdPosePairT, cmdKinPoseLength) for j := 0; j < cmdKinPoseLength; j++ { @@ -60,9 +60,9 @@ func (rcv *KinCmdCircleData) UnPackTo(t *KinCmdCircleDataT) { t.CmdKinPose[j] = x.UnPack() } cmdCircleDataLength := rcv.CmdCircleDataLength() - t.CmdCircleData = make([]*KinCmdCircleDataPairT, cmdCircleDataLength) + t.CmdCircleData = make([]*KinCmd3dCircleDataPairT, cmdCircleDataLength) for j := 0; j < cmdCircleDataLength; j++ { - x := KinCmdCircleDataPair{} + x := KinCmd3dCircleDataPair{} rcv.CmdCircleData(&x, j) t.CmdCircleData[j] = x.UnPack() } @@ -70,42 +70,42 @@ func (rcv *KinCmdCircleData) UnPackTo(t *KinCmdCircleDataT) { t.Lim = rcv.Lim(nil).UnPack() } -func (rcv *KinCmdCircleData) UnPack() *KinCmdCircleDataT { +func (rcv *KinCmd3dCircleData) UnPack() *KinCmd3dCircleDataT { if rcv == nil { return nil } - t := &KinCmdCircleDataT{} + t := &KinCmd3dCircleDataT{} rcv.UnPackTo(t) return t } -type KinCmdCircleData struct { +type KinCmd3dCircleData struct { _tab flatbuffers.Table } -func GetRootAsKinCmdCircleData(buf []byte, offset flatbuffers.UOffsetT) *KinCmdCircleData { +func GetRootAsKinCmd3dCircleData(buf []byte, offset flatbuffers.UOffsetT) *KinCmd3dCircleData { n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &KinCmdCircleData{} + x := &KinCmd3dCircleData{} x.Init(buf, n+offset) return x } -func GetSizePrefixedRootAsKinCmdCircleData(buf []byte, offset flatbuffers.UOffsetT) *KinCmdCircleData { +func GetSizePrefixedRootAsKinCmd3dCircleData(buf []byte, offset flatbuffers.UOffsetT) *KinCmd3dCircleData { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &KinCmdCircleData{} + x := &KinCmd3dCircleData{} x.Init(buf, n+offset+flatbuffers.SizeUint32) return x } -func (rcv *KinCmdCircleData) Init(buf []byte, i flatbuffers.UOffsetT) { +func (rcv *KinCmd3dCircleData) Init(buf []byte, i flatbuffers.UOffsetT) { rcv._tab.Bytes = buf rcv._tab.Pos = i } -func (rcv *KinCmdCircleData) Table() flatbuffers.Table { +func (rcv *KinCmd3dCircleData) Table() flatbuffers.Table { return rcv._tab } /// commanded target position with meanings -func (rcv *KinCmdCircleData) CmdKinPose(obj *KinCmdPosePair, j int) bool { +func (rcv *KinCmd3dCircleData) CmdKinPose(obj *KinCmdPosePair, j int) bool { o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) if o != 0 { x := rcv._tab.Vector(o) @@ -117,7 +117,7 @@ func (rcv *KinCmdCircleData) CmdKinPose(obj *KinCmdPosePair, j int) bool { return false } -func (rcv *KinCmdCircleData) CmdKinPoseLength() int { +func (rcv *KinCmd3dCircleData) CmdKinPoseLength() int { o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) if o != 0 { return rcv._tab.VectorLen(o) @@ -126,8 +126,8 @@ func (rcv *KinCmdCircleData) CmdKinPoseLength() int { } /// commanded target position with meanings -/// commanded circle data with circle meanings -func (rcv *KinCmdCircleData) CmdCircleData(obj *KinCmdCircleDataPair, j int) bool { +/// commanded circle data with 3d circle meanings +func (rcv *KinCmd3dCircleData) CmdCircleData(obj *KinCmd3dCircleDataPair, j int) bool { o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) if o != 0 { x := rcv._tab.Vector(o) @@ -139,7 +139,7 @@ func (rcv *KinCmdCircleData) CmdCircleData(obj *KinCmdCircleDataPair, j int) boo return false } -func (rcv *KinCmdCircleData) CmdCircleDataLength() int { +func (rcv *KinCmd3dCircleData) CmdCircleDataLength() int { o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) if o != 0 { return rcv._tab.VectorLen(o) @@ -147,9 +147,9 @@ func (rcv *KinCmdCircleData) CmdCircleDataLength() int { return 0 } -/// commanded circle data with circle meanings +/// commanded circle data with 3d circle meanings /// coordSys for commanded target position -func (rcv *KinCmdCircleData) CoordSys() CoordSys { +func (rcv *KinCmd3dCircleData) CoordSys() CoordSys { o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) if o != 0 { return CoordSys(rcv._tab.GetInt8(o + rcv._tab.Pos)) @@ -158,12 +158,12 @@ func (rcv *KinCmdCircleData) CoordSys() CoordSys { } /// coordSys for commanded target position -func (rcv *KinCmdCircleData) MutateCoordSys(n CoordSys) bool { +func (rcv *KinCmd3dCircleData) MutateCoordSys(n CoordSys) bool { return rcv._tab.MutateInt8Slot(8, int8(n)) } /// dynamic limits for the motion of this command -func (rcv *KinCmdCircleData) Lim(obj *DynamicLimits) *DynamicLimits { +func (rcv *KinCmd3dCircleData) Lim(obj *DynamicLimits) *DynamicLimits { o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) if o != 0 { x := rcv._tab.Indirect(o + rcv._tab.Pos) @@ -177,27 +177,27 @@ func (rcv *KinCmdCircleData) Lim(obj *DynamicLimits) *DynamicLimits { } /// dynamic limits for the motion of this command -func KinCmdCircleDataStart(builder *flatbuffers.Builder) { +func KinCmd3dCircleDataStart(builder *flatbuffers.Builder) { builder.StartObject(4) } -func KinCmdCircleDataAddCmdKinPose(builder *flatbuffers.Builder, cmdKinPose flatbuffers.UOffsetT) { +func KinCmd3dCircleDataAddCmdKinPose(builder *flatbuffers.Builder, cmdKinPose flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(cmdKinPose), 0) } -func KinCmdCircleDataStartCmdKinPoseVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { +func KinCmd3dCircleDataStartCmdKinPoseVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { return builder.StartVector(4, numElems, 4) } -func KinCmdCircleDataAddCmdCircleData(builder *flatbuffers.Builder, cmdCircleData flatbuffers.UOffsetT) { +func KinCmd3dCircleDataAddCmdCircleData(builder *flatbuffers.Builder, cmdCircleData flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(cmdCircleData), 0) } -func KinCmdCircleDataStartCmdCircleDataVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { +func KinCmd3dCircleDataStartCmdCircleDataVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { return builder.StartVector(4, numElems, 4) } -func KinCmdCircleDataAddCoordSys(builder *flatbuffers.Builder, coordSys CoordSys) { +func KinCmd3dCircleDataAddCoordSys(builder *flatbuffers.Builder, coordSys CoordSys) { builder.PrependInt8Slot(2, int8(coordSys), 0) } -func KinCmdCircleDataAddLim(builder *flatbuffers.Builder, lim flatbuffers.UOffsetT) { +func KinCmd3dCircleDataAddLim(builder *flatbuffers.Builder, lim flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(lim), 0) } -func KinCmdCircleDataEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { +func KinCmd3dCircleDataEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/pkg/fbs/motion/core/fbtypes/KinCmd3dCircleDataPair.go b/pkg/fbs/motion/core/fbtypes/KinCmd3dCircleDataPair.go new file mode 100644 index 0000000..a4f9497 --- /dev/null +++ b/pkg/fbs/motion/core/fbtypes/KinCmd3dCircleDataPair.go @@ -0,0 +1,105 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// One pair with value and meaning for the internal additional circle data (used for commanding) +type KinCmd3dCircleDataPairT struct { + Value float64 `json:"value"` + ExtMeaning *Ext3dCircleMeaningT `json:"extMeaning"` +} + +func (t *KinCmd3dCircleDataPairT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + extMeaningOffset := t.ExtMeaning.Pack(builder) + KinCmd3dCircleDataPairStart(builder) + KinCmd3dCircleDataPairAddValue(builder, t.Value) + KinCmd3dCircleDataPairAddExtMeaning(builder, extMeaningOffset) + return KinCmd3dCircleDataPairEnd(builder) +} + +func (rcv *KinCmd3dCircleDataPair) UnPackTo(t *KinCmd3dCircleDataPairT) { + t.Value = rcv.Value() + t.ExtMeaning = rcv.ExtMeaning(nil).UnPack() +} + +func (rcv *KinCmd3dCircleDataPair) UnPack() *KinCmd3dCircleDataPairT { + if rcv == nil { return nil } + t := &KinCmd3dCircleDataPairT{} + rcv.UnPackTo(t) + return t +} + +type KinCmd3dCircleDataPair struct { + _tab flatbuffers.Table +} + +func GetRootAsKinCmd3dCircleDataPair(buf []byte, offset flatbuffers.UOffsetT) *KinCmd3dCircleDataPair { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &KinCmd3dCircleDataPair{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsKinCmd3dCircleDataPair(buf []byte, offset flatbuffers.UOffsetT) *KinCmd3dCircleDataPair { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &KinCmd3dCircleDataPair{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *KinCmd3dCircleDataPair) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *KinCmd3dCircleDataPair) Table() flatbuffers.Table { + return rcv._tab +} + +/// one value of a circle data +func (rcv *KinCmd3dCircleDataPair) Value() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +/// one value of a circle data +func (rcv *KinCmd3dCircleDataPair) MutateValue(n float64) bool { + return rcv._tab.MutateFloat64Slot(4, n) +} + +/// related meaning of the value +/// possible meanings are: "IP_X", "IP_Y", "IP_Z" +func (rcv *KinCmd3dCircleDataPair) ExtMeaning(obj *Ext3dCircleMeaning) *Ext3dCircleMeaning { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(Ext3dCircleMeaning) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// related meaning of the value +/// possible meanings are: "IP_X", "IP_Y", "IP_Z" +func KinCmd3dCircleDataPairStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func KinCmd3dCircleDataPairAddValue(builder *flatbuffers.Builder, value float64) { + builder.PrependFloat64Slot(0, value, 0.0) +} +func KinCmd3dCircleDataPairAddExtMeaning(builder *flatbuffers.Builder, extMeaning flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(extMeaning), 0) +} +func KinCmd3dCircleDataPairEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/core/fbtypes/KinCmdCircleDataPair.go b/pkg/fbs/motion/core/fbtypes/KinCmdCircleDataPair.go deleted file mode 100644 index 2fa5e20..0000000 --- a/pkg/fbs/motion/core/fbtypes/KinCmdCircleDataPair.go +++ /dev/null @@ -1,105 +0,0 @@ -// Code generated by the FlatBuffers compiler. DO NOT EDIT. - -package fbtypes - -import ( - flatbuffers "github.com/google/flatbuffers/go" -) - -/// One pair with value and meaning for the internal additional circle data (used for commanding) -type KinCmdCircleDataPairT struct { - Value float64 `json:"value"` - ExtMeaning *ExtCircleMeaningT `json:"extMeaning"` -} - -func (t *KinCmdCircleDataPairT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - if t == nil { return 0 } - extMeaningOffset := t.ExtMeaning.Pack(builder) - KinCmdCircleDataPairStart(builder) - KinCmdCircleDataPairAddValue(builder, t.Value) - KinCmdCircleDataPairAddExtMeaning(builder, extMeaningOffset) - return KinCmdCircleDataPairEnd(builder) -} - -func (rcv *KinCmdCircleDataPair) UnPackTo(t *KinCmdCircleDataPairT) { - t.Value = rcv.Value() - t.ExtMeaning = rcv.ExtMeaning(nil).UnPack() -} - -func (rcv *KinCmdCircleDataPair) UnPack() *KinCmdCircleDataPairT { - if rcv == nil { return nil } - t := &KinCmdCircleDataPairT{} - rcv.UnPackTo(t) - return t -} - -type KinCmdCircleDataPair struct { - _tab flatbuffers.Table -} - -func GetRootAsKinCmdCircleDataPair(buf []byte, offset flatbuffers.UOffsetT) *KinCmdCircleDataPair { - n := flatbuffers.GetUOffsetT(buf[offset:]) - x := &KinCmdCircleDataPair{} - x.Init(buf, n+offset) - return x -} - -func GetSizePrefixedRootAsKinCmdCircleDataPair(buf []byte, offset flatbuffers.UOffsetT) *KinCmdCircleDataPair { - n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) - x := &KinCmdCircleDataPair{} - x.Init(buf, n+offset+flatbuffers.SizeUint32) - return x -} - -func (rcv *KinCmdCircleDataPair) Init(buf []byte, i flatbuffers.UOffsetT) { - rcv._tab.Bytes = buf - rcv._tab.Pos = i -} - -func (rcv *KinCmdCircleDataPair) Table() flatbuffers.Table { - return rcv._tab -} - -/// one value of a circle data -func (rcv *KinCmdCircleDataPair) Value() float64 { - o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) - if o != 0 { - return rcv._tab.GetFloat64(o + rcv._tab.Pos) - } - return 0.0 -} - -/// one value of a circle data -func (rcv *KinCmdCircleDataPair) MutateValue(n float64) bool { - return rcv._tab.MutateFloat64Slot(4, n) -} - -/// related meaning of the value -/// possible meanings are: "UNDEF", "MP_X", "MP_Y", "MP_Z", "RADIUS", "IP_X", "IP_Y", "IP_Z" -func (rcv *KinCmdCircleDataPair) ExtMeaning(obj *ExtCircleMeaning) *ExtCircleMeaning { - o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) - if o != 0 { - x := rcv._tab.Indirect(o + rcv._tab.Pos) - if obj == nil { - obj = new(ExtCircleMeaning) - } - obj.Init(rcv._tab.Bytes, x) - return obj - } - return nil -} - -/// related meaning of the value -/// possible meanings are: "UNDEF", "MP_X", "MP_Y", "MP_Z", "RADIUS", "IP_X", "IP_Y", "IP_Z" -func KinCmdCircleDataPairStart(builder *flatbuffers.Builder) { - builder.StartObject(2) -} -func KinCmdCircleDataPairAddValue(builder *flatbuffers.Builder, value float64) { - builder.PrependFloat64Slot(0, value, 0.0) -} -func KinCmdCircleDataPairAddExtMeaning(builder *flatbuffers.Builder, extMeaning flatbuffers.UOffsetT) { - builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(extMeaning), 0) -} -func KinCmdCircleDataPairEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - return builder.EndObject() -} diff --git a/pkg/fbs/motion/core/fbtypes/KinCmdOptActivePlaneData.go b/pkg/fbs/motion/core/fbtypes/KinCmdOptActivePlaneData.go index 2aa062b..a75e4c8 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCmdOptActivePlaneData.go +++ b/pkg/fbs/motion/core/fbtypes/KinCmdOptActivePlaneData.go @@ -63,7 +63,7 @@ func (rcv *KinCmdOptActivePlaneData) Table() flatbuffers.Table { return rcv._tab } -/// permanent type (e.g. "PermOn") +/// permanent type (either "PermOn" or any other string to switch off) func (rcv *KinCmdOptActivePlaneData) PermType() []byte { o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) if o != 0 { @@ -72,7 +72,7 @@ func (rcv *KinCmdOptActivePlaneData) PermType() []byte { return nil } -/// permanent type (e.g. "PermOn") +/// permanent type (either "PermOn" or any other string to switch off) /// type of the new active plane func (rcv *KinCmdOptActivePlaneData) Plane() ActivePlaneType { o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) diff --git a/pkg/fbs/motion/core/fbtypes/KinCmdOptBlendData.go b/pkg/fbs/motion/core/fbtypes/KinCmdOptBlendData.go index 2ed1116..a59dcfd 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCmdOptBlendData.go +++ b/pkg/fbs/motion/core/fbtypes/KinCmdOptBlendData.go @@ -66,7 +66,7 @@ func (rcv *KinCmdOptBlendData) Table() flatbuffers.Table { return rcv._tab } -/// permanent type (e.g. "Once") +/// permanent type ("Once", "PermOn" or any other string to switch the permanent command option off) func (rcv *KinCmdOptBlendData) PermType() []byte { o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) if o != 0 { @@ -75,7 +75,7 @@ func (rcv *KinCmdOptBlendData) PermType() []byte { return nil } -/// permanent type (e.g. "Once") +/// permanent type ("Once", "PermOn" or any other string to switch the permanent command option off) /// distance D1 (refer to the manual, should be greater than zero) func (rcv *KinCmdOptBlendData) Dist1() float64 { o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) diff --git a/pkg/fbs/motion/core/fbtypes/KinCmdOptFeedGroupData.go b/pkg/fbs/motion/core/fbtypes/KinCmdOptFeedGroupData.go index 24ae685..3217029 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCmdOptFeedGroupData.go +++ b/pkg/fbs/motion/core/fbtypes/KinCmdOptFeedGroupData.go @@ -63,7 +63,7 @@ func (rcv *KinCmdOptFeedGroupData) Table() flatbuffers.Table { return rcv._tab } -/// permanent type (e.g. "PermOn") +/// permanent type ("Once", "PermOn" or any other string to switch the permanent command option off) func (rcv *KinCmdOptFeedGroupData) PermType() []byte { o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) if o != 0 { @@ -72,7 +72,7 @@ func (rcv *KinCmdOptFeedGroupData) PermType() []byte { return nil } -/// permanent type (e.g. "PermOn") +/// permanent type ("Once", "PermOn" or any other string to switch the permanent command option off) /// name of the feedGroup that should be used to define the path parameter (default FG_XYZ) /// possible feedGroups are: "FG_XYZ", "FG_XYZ_O", "FG_XYZ_A", "FG_XYZ_O_A" func (rcv *KinCmdOptFeedGroupData) Type() FeedGroup { diff --git a/pkg/fbs/motion/core/fbtypes/KinCmdOptMCSData.go b/pkg/fbs/motion/core/fbtypes/KinCmdOptMCSData.go index f8ee3b1..191aeaa 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCmdOptMCSData.go +++ b/pkg/fbs/motion/core/fbtypes/KinCmdOptMCSData.go @@ -67,7 +67,7 @@ func (rcv *KinCmdOptMCSData) Table() flatbuffers.Table { return rcv._tab } -/// permanent type (e.g. "PermOn") +/// permanent type (either "PermOn" or any other string to switch off) func (rcv *KinCmdOptMCSData) PermType() []byte { o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) if o != 0 { @@ -76,7 +76,7 @@ func (rcv *KinCmdOptMCSData) PermType() []byte { return nil } -/// permanent type (e.g. "PermOn") +/// permanent type (either "PermOn" or any other string to switch off) /// name of the joint transformation set that should become active func (rcv *KinCmdOptMCSData) SetName() []byte { o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) diff --git a/pkg/fbs/motion/core/fbtypes/KinCmdOptPCSData.go b/pkg/fbs/motion/core/fbtypes/KinCmdOptPCSData.go index 9d6af84..c0106e5 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCmdOptPCSData.go +++ b/pkg/fbs/motion/core/fbtypes/KinCmdOptPCSData.go @@ -67,7 +67,7 @@ func (rcv *KinCmdOptPCSData) Table() flatbuffers.Table { return rcv._tab } -/// permanent type (e.g. "PermOn") +/// permanent type (either "PermOn" or any other string to switch off) func (rcv *KinCmdOptPCSData) PermType() []byte { o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) if o != 0 { @@ -76,7 +76,7 @@ func (rcv *KinCmdOptPCSData) PermType() []byte { return nil } -/// permanent type (e.g. "PermOn") +/// permanent type (either "PermOn" or any other string to switch off) /// name of the set/group that should become active func (rcv *KinCmdOptPCSData) SetName() []byte { o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) diff --git a/pkg/fbs/motion/core/fbtypes/KinCmdOptPolyTransData.go b/pkg/fbs/motion/core/fbtypes/KinCmdOptPolyTransData.go index 9532dd5..226dc7b 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCmdOptPolyTransData.go +++ b/pkg/fbs/motion/core/fbtypes/KinCmdOptPolyTransData.go @@ -69,7 +69,7 @@ func (rcv *KinCmdOptPolyTransData) Table() flatbuffers.Table { return rcv._tab } -/// permanent type (e.g. "PermOn") +/// permanent type (either "PermOn" or any other string to switch off) func (rcv *KinCmdOptPolyTransData) PermType() []byte { o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) if o != 0 { @@ -78,7 +78,7 @@ func (rcv *KinCmdOptPolyTransData) PermType() []byte { return nil } -/// permanent type (e.g. "PermOn") +/// permanent type (either "PermOn" or any other string to switch off) /// optional distance D1 (distance to shorten the start of the precorner, must be greater than zero) /// when dist1 is greater then zero, also dist2 must be greater than zero; eps must not be set in this case (or equal zero) func (rcv *KinCmdOptPolyTransData) Dist1() float64 { diff --git a/pkg/fbs/motion/core/fbtypes/KinCmdOptSafeAreaData.go b/pkg/fbs/motion/core/fbtypes/KinCmdOptSafeAreaData.go index bfd3705..cb87056 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCmdOptSafeAreaData.go +++ b/pkg/fbs/motion/core/fbtypes/KinCmdOptSafeAreaData.go @@ -67,7 +67,7 @@ func (rcv *KinCmdOptSafeAreaData) Table() flatbuffers.Table { return rcv._tab } -/// permanent type (e.g. "PermOn") +/// permanent type (either "PermOn" or any other string to switch off) func (rcv *KinCmdOptSafeAreaData) PermType() []byte { o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) if o != 0 { @@ -76,7 +76,7 @@ func (rcv *KinCmdOptSafeAreaData) PermType() []byte { return nil } -/// permanent type (e.g. "PermOn") +/// permanent type (either "PermOn" or any other string to switch off) /// name of the safe zone or work area that should become active/disabled as set in the configuration func (rcv *KinCmdOptSafeAreaData) SafeArea() []byte { o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) diff --git a/pkg/fbs/motion/core/fbtypes/KinCmdOptToolLengthData.go b/pkg/fbs/motion/core/fbtypes/KinCmdOptToolLengthData.go index d1a81b4..97e9b9d 100644 --- a/pkg/fbs/motion/core/fbtypes/KinCmdOptToolLengthData.go +++ b/pkg/fbs/motion/core/fbtypes/KinCmdOptToolLengthData.go @@ -67,7 +67,7 @@ func (rcv *KinCmdOptToolLengthData) Table() flatbuffers.Table { return rcv._tab } -/// permanent type (e.g. "PermOn") +/// permanent type (either "PermOn" or any other string to switch off) func (rcv *KinCmdOptToolLengthData) PermType() []byte { o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) if o != 0 { @@ -76,7 +76,7 @@ func (rcv *KinCmdOptToolLengthData) PermType() []byte { return nil } -/// permanent type (e.g. "PermOn") +/// permanent type (either "PermOn" or any other string to switch off) /// name of the set/group that should become active func (rcv *KinCmdOptToolLengthData) SetName() []byte { o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) diff --git a/pkg/fbs/motion/core/fbtypes/KinStateJntTrafoDataReqAxisType.go b/pkg/fbs/motion/core/fbtypes/KinStateJntTrafoDataReqAxisType.go index a47e5c4..4110ad5 100644 --- a/pkg/fbs/motion/core/fbtypes/KinStateJntTrafoDataReqAxisType.go +++ b/pkg/fbs/motion/core/fbtypes/KinStateJntTrafoDataReqAxisType.go @@ -9,7 +9,7 @@ type KinStateJntTrafoDataReqAxisType int8 const ( /// any kind of axis is okay - KinStateJntTrafoDataReqAxisTypeANY KinStateJntTrafoDataReqAxisType = 0 + KinStateJntTrafoDataReqAxisTypeANY_TYPE KinStateJntTrafoDataReqAxisType = 0 ///< a linear axis is requested KinStateJntTrafoDataReqAxisTypeLINEAR KinStateJntTrafoDataReqAxisType = 1 /// a rotational axis is requested @@ -17,13 +17,13 @@ const ( ) var EnumNamesKinStateJntTrafoDataReqAxisType = map[KinStateJntTrafoDataReqAxisType]string{ - KinStateJntTrafoDataReqAxisTypeANY: "ANY", + KinStateJntTrafoDataReqAxisTypeANY_TYPE: "ANY_TYPE", KinStateJntTrafoDataReqAxisTypeLINEAR: "LINEAR", KinStateJntTrafoDataReqAxisTypeROTATIONAL: "ROTATIONAL", } var EnumValuesKinStateJntTrafoDataReqAxisType = map[string]KinStateJntTrafoDataReqAxisType{ - "ANY": KinStateJntTrafoDataReqAxisTypeANY, + "ANY_TYPE": KinStateJntTrafoDataReqAxisTypeANY_TYPE, "LINEAR": KinStateJntTrafoDataReqAxisTypeLINEAR, "ROTATIONAL": KinStateJntTrafoDataReqAxisTypeROTATIONAL, } diff --git a/pkg/fbs/motion/core/fbtypes/StateDataItems.go b/pkg/fbs/motion/core/fbtypes/StateDataItems.go new file mode 100644 index 0000000..f1fcaaa --- /dev/null +++ b/pkg/fbs/motion/core/fbtypes/StateDataItems.go @@ -0,0 +1,111 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// information on all available data items +type StateDataItemsT struct { + Items []*DataItemT `json:"items"` +} + +func (t *StateDataItemsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + itemsOffset := flatbuffers.UOffsetT(0) + if t.Items != nil { + itemsLength := len(t.Items) + itemsOffsets := make([]flatbuffers.UOffsetT, itemsLength) + for j := 0; j < itemsLength; j++ { + itemsOffsets[j] = t.Items[j].Pack(builder) + } + StateDataItemsStartItemsVector(builder, itemsLength) + for j := itemsLength - 1; j >= 0; j-- { + builder.PrependUOffsetT(itemsOffsets[j]) + } + itemsOffset = builder.EndVector(itemsLength) + } + StateDataItemsStart(builder) + StateDataItemsAddItems(builder, itemsOffset) + return StateDataItemsEnd(builder) +} + +func (rcv *StateDataItems) UnPackTo(t *StateDataItemsT) { + itemsLength := rcv.ItemsLength() + t.Items = make([]*DataItemT, itemsLength) + for j := 0; j < itemsLength; j++ { + x := DataItem{} + rcv.Items(&x, j) + t.Items[j] = x.UnPack() + } +} + +func (rcv *StateDataItems) UnPack() *StateDataItemsT { + if rcv == nil { return nil } + t := &StateDataItemsT{} + rcv.UnPackTo(t) + return t +} + +type StateDataItems struct { + _tab flatbuffers.Table +} + +func GetRootAsStateDataItems(buf []byte, offset flatbuffers.UOffsetT) *StateDataItems { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &StateDataItems{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsStateDataItems(buf []byte, offset flatbuffers.UOffsetT) *StateDataItems { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &StateDataItems{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *StateDataItems) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *StateDataItems) Table() flatbuffers.Table { + return rcv._tab +} + +/// all available data items (URI and current value) +func (rcv *StateDataItems) Items(obj *DataItem, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Vector(o) + x += flatbuffers.UOffsetT(j) * 4 + x = rcv._tab.Indirect(x) + obj.Init(rcv._tab.Bytes, x) + return true + } + return false +} + +func (rcv *StateDataItems) ItemsLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +/// all available data items (URI and current value) +func StateDataItemsStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func StateDataItemsAddItems(builder *flatbuffers.Builder, items flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(items), 0) +} +func StateDataItemsStartItemsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func StateDataItemsEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/somo/fbtypes/CmdOptionSwitchOnPath.go b/pkg/fbs/motion/somo/fbtypes/CmdOptionSwitchOnPath.go index 41c7a95..e626098 100644 --- a/pkg/fbs/motion/somo/fbtypes/CmdOptionSwitchOnPath.go +++ b/pkg/fbs/motion/somo/fbtypes/CmdOptionSwitchOnPath.go @@ -90,7 +90,7 @@ func (rcv *CmdOptionSwitchOnPath) Table() flatbuffers.Table { return rcv._tab } -/// permanent type (e.g. "Once") +/// permanent type (e.g. "Once", "PermOn", "PermOff") func (rcv *CmdOptionSwitchOnPath) PermType() []byte { o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) if o != 0 { @@ -99,7 +99,8 @@ func (rcv *CmdOptionSwitchOnPath) PermType() []byte { return nil } -/// permanent type (e.g. "Once") +/// permanent type (e.g. "Once", "PermOn", "PermOff") +/// switch on path mode func (rcv *CmdOptionSwitchOnPath) Mode() SwitchOnPathMode { o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) if o != 0 { @@ -108,11 +109,12 @@ func (rcv *CmdOptionSwitchOnPath) Mode() SwitchOnPathMode { return 0 } +/// switch on path mode func (rcv *CmdOptionSwitchOnPath) MutateMode(n SwitchOnPathMode) bool { return rcv._tab.MutateInt8Slot(6, int8(n)) } -/// signal Id +/// signal id func (rcv *CmdOptionSwitchOnPath) SignalId() uint32 { o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) if o != 0 { @@ -121,11 +123,12 @@ func (rcv *CmdOptionSwitchOnPath) SignalId() uint32 { return 0 } -/// signal Id +/// signal id func (rcv *CmdOptionSwitchOnPath) MutateSignalId(n uint32) bool { return rcv._tab.MutateUint32Slot(8, n) } +/// switch on path action func (rcv *CmdOptionSwitchOnPath) Action() SwitchOnPathAction { o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) if o != 0 { @@ -134,10 +137,12 @@ func (rcv *CmdOptionSwitchOnPath) Action() SwitchOnPathAction { return 0 } +/// switch on path action func (rcv *CmdOptionSwitchOnPath) MutateAction(n SwitchOnPathAction) bool { return rcv._tab.MutateInt8Slot(10, int8(n)) } +/// target position func (rcv *CmdOptionSwitchOnPath) TargetPosition(j int) float64 { o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) if o != 0 { @@ -155,6 +160,7 @@ func (rcv *CmdOptionSwitchOnPath) TargetPositionLength() int { return 0 } +/// target position func (rcv *CmdOptionSwitchOnPath) MutateTargetPosition(j int, n float64) bool { o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) if o != 0 { @@ -164,6 +170,7 @@ func (rcv *CmdOptionSwitchOnPath) MutateTargetPosition(j int, n float64) bool { return false } +/// radius func (rcv *CmdOptionSwitchOnPath) Radius() float64 { o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) if o != 0 { @@ -172,10 +179,12 @@ func (rcv *CmdOptionSwitchOnPath) Radius() float64 { return 0.0 } +/// radius func (rcv *CmdOptionSwitchOnPath) MutateRadius(n float64) bool { return rcv._tab.MutateFloat64Slot(14, n) } +/// pre trigger time func (rcv *CmdOptionSwitchOnPath) PreTriggerTime() float64 { o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) if o != 0 { @@ -184,6 +193,7 @@ func (rcv *CmdOptionSwitchOnPath) PreTriggerTime() float64 { return 0.0 } +/// pre trigger time func (rcv *CmdOptionSwitchOnPath) MutatePreTriggerTime(n float64) bool { return rcv._tab.MutateFloat64Slot(16, n) } diff --git a/pkg/fbs/motion/sync/fbtypes/AxsCfgDynSynchronisation.go b/pkg/fbs/motion/sync/fbtypes/AxsCfgDynSynchronisation.go index cca5390..a0b94d8 100644 --- a/pkg/fbs/motion/sync/fbtypes/AxsCfgDynSynchronisation.go +++ b/pkg/fbs/motion/sync/fbtypes/AxsCfgDynSynchronisation.go @@ -10,15 +10,18 @@ import ( type AxsCfgDynSynchronisationT struct { Limits *AxsCfgDynSynchronisationLimT `json:"limits"` SyncWindowModulo float64 `json:"syncWindowModulo"` + SyncWindowModuloExtended *AxsCfgDynSynchronisationSyncWinModT `json:"syncWindowModuloExtended"` Method DynSynchronisationMethod `json:"method"` } func (t *AxsCfgDynSynchronisationT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { if t == nil { return 0 } limitsOffset := t.Limits.Pack(builder) + syncWindowModuloExtendedOffset := t.SyncWindowModuloExtended.Pack(builder) AxsCfgDynSynchronisationStart(builder) AxsCfgDynSynchronisationAddLimits(builder, limitsOffset) AxsCfgDynSynchronisationAddSyncWindowModulo(builder, t.SyncWindowModulo) + AxsCfgDynSynchronisationAddSyncWindowModuloExtended(builder, syncWindowModuloExtendedOffset) AxsCfgDynSynchronisationAddMethod(builder, t.Method) return AxsCfgDynSynchronisationEnd(builder) } @@ -26,6 +29,7 @@ func (t *AxsCfgDynSynchronisationT) Pack(builder *flatbuffers.Builder) flatbuffe func (rcv *AxsCfgDynSynchronisation) UnPackTo(t *AxsCfgDynSynchronisationT) { t.Limits = rcv.Limits(nil).UnPack() t.SyncWindowModulo = rcv.SyncWindowModulo() + t.SyncWindowModuloExtended = rcv.SyncWindowModuloExtended(nil).UnPack() t.Method = rcv.Method() } @@ -78,7 +82,7 @@ func (rcv *AxsCfgDynSynchronisation) Limits(obj *AxsCfgDynSynchronisationLim) *A } /// Reference to configuration of the dynamic synchronisation limits of the axis -/// Dynamic synchronisation window modulo value +/// Deprecated! It doesn't use anymore. The configuration should be set with the syncWindowModuloExtended only. func (rcv *AxsCfgDynSynchronisation) SyncWindowModulo() float64 { o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) if o != 0 { @@ -87,14 +91,29 @@ func (rcv *AxsCfgDynSynchronisation) SyncWindowModulo() float64 { return 0.0 } -/// Dynamic synchronisation window modulo value +/// Deprecated! It doesn't use anymore. The configuration should be set with the syncWindowModuloExtended only. func (rcv *AxsCfgDynSynchronisation) MutateSyncWindowModulo(n float64) bool { return rcv._tab.MutateFloat64Slot(6, n) } +/// Dynamic synchronisation window modulo value +func (rcv *AxsCfgDynSynchronisation) SyncWindowModuloExtended(obj *AxsCfgDynSynchronisationSyncWinMod) *AxsCfgDynSynchronisationSyncWinMod { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(AxsCfgDynSynchronisationSyncWinMod) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// Dynamic synchronisation window modulo value /// Selected dynamic synchronisation method for sync. commands func (rcv *AxsCfgDynSynchronisation) Method() DynSynchronisationMethod { - o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) if o != 0 { return DynSynchronisationMethod(rcv._tab.GetInt8(o + rcv._tab.Pos)) } @@ -103,11 +122,11 @@ func (rcv *AxsCfgDynSynchronisation) Method() DynSynchronisationMethod { /// Selected dynamic synchronisation method for sync. commands func (rcv *AxsCfgDynSynchronisation) MutateMethod(n DynSynchronisationMethod) bool { - return rcv._tab.MutateInt8Slot(8, int8(n)) + return rcv._tab.MutateInt8Slot(10, int8(n)) } func AxsCfgDynSynchronisationStart(builder *flatbuffers.Builder) { - builder.StartObject(3) + builder.StartObject(4) } func AxsCfgDynSynchronisationAddLimits(builder *flatbuffers.Builder, limits flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(limits), 0) @@ -115,8 +134,11 @@ func AxsCfgDynSynchronisationAddLimits(builder *flatbuffers.Builder, limits flat func AxsCfgDynSynchronisationAddSyncWindowModulo(builder *flatbuffers.Builder, syncWindowModulo float64) { builder.PrependFloat64Slot(1, syncWindowModulo, 0.0) } +func AxsCfgDynSynchronisationAddSyncWindowModuloExtended(builder *flatbuffers.Builder, syncWindowModuloExtended flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(syncWindowModuloExtended), 0) +} func AxsCfgDynSynchronisationAddMethod(builder *flatbuffers.Builder, method DynSynchronisationMethod) { - builder.PrependInt8Slot(2, int8(method), 0) + builder.PrependInt8Slot(3, int8(method), 0) } func AxsCfgDynSynchronisationEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() diff --git a/pkg/fbs/motion/sync/fbtypes/AxsCfgDynSynchronisationLim.go b/pkg/fbs/motion/sync/fbtypes/AxsCfgDynSynchronisationLim.go index dd194a9..b489f3e 100644 --- a/pkg/fbs/motion/sync/fbtypes/AxsCfgDynSynchronisationLim.go +++ b/pkg/fbs/motion/sync/fbtypes/AxsCfgDynSynchronisationLim.go @@ -14,10 +14,40 @@ type AxsCfgDynSynchronisationLimT struct { JrkDec float64 `json:"jrkDec"` VelNeg float64 `json:"velNeg"` VelPos float64 `json:"velPos"` + AccUnit string `json:"accUnit"` + DecUnit string `json:"decUnit"` + JrkAccUnit string `json:"jrkAccUnit"` + JrkDecUnit string `json:"jrkDecUnit"` + VelNegUnit string `json:"velNegUnit"` + VelPosUnit string `json:"velPosUnit"` } func (t *AxsCfgDynSynchronisationLimT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { if t == nil { return 0 } + accUnitOffset := flatbuffers.UOffsetT(0) + if t.AccUnit != "" { + accUnitOffset = builder.CreateString(t.AccUnit) + } + decUnitOffset := flatbuffers.UOffsetT(0) + if t.DecUnit != "" { + decUnitOffset = builder.CreateString(t.DecUnit) + } + jrkAccUnitOffset := flatbuffers.UOffsetT(0) + if t.JrkAccUnit != "" { + jrkAccUnitOffset = builder.CreateString(t.JrkAccUnit) + } + jrkDecUnitOffset := flatbuffers.UOffsetT(0) + if t.JrkDecUnit != "" { + jrkDecUnitOffset = builder.CreateString(t.JrkDecUnit) + } + velNegUnitOffset := flatbuffers.UOffsetT(0) + if t.VelNegUnit != "" { + velNegUnitOffset = builder.CreateString(t.VelNegUnit) + } + velPosUnitOffset := flatbuffers.UOffsetT(0) + if t.VelPosUnit != "" { + velPosUnitOffset = builder.CreateString(t.VelPosUnit) + } AxsCfgDynSynchronisationLimStart(builder) AxsCfgDynSynchronisationLimAddAcc(builder, t.Acc) AxsCfgDynSynchronisationLimAddDec(builder, t.Dec) @@ -25,6 +55,12 @@ func (t *AxsCfgDynSynchronisationLimT) Pack(builder *flatbuffers.Builder) flatbu AxsCfgDynSynchronisationLimAddJrkDec(builder, t.JrkDec) AxsCfgDynSynchronisationLimAddVelNeg(builder, t.VelNeg) AxsCfgDynSynchronisationLimAddVelPos(builder, t.VelPos) + AxsCfgDynSynchronisationLimAddAccUnit(builder, accUnitOffset) + AxsCfgDynSynchronisationLimAddDecUnit(builder, decUnitOffset) + AxsCfgDynSynchronisationLimAddJrkAccUnit(builder, jrkAccUnitOffset) + AxsCfgDynSynchronisationLimAddJrkDecUnit(builder, jrkDecUnitOffset) + AxsCfgDynSynchronisationLimAddVelNegUnit(builder, velNegUnitOffset) + AxsCfgDynSynchronisationLimAddVelPosUnit(builder, velPosUnitOffset) return AxsCfgDynSynchronisationLimEnd(builder) } @@ -35,6 +71,12 @@ func (rcv *AxsCfgDynSynchronisationLim) UnPackTo(t *AxsCfgDynSynchronisationLimT t.JrkDec = rcv.JrkDec() t.VelNeg = rcv.VelNeg() t.VelPos = rcv.VelPos() + t.AccUnit = string(rcv.AccUnit()) + t.DecUnit = string(rcv.DecUnit()) + t.JrkAccUnit = string(rcv.JrkAccUnit()) + t.JrkDecUnit = string(rcv.JrkDecUnit()) + t.VelNegUnit = string(rcv.VelNegUnit()) + t.VelPosUnit = string(rcv.VelPosUnit()) } func (rcv *AxsCfgDynSynchronisationLim) UnPack() *AxsCfgDynSynchronisationLimT { @@ -155,8 +197,68 @@ func (rcv *AxsCfgDynSynchronisationLim) MutateVelPos(n float64) bool { return rcv._tab.MutateFloat64Slot(14, n) } +/// unit of acc +func (rcv *AxsCfgDynSynchronisationLim) AccUnit() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// unit of acc +/// unit of dec +func (rcv *AxsCfgDynSynchronisationLim) DecUnit() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(18)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// unit of dec +/// unit of jrkAcc +func (rcv *AxsCfgDynSynchronisationLim) JrkAccUnit() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(20)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// unit of jrkAcc +/// unit of jrkDec +func (rcv *AxsCfgDynSynchronisationLim) JrkDecUnit() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(22)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// unit of jrkDec +/// unit of velNeg +func (rcv *AxsCfgDynSynchronisationLim) VelNegUnit() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(24)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// unit of velNeg +/// unit of velPos +func (rcv *AxsCfgDynSynchronisationLim) VelPosUnit() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(26)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// unit of velPos func AxsCfgDynSynchronisationLimStart(builder *flatbuffers.Builder) { - builder.StartObject(6) + builder.StartObject(12) } func AxsCfgDynSynchronisationLimAddAcc(builder *flatbuffers.Builder, acc float64) { builder.PrependFloat64Slot(0, acc, 0.0) @@ -176,6 +278,24 @@ func AxsCfgDynSynchronisationLimAddVelNeg(builder *flatbuffers.Builder, velNeg f func AxsCfgDynSynchronisationLimAddVelPos(builder *flatbuffers.Builder, velPos float64) { builder.PrependFloat64Slot(5, velPos, 0.0) } +func AxsCfgDynSynchronisationLimAddAccUnit(builder *flatbuffers.Builder, accUnit flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(6, flatbuffers.UOffsetT(accUnit), 0) +} +func AxsCfgDynSynchronisationLimAddDecUnit(builder *flatbuffers.Builder, decUnit flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(7, flatbuffers.UOffsetT(decUnit), 0) +} +func AxsCfgDynSynchronisationLimAddJrkAccUnit(builder *flatbuffers.Builder, jrkAccUnit flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(8, flatbuffers.UOffsetT(jrkAccUnit), 0) +} +func AxsCfgDynSynchronisationLimAddJrkDecUnit(builder *flatbuffers.Builder, jrkDecUnit flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(9, flatbuffers.UOffsetT(jrkDecUnit), 0) +} +func AxsCfgDynSynchronisationLimAddVelNegUnit(builder *flatbuffers.Builder, velNegUnit flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(10, flatbuffers.UOffsetT(velNegUnit), 0) +} +func AxsCfgDynSynchronisationLimAddVelPosUnit(builder *flatbuffers.Builder, velPosUnit flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(11, flatbuffers.UOffsetT(velPosUnit), 0) +} func AxsCfgDynSynchronisationLimEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/pkg/fbs/motion/sync/fbtypes/AxsCfgDynSynchronisationSyncWinMod.go b/pkg/fbs/motion/sync/fbtypes/AxsCfgDynSynchronisationSyncWinMod.go new file mode 100644 index 0000000..4751b4c --- /dev/null +++ b/pkg/fbs/motion/sync/fbtypes/AxsCfgDynSynchronisationSyncWinMod.go @@ -0,0 +1,101 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// Configuration of the dynamic synchronisation window modulo of a single axis +type AxsCfgDynSynchronisationSyncWinModT struct { + SyncWindowModulo float64 `json:"syncWindowModulo"` + SyncWindowModuloUnit string `json:"syncWindowModuloUnit"` +} + +func (t *AxsCfgDynSynchronisationSyncWinModT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + syncWindowModuloUnitOffset := flatbuffers.UOffsetT(0) + if t.SyncWindowModuloUnit != "" { + syncWindowModuloUnitOffset = builder.CreateString(t.SyncWindowModuloUnit) + } + AxsCfgDynSynchronisationSyncWinModStart(builder) + AxsCfgDynSynchronisationSyncWinModAddSyncWindowModulo(builder, t.SyncWindowModulo) + AxsCfgDynSynchronisationSyncWinModAddSyncWindowModuloUnit(builder, syncWindowModuloUnitOffset) + return AxsCfgDynSynchronisationSyncWinModEnd(builder) +} + +func (rcv *AxsCfgDynSynchronisationSyncWinMod) UnPackTo(t *AxsCfgDynSynchronisationSyncWinModT) { + t.SyncWindowModulo = rcv.SyncWindowModulo() + t.SyncWindowModuloUnit = string(rcv.SyncWindowModuloUnit()) +} + +func (rcv *AxsCfgDynSynchronisationSyncWinMod) UnPack() *AxsCfgDynSynchronisationSyncWinModT { + if rcv == nil { return nil } + t := &AxsCfgDynSynchronisationSyncWinModT{} + rcv.UnPackTo(t) + return t +} + +type AxsCfgDynSynchronisationSyncWinMod struct { + _tab flatbuffers.Table +} + +func GetRootAsAxsCfgDynSynchronisationSyncWinMod(buf []byte, offset flatbuffers.UOffsetT) *AxsCfgDynSynchronisationSyncWinMod { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &AxsCfgDynSynchronisationSyncWinMod{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsAxsCfgDynSynchronisationSyncWinMod(buf []byte, offset flatbuffers.UOffsetT) *AxsCfgDynSynchronisationSyncWinMod { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &AxsCfgDynSynchronisationSyncWinMod{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *AxsCfgDynSynchronisationSyncWinMod) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *AxsCfgDynSynchronisationSyncWinMod) Table() flatbuffers.Table { + return rcv._tab +} + +/// Dynamic synchronisation window modulo value +func (rcv *AxsCfgDynSynchronisationSyncWinMod) SyncWindowModulo() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +/// Dynamic synchronisation window modulo value +func (rcv *AxsCfgDynSynchronisationSyncWinMod) MutateSyncWindowModulo(n float64) bool { + return rcv._tab.MutateFloat64Slot(4, n) +} + +/// Unit of syncWindowModulo +func (rcv *AxsCfgDynSynchronisationSyncWinMod) SyncWindowModuloUnit() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// Unit of syncWindowModulo +func AxsCfgDynSynchronisationSyncWinModStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func AxsCfgDynSynchronisationSyncWinModAddSyncWindowModulo(builder *flatbuffers.Builder, syncWindowModulo float64) { + builder.PrependFloat64Slot(0, syncWindowModulo, 0.0) +} +func AxsCfgDynSynchronisationSyncWinModAddSyncWindowModuloUnit(builder *flatbuffers.Builder, syncWindowModuloUnit flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(syncWindowModuloUnit), 0) +} +func AxsCfgDynSynchronisationSyncWinModEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/sync/fbtypes/AxsCmdCamInData.go b/pkg/fbs/motion/sync/fbtypes/AxsCmdCamInData.go new file mode 100644 index 0000000..3390bc7 --- /dev/null +++ b/pkg/fbs/motion/sync/fbtypes/AxsCmdCamInData.go @@ -0,0 +1,143 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// parameters of the axis CamIn command +type AxsCmdCamInDataT struct { + Master string `json:"master"` + SyncSource SyncSource `json:"syncSource"` + DynSyncDirection DynSyncDirection `json:"dynSyncDirection"` + Parameters *AxsCmdCamInParamsT `json:"parameters"` +} + +func (t *AxsCmdCamInDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + masterOffset := flatbuffers.UOffsetT(0) + if t.Master != "" { + masterOffset = builder.CreateString(t.Master) + } + parametersOffset := t.Parameters.Pack(builder) + AxsCmdCamInDataStart(builder) + AxsCmdCamInDataAddMaster(builder, masterOffset) + AxsCmdCamInDataAddSyncSource(builder, t.SyncSource) + AxsCmdCamInDataAddDynSyncDirection(builder, t.DynSyncDirection) + AxsCmdCamInDataAddParameters(builder, parametersOffset) + return AxsCmdCamInDataEnd(builder) +} + +func (rcv *AxsCmdCamInData) UnPackTo(t *AxsCmdCamInDataT) { + t.Master = string(rcv.Master()) + t.SyncSource = rcv.SyncSource() + t.DynSyncDirection = rcv.DynSyncDirection() + t.Parameters = rcv.Parameters(nil).UnPack() +} + +func (rcv *AxsCmdCamInData) UnPack() *AxsCmdCamInDataT { + if rcv == nil { return nil } + t := &AxsCmdCamInDataT{} + rcv.UnPackTo(t) + return t +} + +type AxsCmdCamInData struct { + _tab flatbuffers.Table +} + +func GetRootAsAxsCmdCamInData(buf []byte, offset flatbuffers.UOffsetT) *AxsCmdCamInData { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &AxsCmdCamInData{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsAxsCmdCamInData(buf []byte, offset flatbuffers.UOffsetT) *AxsCmdCamInData { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &AxsCmdCamInData{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *AxsCmdCamInData) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *AxsCmdCamInData) Table() flatbuffers.Table { + return rcv._tab +} + +/// name of the master axis +func (rcv *AxsCmdCamInData) Master() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// name of the master axis +/// sync source (Setpoint) +func (rcv *AxsCmdCamInData) SyncSource() SyncSource { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return SyncSource(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +/// sync source (Setpoint) +func (rcv *AxsCmdCamInData) MutateSyncSource(n SyncSource) bool { + return rcv._tab.MutateInt8Slot(6, int8(n)) +} + +/// dynamic sync direction (ShortestWay) +func (rcv *AxsCmdCamInData) DynSyncDirection() DynSyncDirection { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return DynSyncDirection(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +/// dynamic sync direction (ShortestWay) +func (rcv *AxsCmdCamInData) MutateDynSyncDirection(n DynSyncDirection) bool { + return rcv._tab.MutateInt8Slot(8, int8(n)) +} + +/// CamIn parameters (master offset, slave offset, ratio numerator, ratio denominator,...) +func (rcv *AxsCmdCamInData) Parameters(obj *AxsCmdCamInParams) *AxsCmdCamInParams { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(AxsCmdCamInParams) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// CamIn parameters (master offset, slave offset, ratio numerator, ratio denominator,...) +func AxsCmdCamInDataStart(builder *flatbuffers.Builder) { + builder.StartObject(4) +} +func AxsCmdCamInDataAddMaster(builder *flatbuffers.Builder, master flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(master), 0) +} +func AxsCmdCamInDataAddSyncSource(builder *flatbuffers.Builder, syncSource SyncSource) { + builder.PrependInt8Slot(1, int8(syncSource), 0) +} +func AxsCmdCamInDataAddDynSyncDirection(builder *flatbuffers.Builder, dynSyncDirection DynSyncDirection) { + builder.PrependInt8Slot(2, int8(dynSyncDirection), 0) +} +func AxsCmdCamInDataAddParameters(builder *flatbuffers.Builder, parameters flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(parameters), 0) +} +func AxsCmdCamInDataEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/sync/fbtypes/AxsCmdCamInDlParams.go b/pkg/fbs/motion/sync/fbtypes/AxsCmdCamInDlParams.go new file mode 100644 index 0000000..c876eb5 --- /dev/null +++ b/pkg/fbs/motion/sync/fbtypes/AxsCmdCamInDlParams.go @@ -0,0 +1,381 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// CamIn calculation pipeline parameters, that are stored in the Datalayer RT, for the axis CamInEx command +type AxsCmdCamInDlParamsT struct { + SoiMasterOffsetDlIdx int32 `json:"soiMasterOffsetDlIdx"` + SoiMasterOffsetVelDlIdx int32 `json:"soiMasterOffsetVelDlIdx"` + SoiMasterOffsetAccDlIdx int32 `json:"soiMasterOffsetAccDlIdx"` + SoiSlaveOffsetDlIdx int32 `json:"soiSlaveOffsetDlIdx"` + SoiSlaveOffsetVelDlIdx int32 `json:"soiSlaveOffsetVelDlIdx"` + SoiSlaveOffsetAccDlIdx int32 `json:"soiSlaveOffsetAccDlIdx"` + FofMasterOffsetDlIdx int32 `json:"fofMasterOffsetDlIdx"` + FofMasterOffsetTimeConstantDlIdx int32 `json:"fofMasterOffsetTimeConstantDlIdx"` + FofSlaveOffsetDlIdx int32 `json:"fofSlaveOffsetDlIdx"` + FofSlaveOffsetTimeConstantDlIdx int32 `json:"fofSlaveOffsetTimeConstantDlIdx"` + FineAdjustDlIdx int32 `json:"fineAdjustDlIdx"` + SoiAngleAdjustDlIdx int32 `json:"soiAngleAdjustDlIdx"` + SoiAngleAdjustVelDlIdx int32 `json:"soiAngleAdjustVelDlIdx"` + SoiAngleAdjustAccDlIdx int32 `json:"soiAngleAdjustAccDlIdx"` + FofAngleAdjustDlIdx int32 `json:"fofAngleAdjustDlIdx"` + FofAngleAdjustTimeConstantDlIdx int32 `json:"fofAngleAdjustTimeConstantDlIdx"` +} + +func (t *AxsCmdCamInDlParamsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + AxsCmdCamInDlParamsStart(builder) + AxsCmdCamInDlParamsAddSoiMasterOffsetDlIdx(builder, t.SoiMasterOffsetDlIdx) + AxsCmdCamInDlParamsAddSoiMasterOffsetVelDlIdx(builder, t.SoiMasterOffsetVelDlIdx) + AxsCmdCamInDlParamsAddSoiMasterOffsetAccDlIdx(builder, t.SoiMasterOffsetAccDlIdx) + AxsCmdCamInDlParamsAddSoiSlaveOffsetDlIdx(builder, t.SoiSlaveOffsetDlIdx) + AxsCmdCamInDlParamsAddSoiSlaveOffsetVelDlIdx(builder, t.SoiSlaveOffsetVelDlIdx) + AxsCmdCamInDlParamsAddSoiSlaveOffsetAccDlIdx(builder, t.SoiSlaveOffsetAccDlIdx) + AxsCmdCamInDlParamsAddFofMasterOffsetDlIdx(builder, t.FofMasterOffsetDlIdx) + AxsCmdCamInDlParamsAddFofMasterOffsetTimeConstantDlIdx(builder, t.FofMasterOffsetTimeConstantDlIdx) + AxsCmdCamInDlParamsAddFofSlaveOffsetDlIdx(builder, t.FofSlaveOffsetDlIdx) + AxsCmdCamInDlParamsAddFofSlaveOffsetTimeConstantDlIdx(builder, t.FofSlaveOffsetTimeConstantDlIdx) + AxsCmdCamInDlParamsAddFineAdjustDlIdx(builder, t.FineAdjustDlIdx) + AxsCmdCamInDlParamsAddSoiAngleAdjustDlIdx(builder, t.SoiAngleAdjustDlIdx) + AxsCmdCamInDlParamsAddSoiAngleAdjustVelDlIdx(builder, t.SoiAngleAdjustVelDlIdx) + AxsCmdCamInDlParamsAddSoiAngleAdjustAccDlIdx(builder, t.SoiAngleAdjustAccDlIdx) + AxsCmdCamInDlParamsAddFofAngleAdjustDlIdx(builder, t.FofAngleAdjustDlIdx) + AxsCmdCamInDlParamsAddFofAngleAdjustTimeConstantDlIdx(builder, t.FofAngleAdjustTimeConstantDlIdx) + return AxsCmdCamInDlParamsEnd(builder) +} + +func (rcv *AxsCmdCamInDlParams) UnPackTo(t *AxsCmdCamInDlParamsT) { + t.SoiMasterOffsetDlIdx = rcv.SoiMasterOffsetDlIdx() + t.SoiMasterOffsetVelDlIdx = rcv.SoiMasterOffsetVelDlIdx() + t.SoiMasterOffsetAccDlIdx = rcv.SoiMasterOffsetAccDlIdx() + t.SoiSlaveOffsetDlIdx = rcv.SoiSlaveOffsetDlIdx() + t.SoiSlaveOffsetVelDlIdx = rcv.SoiSlaveOffsetVelDlIdx() + t.SoiSlaveOffsetAccDlIdx = rcv.SoiSlaveOffsetAccDlIdx() + t.FofMasterOffsetDlIdx = rcv.FofMasterOffsetDlIdx() + t.FofMasterOffsetTimeConstantDlIdx = rcv.FofMasterOffsetTimeConstantDlIdx() + t.FofSlaveOffsetDlIdx = rcv.FofSlaveOffsetDlIdx() + t.FofSlaveOffsetTimeConstantDlIdx = rcv.FofSlaveOffsetTimeConstantDlIdx() + t.FineAdjustDlIdx = rcv.FineAdjustDlIdx() + t.SoiAngleAdjustDlIdx = rcv.SoiAngleAdjustDlIdx() + t.SoiAngleAdjustVelDlIdx = rcv.SoiAngleAdjustVelDlIdx() + t.SoiAngleAdjustAccDlIdx = rcv.SoiAngleAdjustAccDlIdx() + t.FofAngleAdjustDlIdx = rcv.FofAngleAdjustDlIdx() + t.FofAngleAdjustTimeConstantDlIdx = rcv.FofAngleAdjustTimeConstantDlIdx() +} + +func (rcv *AxsCmdCamInDlParams) UnPack() *AxsCmdCamInDlParamsT { + if rcv == nil { return nil } + t := &AxsCmdCamInDlParamsT{} + rcv.UnPackTo(t) + return t +} + +type AxsCmdCamInDlParams struct { + _tab flatbuffers.Table +} + +func GetRootAsAxsCmdCamInDlParams(buf []byte, offset flatbuffers.UOffsetT) *AxsCmdCamInDlParams { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &AxsCmdCamInDlParams{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsAxsCmdCamInDlParams(buf []byte, offset flatbuffers.UOffsetT) *AxsCmdCamInDlParams { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &AxsCmdCamInDlParams{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *AxsCmdCamInDlParams) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *AxsCmdCamInDlParams) Table() flatbuffers.Table { + return rcv._tab +} + +/// data layer index of master offset target value, second order interpolated +func (rcv *AxsCmdCamInDlParams) SoiMasterOffsetDlIdx() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return -1 +} + +/// data layer index of master offset target value, second order interpolated +func (rcv *AxsCmdCamInDlParams) MutateSoiMasterOffsetDlIdx(n int32) bool { + return rcv._tab.MutateInt32Slot(4, n) +} + +/// data layer index of master offset velocity constraint for second order interpolation +func (rcv *AxsCmdCamInDlParams) SoiMasterOffsetVelDlIdx() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return -1 +} + +/// data layer index of master offset velocity constraint for second order interpolation +func (rcv *AxsCmdCamInDlParams) MutateSoiMasterOffsetVelDlIdx(n int32) bool { + return rcv._tab.MutateInt32Slot(6, n) +} + +/// data layer index of master offset acceleration constraint for second order interpolation +func (rcv *AxsCmdCamInDlParams) SoiMasterOffsetAccDlIdx() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return -1 +} + +/// data layer index of master offset acceleration constraint for second order interpolation +func (rcv *AxsCmdCamInDlParams) MutateSoiMasterOffsetAccDlIdx(n int32) bool { + return rcv._tab.MutateInt32Slot(8, n) +} + +/// data layer index of slave offset target value, second order interpolated +func (rcv *AxsCmdCamInDlParams) SoiSlaveOffsetDlIdx() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return -1 +} + +/// data layer index of slave offset target value, second order interpolated +func (rcv *AxsCmdCamInDlParams) MutateSoiSlaveOffsetDlIdx(n int32) bool { + return rcv._tab.MutateInt32Slot(10, n) +} + +/// data layer index of slave offset velocity constraint for second order interpolation +func (rcv *AxsCmdCamInDlParams) SoiSlaveOffsetVelDlIdx() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return -1 +} + +/// data layer index of slave offset velocity constraint for second order interpolation +func (rcv *AxsCmdCamInDlParams) MutateSoiSlaveOffsetVelDlIdx(n int32) bool { + return rcv._tab.MutateInt32Slot(12, n) +} + +/// data layer index of slave offset acceleration constraint for second order interpolation +func (rcv *AxsCmdCamInDlParams) SoiSlaveOffsetAccDlIdx() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return -1 +} + +/// data layer index of slave offset acceleration constraint for second order interpolation +func (rcv *AxsCmdCamInDlParams) MutateSoiSlaveOffsetAccDlIdx(n int32) bool { + return rcv._tab.MutateInt32Slot(14, n) +} + +/// data layer index of second master offset, first order filtered +func (rcv *AxsCmdCamInDlParams) FofMasterOffsetDlIdx() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return -1 +} + +/// data layer index of second master offset, first order filtered +func (rcv *AxsCmdCamInDlParams) MutateFofMasterOffsetDlIdx(n int32) bool { + return rcv._tab.MutateInt32Slot(16, n) +} + +/// data layer index of time constant for change rate of fofMasterOffset +func (rcv *AxsCmdCamInDlParams) FofMasterOffsetTimeConstantDlIdx() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(18)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return -1 +} + +/// data layer index of time constant for change rate of fofMasterOffset +func (rcv *AxsCmdCamInDlParams) MutateFofMasterOffsetTimeConstantDlIdx(n int32) bool { + return rcv._tab.MutateInt32Slot(18, n) +} + +/// data layer index of second slave offset, first order filtered +func (rcv *AxsCmdCamInDlParams) FofSlaveOffsetDlIdx() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(20)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return -1 +} + +/// data layer index of second slave offset, first order filtered +func (rcv *AxsCmdCamInDlParams) MutateFofSlaveOffsetDlIdx(n int32) bool { + return rcv._tab.MutateInt32Slot(20, n) +} + +/// data layer index of time constant for change rate of fofSlaveOffset +func (rcv *AxsCmdCamInDlParams) FofSlaveOffsetTimeConstantDlIdx() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(22)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return -1 +} + +/// data layer index of time constant for change rate of fofSlaveOffset +func (rcv *AxsCmdCamInDlParams) MutateFofSlaveOffsetTimeConstantDlIdx(n int32) bool { + return rcv._tab.MutateInt32Slot(22, n) +} + +/// data layer index of fine adjust percentage in addition to the commanded fine adjust +func (rcv *AxsCmdCamInDlParams) FineAdjustDlIdx() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(24)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return -1 +} + +/// data layer index of fine adjust percentage in addition to the commanded fine adjust +func (rcv *AxsCmdCamInDlParams) MutateFineAdjustDlIdx(n int32) bool { + return rcv._tab.MutateInt32Slot(24, n) +} + +/// data layer index of angle adjust value +func (rcv *AxsCmdCamInDlParams) SoiAngleAdjustDlIdx() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(26)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return -1 +} + +/// data layer index of angle adjust value +func (rcv *AxsCmdCamInDlParams) MutateSoiAngleAdjustDlIdx(n int32) bool { + return rcv._tab.MutateInt32Slot(26, n) +} + +/// data layer index of angle adjust velocity constraint for second order interpolation +func (rcv *AxsCmdCamInDlParams) SoiAngleAdjustVelDlIdx() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(28)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return -1 +} + +/// data layer index of angle adjust velocity constraint for second order interpolation +func (rcv *AxsCmdCamInDlParams) MutateSoiAngleAdjustVelDlIdx(n int32) bool { + return rcv._tab.MutateInt32Slot(28, n) +} + +/// data layer index of angle adjust acceleration constraint for second order interpolation +func (rcv *AxsCmdCamInDlParams) SoiAngleAdjustAccDlIdx() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(30)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return -1 +} + +/// data layer index of angle adjust acceleration constraint for second order interpolation +func (rcv *AxsCmdCamInDlParams) MutateSoiAngleAdjustAccDlIdx(n int32) bool { + return rcv._tab.MutateInt32Slot(30, n) +} + +/// data layer index of second angle adjust, first order filtered +func (rcv *AxsCmdCamInDlParams) FofAngleAdjustDlIdx() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(32)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return -1 +} + +/// data layer index of second angle adjust, first order filtered +func (rcv *AxsCmdCamInDlParams) MutateFofAngleAdjustDlIdx(n int32) bool { + return rcv._tab.MutateInt32Slot(32, n) +} + +/// data layer index of time constant for change rate of fofAngleAdjust +func (rcv *AxsCmdCamInDlParams) FofAngleAdjustTimeConstantDlIdx() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(34)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return -1 +} + +/// data layer index of time constant for change rate of fofAngleAdjust +func (rcv *AxsCmdCamInDlParams) MutateFofAngleAdjustTimeConstantDlIdx(n int32) bool { + return rcv._tab.MutateInt32Slot(34, n) +} + +func AxsCmdCamInDlParamsStart(builder *flatbuffers.Builder) { + builder.StartObject(16) +} +func AxsCmdCamInDlParamsAddSoiMasterOffsetDlIdx(builder *flatbuffers.Builder, soiMasterOffsetDlIdx int32) { + builder.PrependInt32Slot(0, soiMasterOffsetDlIdx, -1) +} +func AxsCmdCamInDlParamsAddSoiMasterOffsetVelDlIdx(builder *flatbuffers.Builder, soiMasterOffsetVelDlIdx int32) { + builder.PrependInt32Slot(1, soiMasterOffsetVelDlIdx, -1) +} +func AxsCmdCamInDlParamsAddSoiMasterOffsetAccDlIdx(builder *flatbuffers.Builder, soiMasterOffsetAccDlIdx int32) { + builder.PrependInt32Slot(2, soiMasterOffsetAccDlIdx, -1) +} +func AxsCmdCamInDlParamsAddSoiSlaveOffsetDlIdx(builder *flatbuffers.Builder, soiSlaveOffsetDlIdx int32) { + builder.PrependInt32Slot(3, soiSlaveOffsetDlIdx, -1) +} +func AxsCmdCamInDlParamsAddSoiSlaveOffsetVelDlIdx(builder *flatbuffers.Builder, soiSlaveOffsetVelDlIdx int32) { + builder.PrependInt32Slot(4, soiSlaveOffsetVelDlIdx, -1) +} +func AxsCmdCamInDlParamsAddSoiSlaveOffsetAccDlIdx(builder *flatbuffers.Builder, soiSlaveOffsetAccDlIdx int32) { + builder.PrependInt32Slot(5, soiSlaveOffsetAccDlIdx, -1) +} +func AxsCmdCamInDlParamsAddFofMasterOffsetDlIdx(builder *flatbuffers.Builder, fofMasterOffsetDlIdx int32) { + builder.PrependInt32Slot(6, fofMasterOffsetDlIdx, -1) +} +func AxsCmdCamInDlParamsAddFofMasterOffsetTimeConstantDlIdx(builder *flatbuffers.Builder, fofMasterOffsetTimeConstantDlIdx int32) { + builder.PrependInt32Slot(7, fofMasterOffsetTimeConstantDlIdx, -1) +} +func AxsCmdCamInDlParamsAddFofSlaveOffsetDlIdx(builder *flatbuffers.Builder, fofSlaveOffsetDlIdx int32) { + builder.PrependInt32Slot(8, fofSlaveOffsetDlIdx, -1) +} +func AxsCmdCamInDlParamsAddFofSlaveOffsetTimeConstantDlIdx(builder *flatbuffers.Builder, fofSlaveOffsetTimeConstantDlIdx int32) { + builder.PrependInt32Slot(9, fofSlaveOffsetTimeConstantDlIdx, -1) +} +func AxsCmdCamInDlParamsAddFineAdjustDlIdx(builder *flatbuffers.Builder, fineAdjustDlIdx int32) { + builder.PrependInt32Slot(10, fineAdjustDlIdx, -1) +} +func AxsCmdCamInDlParamsAddSoiAngleAdjustDlIdx(builder *flatbuffers.Builder, soiAngleAdjustDlIdx int32) { + builder.PrependInt32Slot(11, soiAngleAdjustDlIdx, -1) +} +func AxsCmdCamInDlParamsAddSoiAngleAdjustVelDlIdx(builder *flatbuffers.Builder, soiAngleAdjustVelDlIdx int32) { + builder.PrependInt32Slot(12, soiAngleAdjustVelDlIdx, -1) +} +func AxsCmdCamInDlParamsAddSoiAngleAdjustAccDlIdx(builder *flatbuffers.Builder, soiAngleAdjustAccDlIdx int32) { + builder.PrependInt32Slot(13, soiAngleAdjustAccDlIdx, -1) +} +func AxsCmdCamInDlParamsAddFofAngleAdjustDlIdx(builder *flatbuffers.Builder, fofAngleAdjustDlIdx int32) { + builder.PrependInt32Slot(14, fofAngleAdjustDlIdx, -1) +} +func AxsCmdCamInDlParamsAddFofAngleAdjustTimeConstantDlIdx(builder *flatbuffers.Builder, fofAngleAdjustTimeConstantDlIdx int32) { + builder.PrependInt32Slot(15, fofAngleAdjustTimeConstantDlIdx, -1) +} +func AxsCmdCamInDlParamsEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/sync/fbtypes/AxsCmdCamInExData.go b/pkg/fbs/motion/sync/fbtypes/AxsCmdCamInExData.go new file mode 100644 index 0000000..661b8e3 --- /dev/null +++ b/pkg/fbs/motion/sync/fbtypes/AxsCmdCamInExData.go @@ -0,0 +1,165 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// parameters of the axis CamInEx command +type AxsCmdCamInExDataT struct { + Master string `json:"master"` + SyncSource SyncSource `json:"syncSource"` + DynSyncDirection DynSyncDirection `json:"dynSyncDirection"` + Parameters *AxsCmdCamInParamsT `json:"parameters"` + DlParameters *AxsCmdCamInDlParamsT `json:"dlParameters"` +} + +func (t *AxsCmdCamInExDataT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + masterOffset := flatbuffers.UOffsetT(0) + if t.Master != "" { + masterOffset = builder.CreateString(t.Master) + } + parametersOffset := t.Parameters.Pack(builder) + dlParametersOffset := t.DlParameters.Pack(builder) + AxsCmdCamInExDataStart(builder) + AxsCmdCamInExDataAddMaster(builder, masterOffset) + AxsCmdCamInExDataAddSyncSource(builder, t.SyncSource) + AxsCmdCamInExDataAddDynSyncDirection(builder, t.DynSyncDirection) + AxsCmdCamInExDataAddParameters(builder, parametersOffset) + AxsCmdCamInExDataAddDlParameters(builder, dlParametersOffset) + return AxsCmdCamInExDataEnd(builder) +} + +func (rcv *AxsCmdCamInExData) UnPackTo(t *AxsCmdCamInExDataT) { + t.Master = string(rcv.Master()) + t.SyncSource = rcv.SyncSource() + t.DynSyncDirection = rcv.DynSyncDirection() + t.Parameters = rcv.Parameters(nil).UnPack() + t.DlParameters = rcv.DlParameters(nil).UnPack() +} + +func (rcv *AxsCmdCamInExData) UnPack() *AxsCmdCamInExDataT { + if rcv == nil { return nil } + t := &AxsCmdCamInExDataT{} + rcv.UnPackTo(t) + return t +} + +type AxsCmdCamInExData struct { + _tab flatbuffers.Table +} + +func GetRootAsAxsCmdCamInExData(buf []byte, offset flatbuffers.UOffsetT) *AxsCmdCamInExData { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &AxsCmdCamInExData{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsAxsCmdCamInExData(buf []byte, offset flatbuffers.UOffsetT) *AxsCmdCamInExData { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &AxsCmdCamInExData{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *AxsCmdCamInExData) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *AxsCmdCamInExData) Table() flatbuffers.Table { + return rcv._tab +} + +/// name of the master axis +func (rcv *AxsCmdCamInExData) Master() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// name of the master axis +/// sync source (Setpoint) +func (rcv *AxsCmdCamInExData) SyncSource() SyncSource { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return SyncSource(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +/// sync source (Setpoint) +func (rcv *AxsCmdCamInExData) MutateSyncSource(n SyncSource) bool { + return rcv._tab.MutateInt8Slot(6, int8(n)) +} + +/// dynamic sync direction (ShortestWay) +func (rcv *AxsCmdCamInExData) DynSyncDirection() DynSyncDirection { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return DynSyncDirection(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +/// dynamic sync direction (ShortestWay) +func (rcv *AxsCmdCamInExData) MutateDynSyncDirection(n DynSyncDirection) bool { + return rcv._tab.MutateInt8Slot(8, int8(n)) +} + +/// CamIn parameters (master offset, slave offset, ratio numerator, ratio denominator,...) +func (rcv *AxsCmdCamInExData) Parameters(obj *AxsCmdCamInParams) *AxsCmdCamInParams { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(AxsCmdCamInParams) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// CamIn parameters (master offset, slave offset, ratio numerator, ratio denominator,...) +/// CamIn data layer parameters +func (rcv *AxsCmdCamInExData) DlParameters(obj *AxsCmdCamInDlParams) *AxsCmdCamInDlParams { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(AxsCmdCamInDlParams) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// CamIn data layer parameters +func AxsCmdCamInExDataStart(builder *flatbuffers.Builder) { + builder.StartObject(5) +} +func AxsCmdCamInExDataAddMaster(builder *flatbuffers.Builder, master flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(master), 0) +} +func AxsCmdCamInExDataAddSyncSource(builder *flatbuffers.Builder, syncSource SyncSource) { + builder.PrependInt8Slot(1, int8(syncSource), 0) +} +func AxsCmdCamInExDataAddDynSyncDirection(builder *flatbuffers.Builder, dynSyncDirection DynSyncDirection) { + builder.PrependInt8Slot(2, int8(dynSyncDirection), 0) +} +func AxsCmdCamInExDataAddParameters(builder *flatbuffers.Builder, parameters flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(parameters), 0) +} +func AxsCmdCamInExDataAddDlParameters(builder *flatbuffers.Builder, dlParameters flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(dlParameters), 0) +} +func AxsCmdCamInExDataEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/sync/fbtypes/AxsCmdCamInParams.go b/pkg/fbs/motion/sync/fbtypes/AxsCmdCamInParams.go new file mode 100644 index 0000000..8ae6302 --- /dev/null +++ b/pkg/fbs/motion/sync/fbtypes/AxsCmdCamInParams.go @@ -0,0 +1,361 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// CamIn calculation pipeline parameters for the axis CamIn command +type AxsCmdCamInParamsT struct { + MasterOffset float64 `json:"masterOffset"` + SlaveOffset float64 `json:"slaveOffset"` + RatioNumerator int32 `json:"ratioNumerator"` + RatioDenominator int32 `json:"ratioDenominator"` + FineAdjust float64 `json:"fineAdjust"` + GainFactor float64 `json:"gainFactor"` + AngleAdjust float64 `json:"angleAdjust"` + ProfileEntry ProfileEntry `json:"profileEntry"` + ProfileExecutionMode ProfileExecutionMode `json:"profileExecutionMode"` + PointTable string `json:"pointTable"` + SwitchPosition float64 `json:"switchPosition"` + SwitchProfileOnPos bool `json:"switchProfileOnPos"` + SwitchGearOnPos bool `json:"switchGearOnPos"` + SwitchPositionGainFactor float64 `json:"switchPositionGainFactor"` + SwitchGainFactorOnPos bool `json:"switchGainFactorOnPos"` +} + +func (t *AxsCmdCamInParamsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + pointTableOffset := flatbuffers.UOffsetT(0) + if t.PointTable != "" { + pointTableOffset = builder.CreateString(t.PointTable) + } + AxsCmdCamInParamsStart(builder) + AxsCmdCamInParamsAddMasterOffset(builder, t.MasterOffset) + AxsCmdCamInParamsAddSlaveOffset(builder, t.SlaveOffset) + AxsCmdCamInParamsAddRatioNumerator(builder, t.RatioNumerator) + AxsCmdCamInParamsAddRatioDenominator(builder, t.RatioDenominator) + AxsCmdCamInParamsAddFineAdjust(builder, t.FineAdjust) + AxsCmdCamInParamsAddGainFactor(builder, t.GainFactor) + AxsCmdCamInParamsAddAngleAdjust(builder, t.AngleAdjust) + AxsCmdCamInParamsAddProfileEntry(builder, t.ProfileEntry) + AxsCmdCamInParamsAddProfileExecutionMode(builder, t.ProfileExecutionMode) + AxsCmdCamInParamsAddPointTable(builder, pointTableOffset) + AxsCmdCamInParamsAddSwitchPosition(builder, t.SwitchPosition) + AxsCmdCamInParamsAddSwitchProfileOnPos(builder, t.SwitchProfileOnPos) + AxsCmdCamInParamsAddSwitchGearOnPos(builder, t.SwitchGearOnPos) + AxsCmdCamInParamsAddSwitchPositionGainFactor(builder, t.SwitchPositionGainFactor) + AxsCmdCamInParamsAddSwitchGainFactorOnPos(builder, t.SwitchGainFactorOnPos) + return AxsCmdCamInParamsEnd(builder) +} + +func (rcv *AxsCmdCamInParams) UnPackTo(t *AxsCmdCamInParamsT) { + t.MasterOffset = rcv.MasterOffset() + t.SlaveOffset = rcv.SlaveOffset() + t.RatioNumerator = rcv.RatioNumerator() + t.RatioDenominator = rcv.RatioDenominator() + t.FineAdjust = rcv.FineAdjust() + t.GainFactor = rcv.GainFactor() + t.AngleAdjust = rcv.AngleAdjust() + t.ProfileEntry = rcv.ProfileEntry() + t.ProfileExecutionMode = rcv.ProfileExecutionMode() + t.PointTable = string(rcv.PointTable()) + t.SwitchPosition = rcv.SwitchPosition() + t.SwitchProfileOnPos = rcv.SwitchProfileOnPos() + t.SwitchGearOnPos = rcv.SwitchGearOnPos() + t.SwitchPositionGainFactor = rcv.SwitchPositionGainFactor() + t.SwitchGainFactorOnPos = rcv.SwitchGainFactorOnPos() +} + +func (rcv *AxsCmdCamInParams) UnPack() *AxsCmdCamInParamsT { + if rcv == nil { return nil } + t := &AxsCmdCamInParamsT{} + rcv.UnPackTo(t) + return t +} + +type AxsCmdCamInParams struct { + _tab flatbuffers.Table +} + +func GetRootAsAxsCmdCamInParams(buf []byte, offset flatbuffers.UOffsetT) *AxsCmdCamInParams { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &AxsCmdCamInParams{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsAxsCmdCamInParams(buf []byte, offset flatbuffers.UOffsetT) *AxsCmdCamInParams { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &AxsCmdCamInParams{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *AxsCmdCamInParams) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *AxsCmdCamInParams) Table() flatbuffers.Table { + return rcv._tab +} + +/// Constant master offset for the command instance. +func (rcv *AxsCmdCamInParams) MasterOffset() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +/// Constant master offset for the command instance. +func (rcv *AxsCmdCamInParams) MutateMasterOffset(n float64) bool { + return rcv._tab.MutateFloat64Slot(4, n) +} + +/// Constant slave offset for the command instance. +func (rcv *AxsCmdCamInParams) SlaveOffset() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +/// Constant slave offset for the command instance. +func (rcv *AxsCmdCamInParams) MutateSlaveOffset(n float64) bool { + return rcv._tab.MutateFloat64Slot(6, n) +} + +/// Numerator of gear ratio. +func (rcv *AxsCmdCamInParams) RatioNumerator() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return 1 +} + +/// Numerator of gear ratio. +func (rcv *AxsCmdCamInParams) MutateRatioNumerator(n int32) bool { + return rcv._tab.MutateInt32Slot(8, n) +} + +/// Denominator of gear ratio. +func (rcv *AxsCmdCamInParams) RatioDenominator() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return 1 +} + +/// Denominator of gear ratio. +func (rcv *AxsCmdCamInParams) MutateRatioDenominator(n int32) bool { + return rcv._tab.MutateInt32Slot(10, n) +} + +/// Constant fine adjustment percentage for the gear ratio. +func (rcv *AxsCmdCamInParams) FineAdjust() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +/// Constant fine adjustment percentage for the gear ratio. +func (rcv *AxsCmdCamInParams) MutateFineAdjust(n float64) bool { + return rcv._tab.MutateFloat64Slot(12, n) +} + +/// Scaling factor for the gain +func (rcv *AxsCmdCamInParams) GainFactor() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 1.0 +} + +/// Scaling factor for the gain +func (rcv *AxsCmdCamInParams) MutateGainFactor(n float64) bool { + return rcv._tab.MutateFloat64Slot(14, n) +} + +/// Constant angle adjust for the command instance +func (rcv *AxsCmdCamInParams) AngleAdjust() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +/// Constant angle adjust for the command instance +func (rcv *AxsCmdCamInParams) MutateAngleAdjust(n float64) bool { + return rcv._tab.MutateFloat64Slot(16, n) +} + +/// Defines the start behaviour of the point table similar to a FlexProfile +func (rcv *AxsCmdCamInParams) ProfileEntry() ProfileEntry { + o := flatbuffers.UOffsetT(rcv._tab.Offset(18)) + if o != 0 { + return ProfileEntry(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 1 +} + +/// Defines the start behaviour of the point table similar to a FlexProfile +func (rcv *AxsCmdCamInParams) MutateProfileEntry(n ProfileEntry) bool { + return rcv._tab.MutateInt8Slot(18, int8(n)) +} + +/// Specifies how the point table is executed +func (rcv *AxsCmdCamInParams) ProfileExecutionMode() ProfileExecutionMode { + o := flatbuffers.UOffsetT(rcv._tab.Offset(20)) + if o != 0 { + return ProfileExecutionMode(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +/// Specifies how the point table is executed +func (rcv *AxsCmdCamInParams) MutateProfileExecutionMode(n ProfileExecutionMode) bool { + return rcv._tab.MutateInt8Slot(20, int8(n)) +} + +/// Name of the point table that should be executed. +func (rcv *AxsCmdCamInParams) PointTable() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(22)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// Name of the point table that should be executed. +/// Master position used to switch to the new point table and/or gear. +func (rcv *AxsCmdCamInParams) SwitchPosition() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(24)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +/// Master position used to switch to the new point table and/or gear. +func (rcv *AxsCmdCamInParams) MutateSwitchPosition(n float64) bool { + return rcv._tab.MutateFloat64Slot(24, n) +} + +/// If false, switch to the selected point table immediately. If true, switch to the selected point table not until the switchPosition is reached. +func (rcv *AxsCmdCamInParams) SwitchProfileOnPos() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(26)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +/// If false, switch to the selected point table immediately. If true, switch to the selected point table not until the switchPosition is reached. +func (rcv *AxsCmdCamInParams) MutateSwitchProfileOnPos(n bool) bool { + return rcv._tab.MutateBoolSlot(26, n) +} + +/// If false, switch to the selected gear immediately. If true, switch to the selected gear not until the switchPosition is reached. +func (rcv *AxsCmdCamInParams) SwitchGearOnPos() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(28)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +/// If false, switch to the selected gear immediately. If true, switch to the selected gear not until the switchPosition is reached. +func (rcv *AxsCmdCamInParams) MutateSwitchGearOnPos(n bool) bool { + return rcv._tab.MutateBoolSlot(28, n) +} + +/// Master position used to switch to the new gain factor. +func (rcv *AxsCmdCamInParams) SwitchPositionGainFactor() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(30)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +/// Master position used to switch to the new gain factor. +func (rcv *AxsCmdCamInParams) MutateSwitchPositionGainFactor(n float64) bool { + return rcv._tab.MutateFloat64Slot(30, n) +} + +/// If false, switch to the selected gain factor immediately. If true, switch to the selected gain factor not until the switchPositionGainFactor is reached. +func (rcv *AxsCmdCamInParams) SwitchGainFactorOnPos() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(32)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +/// If false, switch to the selected gain factor immediately. If true, switch to the selected gain factor not until the switchPositionGainFactor is reached. +func (rcv *AxsCmdCamInParams) MutateSwitchGainFactorOnPos(n bool) bool { + return rcv._tab.MutateBoolSlot(32, n) +} + +func AxsCmdCamInParamsStart(builder *flatbuffers.Builder) { + builder.StartObject(15) +} +func AxsCmdCamInParamsAddMasterOffset(builder *flatbuffers.Builder, masterOffset float64) { + builder.PrependFloat64Slot(0, masterOffset, 0.0) +} +func AxsCmdCamInParamsAddSlaveOffset(builder *flatbuffers.Builder, slaveOffset float64) { + builder.PrependFloat64Slot(1, slaveOffset, 0.0) +} +func AxsCmdCamInParamsAddRatioNumerator(builder *flatbuffers.Builder, ratioNumerator int32) { + builder.PrependInt32Slot(2, ratioNumerator, 1) +} +func AxsCmdCamInParamsAddRatioDenominator(builder *flatbuffers.Builder, ratioDenominator int32) { + builder.PrependInt32Slot(3, ratioDenominator, 1) +} +func AxsCmdCamInParamsAddFineAdjust(builder *flatbuffers.Builder, fineAdjust float64) { + builder.PrependFloat64Slot(4, fineAdjust, 0.0) +} +func AxsCmdCamInParamsAddGainFactor(builder *flatbuffers.Builder, gainFactor float64) { + builder.PrependFloat64Slot(5, gainFactor, 1.0) +} +func AxsCmdCamInParamsAddAngleAdjust(builder *flatbuffers.Builder, angleAdjust float64) { + builder.PrependFloat64Slot(6, angleAdjust, 0.0) +} +func AxsCmdCamInParamsAddProfileEntry(builder *flatbuffers.Builder, profileEntry ProfileEntry) { + builder.PrependInt8Slot(7, int8(profileEntry), 1) +} +func AxsCmdCamInParamsAddProfileExecutionMode(builder *flatbuffers.Builder, profileExecutionMode ProfileExecutionMode) { + builder.PrependInt8Slot(8, int8(profileExecutionMode), 0) +} +func AxsCmdCamInParamsAddPointTable(builder *flatbuffers.Builder, pointTable flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(9, flatbuffers.UOffsetT(pointTable), 0) +} +func AxsCmdCamInParamsAddSwitchPosition(builder *flatbuffers.Builder, switchPosition float64) { + builder.PrependFloat64Slot(10, switchPosition, 0.0) +} +func AxsCmdCamInParamsAddSwitchProfileOnPos(builder *flatbuffers.Builder, switchProfileOnPos bool) { + builder.PrependBoolSlot(11, switchProfileOnPos, false) +} +func AxsCmdCamInParamsAddSwitchGearOnPos(builder *flatbuffers.Builder, switchGearOnPos bool) { + builder.PrependBoolSlot(12, switchGearOnPos, false) +} +func AxsCmdCamInParamsAddSwitchPositionGainFactor(builder *flatbuffers.Builder, switchPositionGainFactor float64) { + builder.PrependFloat64Slot(13, switchPositionGainFactor, 0.0) +} +func AxsCmdCamInParamsAddSwitchGainFactorOnPos(builder *flatbuffers.Builder, switchGainFactorOnPos bool) { + builder.PrependBoolSlot(14, switchGainFactorOnPos, false) +} +func AxsCmdCamInParamsEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/sync/fbtypes/AxsCmdFlexProfileDlParams.go b/pkg/fbs/motion/sync/fbtypes/AxsCmdFlexProfileDlParams.go index b7a8da5..ca27477 100644 --- a/pkg/fbs/motion/sync/fbtypes/AxsCmdFlexProfileDlParams.go +++ b/pkg/fbs/motion/sync/fbtypes/AxsCmdFlexProfileDlParams.go @@ -19,6 +19,11 @@ type AxsCmdFlexProfileDlParamsT struct { FofSlaveOffsetDlIdx int32 `json:"fofSlaveOffsetDlIdx"` FofSlaveOffsetTimeConstantDlIdx int32 `json:"fofSlaveOffsetTimeConstantDlIdx"` FineAdjustDlIdx int32 `json:"fineAdjustDlIdx"` + SoiAngleAdjustDlIdx int32 `json:"soiAngleAdjustDlIdx"` + SoiAngleAdjustVelDlIdx int32 `json:"soiAngleAdjustVelDlIdx"` + SoiAngleAdjustAccDlIdx int32 `json:"soiAngleAdjustAccDlIdx"` + FofAngleAdjustDlIdx int32 `json:"fofAngleAdjustDlIdx"` + FofAngleAdjustTimeConstantDlIdx int32 `json:"fofAngleAdjustTimeConstantDlIdx"` } func (t *AxsCmdFlexProfileDlParamsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { @@ -35,6 +40,11 @@ func (t *AxsCmdFlexProfileDlParamsT) Pack(builder *flatbuffers.Builder) flatbuff AxsCmdFlexProfileDlParamsAddFofSlaveOffsetDlIdx(builder, t.FofSlaveOffsetDlIdx) AxsCmdFlexProfileDlParamsAddFofSlaveOffsetTimeConstantDlIdx(builder, t.FofSlaveOffsetTimeConstantDlIdx) AxsCmdFlexProfileDlParamsAddFineAdjustDlIdx(builder, t.FineAdjustDlIdx) + AxsCmdFlexProfileDlParamsAddSoiAngleAdjustDlIdx(builder, t.SoiAngleAdjustDlIdx) + AxsCmdFlexProfileDlParamsAddSoiAngleAdjustVelDlIdx(builder, t.SoiAngleAdjustVelDlIdx) + AxsCmdFlexProfileDlParamsAddSoiAngleAdjustAccDlIdx(builder, t.SoiAngleAdjustAccDlIdx) + AxsCmdFlexProfileDlParamsAddFofAngleAdjustDlIdx(builder, t.FofAngleAdjustDlIdx) + AxsCmdFlexProfileDlParamsAddFofAngleAdjustTimeConstantDlIdx(builder, t.FofAngleAdjustTimeConstantDlIdx) return AxsCmdFlexProfileDlParamsEnd(builder) } @@ -50,6 +60,11 @@ func (rcv *AxsCmdFlexProfileDlParams) UnPackTo(t *AxsCmdFlexProfileDlParamsT) { t.FofSlaveOffsetDlIdx = rcv.FofSlaveOffsetDlIdx() t.FofSlaveOffsetTimeConstantDlIdx = rcv.FofSlaveOffsetTimeConstantDlIdx() t.FineAdjustDlIdx = rcv.FineAdjustDlIdx() + t.SoiAngleAdjustDlIdx = rcv.SoiAngleAdjustDlIdx() + t.SoiAngleAdjustVelDlIdx = rcv.SoiAngleAdjustVelDlIdx() + t.SoiAngleAdjustAccDlIdx = rcv.SoiAngleAdjustAccDlIdx() + t.FofAngleAdjustDlIdx = rcv.FofAngleAdjustDlIdx() + t.FofAngleAdjustTimeConstantDlIdx = rcv.FofAngleAdjustTimeConstantDlIdx() } func (rcv *AxsCmdFlexProfileDlParams) UnPack() *AxsCmdFlexProfileDlParamsT { @@ -240,8 +255,78 @@ func (rcv *AxsCmdFlexProfileDlParams) MutateFineAdjustDlIdx(n int32) bool { return rcv._tab.MutateInt32Slot(24, n) } +/// data layer index of angle adjust valaue +func (rcv *AxsCmdFlexProfileDlParams) SoiAngleAdjustDlIdx() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(26)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return -1 +} + +/// data layer index of angle adjust valaue +func (rcv *AxsCmdFlexProfileDlParams) MutateSoiAngleAdjustDlIdx(n int32) bool { + return rcv._tab.MutateInt32Slot(26, n) +} + +/// data layer index of angle adjust velocity constraint for second order interpolation +func (rcv *AxsCmdFlexProfileDlParams) SoiAngleAdjustVelDlIdx() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(28)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return -1 +} + +/// data layer index of angle adjust velocity constraint for second order interpolation +func (rcv *AxsCmdFlexProfileDlParams) MutateSoiAngleAdjustVelDlIdx(n int32) bool { + return rcv._tab.MutateInt32Slot(28, n) +} + +/// data layer index of angle adjust acceleration constraint for second order interpolation +func (rcv *AxsCmdFlexProfileDlParams) SoiAngleAdjustAccDlIdx() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(30)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return -1 +} + +/// data layer index of angle adjust acceleration constraint for second order interpolation +func (rcv *AxsCmdFlexProfileDlParams) MutateSoiAngleAdjustAccDlIdx(n int32) bool { + return rcv._tab.MutateInt32Slot(30, n) +} + +/// data layer index of second angle adjust, first order filtered +func (rcv *AxsCmdFlexProfileDlParams) FofAngleAdjustDlIdx() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(32)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return -1 +} + +/// data layer index of second angle adjust, first order filtered +func (rcv *AxsCmdFlexProfileDlParams) MutateFofAngleAdjustDlIdx(n int32) bool { + return rcv._tab.MutateInt32Slot(32, n) +} + +/// data layer index of time constant for change rate of fofAngleAdjust +func (rcv *AxsCmdFlexProfileDlParams) FofAngleAdjustTimeConstantDlIdx() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(34)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return -1 +} + +/// data layer index of time constant for change rate of fofAngleAdjust +func (rcv *AxsCmdFlexProfileDlParams) MutateFofAngleAdjustTimeConstantDlIdx(n int32) bool { + return rcv._tab.MutateInt32Slot(34, n) +} + func AxsCmdFlexProfileDlParamsStart(builder *flatbuffers.Builder) { - builder.StartObject(11) + builder.StartObject(16) } func AxsCmdFlexProfileDlParamsAddSoiMasterOffsetDlIdx(builder *flatbuffers.Builder, soiMasterOffsetDlIdx int32) { builder.PrependInt32Slot(0, soiMasterOffsetDlIdx, -1) @@ -276,6 +361,21 @@ func AxsCmdFlexProfileDlParamsAddFofSlaveOffsetTimeConstantDlIdx(builder *flatbu func AxsCmdFlexProfileDlParamsAddFineAdjustDlIdx(builder *flatbuffers.Builder, fineAdjustDlIdx int32) { builder.PrependInt32Slot(10, fineAdjustDlIdx, -1) } +func AxsCmdFlexProfileDlParamsAddSoiAngleAdjustDlIdx(builder *flatbuffers.Builder, soiAngleAdjustDlIdx int32) { + builder.PrependInt32Slot(11, soiAngleAdjustDlIdx, -1) +} +func AxsCmdFlexProfileDlParamsAddSoiAngleAdjustVelDlIdx(builder *flatbuffers.Builder, soiAngleAdjustVelDlIdx int32) { + builder.PrependInt32Slot(12, soiAngleAdjustVelDlIdx, -1) +} +func AxsCmdFlexProfileDlParamsAddSoiAngleAdjustAccDlIdx(builder *flatbuffers.Builder, soiAngleAdjustAccDlIdx int32) { + builder.PrependInt32Slot(13, soiAngleAdjustAccDlIdx, -1) +} +func AxsCmdFlexProfileDlParamsAddFofAngleAdjustDlIdx(builder *flatbuffers.Builder, fofAngleAdjustDlIdx int32) { + builder.PrependInt32Slot(14, fofAngleAdjustDlIdx, -1) +} +func AxsCmdFlexProfileDlParamsAddFofAngleAdjustTimeConstantDlIdx(builder *flatbuffers.Builder, fofAngleAdjustTimeConstantDlIdx int32) { + builder.PrependInt32Slot(15, fofAngleAdjustTimeConstantDlIdx, -1) +} func AxsCmdFlexProfileDlParamsEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/pkg/fbs/motion/sync/fbtypes/AxsCmdFlexProfileParams.go b/pkg/fbs/motion/sync/fbtypes/AxsCmdFlexProfileParams.go index ac28c54..ab09873 100644 --- a/pkg/fbs/motion/sync/fbtypes/AxsCmdFlexProfileParams.go +++ b/pkg/fbs/motion/sync/fbtypes/AxsCmdFlexProfileParams.go @@ -19,6 +19,7 @@ type AxsCmdFlexProfileParamsT struct { SwitchPosition float64 `json:"switchPosition"` SwitchProfileOnPos bool `json:"switchProfileOnPos"` SwitchGearOnPos bool `json:"switchGearOnPos"` + AngleAdjust float64 `json:"angleAdjust"` } func (t *AxsCmdFlexProfileParamsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { @@ -39,6 +40,7 @@ func (t *AxsCmdFlexProfileParamsT) Pack(builder *flatbuffers.Builder) flatbuffer AxsCmdFlexProfileParamsAddSwitchPosition(builder, t.SwitchPosition) AxsCmdFlexProfileParamsAddSwitchProfileOnPos(builder, t.SwitchProfileOnPos) AxsCmdFlexProfileParamsAddSwitchGearOnPos(builder, t.SwitchGearOnPos) + AxsCmdFlexProfileParamsAddAngleAdjust(builder, t.AngleAdjust) return AxsCmdFlexProfileParamsEnd(builder) } @@ -54,6 +56,7 @@ func (rcv *AxsCmdFlexProfileParams) UnPackTo(t *AxsCmdFlexProfileParamsT) { t.SwitchPosition = rcv.SwitchPosition() t.SwitchProfileOnPos = rcv.SwitchProfileOnPos() t.SwitchGearOnPos = rcv.SwitchGearOnPos() + t.AngleAdjust = rcv.AngleAdjust() } func (rcv *AxsCmdFlexProfileParams) UnPack() *AxsCmdFlexProfileParamsT { @@ -240,8 +243,22 @@ func (rcv *AxsCmdFlexProfileParams) MutateSwitchGearOnPos(n bool) bool { return rcv._tab.MutateBoolSlot(24, n) } +/// angle adjust +func (rcv *AxsCmdFlexProfileParams) AngleAdjust() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(26)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +/// angle adjust +func (rcv *AxsCmdFlexProfileParams) MutateAngleAdjust(n float64) bool { + return rcv._tab.MutateFloat64Slot(26, n) +} + func AxsCmdFlexProfileParamsStart(builder *flatbuffers.Builder) { - builder.StartObject(11) + builder.StartObject(12) } func AxsCmdFlexProfileParamsAddMasterOffset(builder *flatbuffers.Builder, masterOffset float64) { builder.PrependFloat64Slot(0, masterOffset, 0.0) @@ -276,6 +293,9 @@ func AxsCmdFlexProfileParamsAddSwitchProfileOnPos(builder *flatbuffers.Builder, func AxsCmdFlexProfileParamsAddSwitchGearOnPos(builder *flatbuffers.Builder, switchGearOnPos bool) { builder.PrependBoolSlot(10, switchGearOnPos, false) } +func AxsCmdFlexProfileParamsAddAngleAdjust(builder *flatbuffers.Builder, angleAdjust float64) { + builder.PrependFloat64Slot(11, angleAdjust, 0.0) +} func AxsCmdFlexProfileParamsEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/pkg/fbs/motion/sync/fbtypes/AxsStateCamInExecution.go b/pkg/fbs/motion/sync/fbtypes/AxsStateCamInExecution.go new file mode 100644 index 0000000..d1358cf --- /dev/null +++ b/pkg/fbs/motion/sync/fbtypes/AxsStateCamInExecution.go @@ -0,0 +1,141 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// state information of the execution +type AxsStateCamInExecutionT struct { + ActivePointTable string `json:"activePointTable"` + WaitForSwitchPos bool `json:"waitForSwitchPos"` + WaitForSwitchGain bool `json:"waitForSwitchGain"` + SingleExecutionDone bool `json:"singleExecutionDone"` +} + +func (t *AxsStateCamInExecutionT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + activePointTableOffset := flatbuffers.UOffsetT(0) + if t.ActivePointTable != "" { + activePointTableOffset = builder.CreateString(t.ActivePointTable) + } + AxsStateCamInExecutionStart(builder) + AxsStateCamInExecutionAddActivePointTable(builder, activePointTableOffset) + AxsStateCamInExecutionAddWaitForSwitchPos(builder, t.WaitForSwitchPos) + AxsStateCamInExecutionAddWaitForSwitchGain(builder, t.WaitForSwitchGain) + AxsStateCamInExecutionAddSingleExecutionDone(builder, t.SingleExecutionDone) + return AxsStateCamInExecutionEnd(builder) +} + +func (rcv *AxsStateCamInExecution) UnPackTo(t *AxsStateCamInExecutionT) { + t.ActivePointTable = string(rcv.ActivePointTable()) + t.WaitForSwitchPos = rcv.WaitForSwitchPos() + t.WaitForSwitchGain = rcv.WaitForSwitchGain() + t.SingleExecutionDone = rcv.SingleExecutionDone() +} + +func (rcv *AxsStateCamInExecution) UnPack() *AxsStateCamInExecutionT { + if rcv == nil { return nil } + t := &AxsStateCamInExecutionT{} + rcv.UnPackTo(t) + return t +} + +type AxsStateCamInExecution struct { + _tab flatbuffers.Table +} + +func GetRootAsAxsStateCamInExecution(buf []byte, offset flatbuffers.UOffsetT) *AxsStateCamInExecution { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &AxsStateCamInExecution{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsAxsStateCamInExecution(buf []byte, offset flatbuffers.UOffsetT) *AxsStateCamInExecution { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &AxsStateCamInExecution{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *AxsStateCamInExecution) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *AxsStateCamInExecution) Table() flatbuffers.Table { + return rcv._tab +} + +/// currently active point table +func (rcv *AxsStateCamInExecution) ActivePointTable() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +/// currently active point table +/// the CamIn is waiting for the specified switching position +func (rcv *AxsStateCamInExecution) WaitForSwitchPos() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +/// the CamIn is waiting for the specified switching position +func (rcv *AxsStateCamInExecution) MutateWaitForSwitchPos(n bool) bool { + return rcv._tab.MutateBoolSlot(6, n) +} + +/// the CamIn is waiting for the specified switch position for the gain factor +func (rcv *AxsStateCamInExecution) WaitForSwitchGain() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +/// the CamIn is waiting for the specified switch position for the gain factor +func (rcv *AxsStateCamInExecution) MutateWaitForSwitchGain(n bool) bool { + return rcv._tab.MutateBoolSlot(8, n) +} + +/// the one-time execution of the profile was completed (only for execution mode "SINGLE") +func (rcv *AxsStateCamInExecution) SingleExecutionDone() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +/// the one-time execution of the profile was completed (only for execution mode "SINGLE") +func (rcv *AxsStateCamInExecution) MutateSingleExecutionDone(n bool) bool { + return rcv._tab.MutateBoolSlot(10, n) +} + +func AxsStateCamInExecutionStart(builder *flatbuffers.Builder) { + builder.StartObject(4) +} +func AxsStateCamInExecutionAddActivePointTable(builder *flatbuffers.Builder, activePointTable flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(activePointTable), 0) +} +func AxsStateCamInExecutionAddWaitForSwitchPos(builder *flatbuffers.Builder, waitForSwitchPos bool) { + builder.PrependBoolSlot(1, waitForSwitchPos, false) +} +func AxsStateCamInExecutionAddWaitForSwitchGain(builder *flatbuffers.Builder, waitForSwitchGain bool) { + builder.PrependBoolSlot(2, waitForSwitchGain, false) +} +func AxsStateCamInExecutionAddSingleExecutionDone(builder *flatbuffers.Builder, singleExecutionDone bool) { + builder.PrependBoolSlot(3, singleExecutionDone, false) +} +func AxsStateCamInExecutionEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/motion/sync/fbtypes/AxsStateCamInObj.go b/pkg/fbs/motion/sync/fbtypes/AxsStateCamInObj.go new file mode 100644 index 0000000..0d471bd --- /dev/null +++ b/pkg/fbs/motion/sync/fbtypes/AxsStateCamInObj.go @@ -0,0 +1,83 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +/// state of a CamIn object +type AxsStateCamInObjT struct { + Execution *AxsStateCamInExecutionT `json:"execution"` +} + +func (t *AxsStateCamInObjT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + executionOffset := t.Execution.Pack(builder) + AxsStateCamInObjStart(builder) + AxsStateCamInObjAddExecution(builder, executionOffset) + return AxsStateCamInObjEnd(builder) +} + +func (rcv *AxsStateCamInObj) UnPackTo(t *AxsStateCamInObjT) { + t.Execution = rcv.Execution(nil).UnPack() +} + +func (rcv *AxsStateCamInObj) UnPack() *AxsStateCamInObjT { + if rcv == nil { return nil } + t := &AxsStateCamInObjT{} + rcv.UnPackTo(t) + return t +} + +type AxsStateCamInObj struct { + _tab flatbuffers.Table +} + +func GetRootAsAxsStateCamInObj(buf []byte, offset flatbuffers.UOffsetT) *AxsStateCamInObj { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &AxsStateCamInObj{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsAxsStateCamInObj(buf []byte, offset flatbuffers.UOffsetT) *AxsStateCamInObj { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &AxsStateCamInObj{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *AxsStateCamInObj) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *AxsStateCamInObj) Table() flatbuffers.Table { + return rcv._tab +} + +/// state information of execution +func (rcv *AxsStateCamInObj) Execution(obj *AxsStateCamInExecution) *AxsStateCamInExecution { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(AxsStateCamInExecution) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// state information of execution +func AxsStateCamInObjStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func AxsStateCamInObjAddExecution(builder *flatbuffers.Builder, execution flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(execution), 0) +} +func AxsStateCamInObjEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/plc/cmp/datalayer/fbs/SysCpuMultiCore.go b/pkg/fbs/plc/cmp/datalayer/fbs/SysCpuMultiCore.go new file mode 100644 index 0000000..0681705 --- /dev/null +++ b/pkg/fbs/plc/cmp/datalayer/fbs/SysCpuMultiCore.go @@ -0,0 +1,208 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type SysCpuMultiCoreT struct { + Taskgroup1 *TaskGroupT `json:"taskgroup1"` + Taskgroup2 *TaskGroupT `json:"taskgroup2"` + Taskgroup3 *TaskGroupT `json:"taskgroup3"` + Taskgroup4 *TaskGroupT `json:"taskgroup4"` + Taskgroup5 *TaskGroupT `json:"taskgroup5"` + Ieccoreset []uint32 `json:"ieccoreset"` +} + +func (t *SysCpuMultiCoreT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + taskgroup1Offset := t.Taskgroup1.Pack(builder) + taskgroup2Offset := t.Taskgroup2.Pack(builder) + taskgroup3Offset := t.Taskgroup3.Pack(builder) + taskgroup4Offset := t.Taskgroup4.Pack(builder) + taskgroup5Offset := t.Taskgroup5.Pack(builder) + ieccoresetOffset := flatbuffers.UOffsetT(0) + if t.Ieccoreset != nil { + ieccoresetLength := len(t.Ieccoreset) + SysCpuMultiCoreStartIeccoresetVector(builder, ieccoresetLength) + for j := ieccoresetLength - 1; j >= 0; j-- { + builder.PrependUint32(t.Ieccoreset[j]) + } + ieccoresetOffset = builder.EndVector(ieccoresetLength) + } + SysCpuMultiCoreStart(builder) + SysCpuMultiCoreAddTaskgroup1(builder, taskgroup1Offset) + SysCpuMultiCoreAddTaskgroup2(builder, taskgroup2Offset) + SysCpuMultiCoreAddTaskgroup3(builder, taskgroup3Offset) + SysCpuMultiCoreAddTaskgroup4(builder, taskgroup4Offset) + SysCpuMultiCoreAddTaskgroup5(builder, taskgroup5Offset) + SysCpuMultiCoreAddIeccoreset(builder, ieccoresetOffset) + return SysCpuMultiCoreEnd(builder) +} + +func (rcv *SysCpuMultiCore) UnPackTo(t *SysCpuMultiCoreT) { + t.Taskgroup1 = rcv.Taskgroup1(nil).UnPack() + t.Taskgroup2 = rcv.Taskgroup2(nil).UnPack() + t.Taskgroup3 = rcv.Taskgroup3(nil).UnPack() + t.Taskgroup4 = rcv.Taskgroup4(nil).UnPack() + t.Taskgroup5 = rcv.Taskgroup5(nil).UnPack() + ieccoresetLength := rcv.IeccoresetLength() + t.Ieccoreset = make([]uint32, ieccoresetLength) + for j := 0; j < ieccoresetLength; j++ { + t.Ieccoreset[j] = rcv.Ieccoreset(j) + } +} + +func (rcv *SysCpuMultiCore) UnPack() *SysCpuMultiCoreT { + if rcv == nil { return nil } + t := &SysCpuMultiCoreT{} + rcv.UnPackTo(t) + return t +} + +type SysCpuMultiCore struct { + _tab flatbuffers.Table +} + +func GetRootAsSysCpuMultiCore(buf []byte, offset flatbuffers.UOffsetT) *SysCpuMultiCore { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &SysCpuMultiCore{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsSysCpuMultiCore(buf []byte, offset flatbuffers.UOffsetT) *SysCpuMultiCore { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &SysCpuMultiCore{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *SysCpuMultiCore) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *SysCpuMultiCore) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *SysCpuMultiCore) Taskgroup1(obj *TaskGroup) *TaskGroup { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(TaskGroup) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *SysCpuMultiCore) Taskgroup2(obj *TaskGroup) *TaskGroup { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(TaskGroup) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *SysCpuMultiCore) Taskgroup3(obj *TaskGroup) *TaskGroup { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(TaskGroup) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *SysCpuMultiCore) Taskgroup4(obj *TaskGroup) *TaskGroup { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(TaskGroup) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *SysCpuMultiCore) Taskgroup5(obj *TaskGroup) *TaskGroup { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(TaskGroup) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *SysCpuMultiCore) Ieccoreset(j int) uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.GetUint32(a + flatbuffers.UOffsetT(j*4)) + } + return 0 +} + +func (rcv *SysCpuMultiCore) IeccoresetLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func (rcv *SysCpuMultiCore) MutateIeccoreset(j int, n uint32) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.MutateUint32(a+flatbuffers.UOffsetT(j*4), n) + } + return false +} + +func SysCpuMultiCoreStart(builder *flatbuffers.Builder) { + builder.StartObject(6) +} +func SysCpuMultiCoreAddTaskgroup1(builder *flatbuffers.Builder, taskgroup1 flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(taskgroup1), 0) +} +func SysCpuMultiCoreAddTaskgroup2(builder *flatbuffers.Builder, taskgroup2 flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(taskgroup2), 0) +} +func SysCpuMultiCoreAddTaskgroup3(builder *flatbuffers.Builder, taskgroup3 flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(taskgroup3), 0) +} +func SysCpuMultiCoreAddTaskgroup4(builder *flatbuffers.Builder, taskgroup4 flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(taskgroup4), 0) +} +func SysCpuMultiCoreAddTaskgroup5(builder *flatbuffers.Builder, taskgroup5 flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(taskgroup5), 0) +} +func SysCpuMultiCoreAddIeccoreset(builder *flatbuffers.Builder, ieccoreset flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(ieccoreset), 0) +} +func SysCpuMultiCoreStartIeccoresetVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func SysCpuMultiCoreEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/plc/cmp/datalayer/fbs/TaskGroup.go b/pkg/fbs/plc/cmp/datalayer/fbs/TaskGroup.go new file mode 100644 index 0000000..3f5e60e --- /dev/null +++ b/pkg/fbs/plc/cmp/datalayer/fbs/TaskGroup.go @@ -0,0 +1,114 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbs + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type TaskGroupT struct { + Name string `json:"name"` + Option uint32 `json:"option"` + Coreset uint32 `json:"coreset"` +} + +func (t *TaskGroupT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + nameOffset := flatbuffers.UOffsetT(0) + if t.Name != "" { + nameOffset = builder.CreateString(t.Name) + } + TaskGroupStart(builder) + TaskGroupAddName(builder, nameOffset) + TaskGroupAddOption(builder, t.Option) + TaskGroupAddCoreset(builder, t.Coreset) + return TaskGroupEnd(builder) +} + +func (rcv *TaskGroup) UnPackTo(t *TaskGroupT) { + t.Name = string(rcv.Name()) + t.Option = rcv.Option() + t.Coreset = rcv.Coreset() +} + +func (rcv *TaskGroup) UnPack() *TaskGroupT { + if rcv == nil { return nil } + t := &TaskGroupT{} + rcv.UnPackTo(t) + return t +} + +type TaskGroup struct { + _tab flatbuffers.Table +} + +func GetRootAsTaskGroup(buf []byte, offset flatbuffers.UOffsetT) *TaskGroup { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &TaskGroup{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsTaskGroup(buf []byte, offset flatbuffers.UOffsetT) *TaskGroup { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &TaskGroup{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *TaskGroup) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *TaskGroup) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *TaskGroup) Name() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *TaskGroup) Option() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *TaskGroup) MutateOption(n uint32) bool { + return rcv._tab.MutateUint32Slot(6, n) +} + +func (rcv *TaskGroup) Coreset() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *TaskGroup) MutateCoreset(n uint32) bool { + return rcv._tab.MutateUint32Slot(8, n) +} + +func TaskGroupStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func TaskGroupAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0) +} +func TaskGroupAddOption(builder *flatbuffers.Builder, option uint32) { + builder.PrependUint32Slot(1, option, 0) +} +func TaskGroupAddCoreset(builder *flatbuffers.Builder, coreset uint32) { + builder.PrependUint32Slot(2, coreset, 0) +} +func TaskGroupEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/CmdType_CmdOptionInfoReq.go b/pkg/fbs/script/manager/fbtypes/CmdType_CmdOptionInfoReq.go index ae1f4e5..a14ddfb 100644 --- a/pkg/fbs/script/manager/fbtypes/CmdType_CmdOptionInfoReq.go +++ b/pkg/fbs/script/manager/fbtypes/CmdType_CmdOptionInfoReq.go @@ -7,21 +7,27 @@ import "strconv" type CmdType_CmdOptionInfoReq int8 const ( - CmdType_CmdOptionInfoReqUNKNOWN CmdType_CmdOptionInfoReq = 0 - CmdType_CmdOptionInfoReqCMD CmdType_CmdOptionInfoReq = 1 - CmdType_CmdOptionInfoReqCMD_OPTION CmdType_CmdOptionInfoReq = 2 + CmdType_CmdOptionInfoReqUNKNOWN CmdType_CmdOptionInfoReq = 0 + CmdType_CmdOptionInfoReqCMD CmdType_CmdOptionInfoReq = 1 + CmdType_CmdOptionInfoReqCMD_OPTION CmdType_CmdOptionInfoReq = 2 + CmdType_CmdOptionInfoReqCMD_OPTION_ONCE CmdType_CmdOptionInfoReq = 3 + CmdType_CmdOptionInfoReqCMD_OPTION_PERMANENT CmdType_CmdOptionInfoReq = 4 ) var EnumNamesCmdType_CmdOptionInfoReq = map[CmdType_CmdOptionInfoReq]string{ - CmdType_CmdOptionInfoReqUNKNOWN: "UNKNOWN", - CmdType_CmdOptionInfoReqCMD: "CMD", - CmdType_CmdOptionInfoReqCMD_OPTION: "CMD_OPTION", + CmdType_CmdOptionInfoReqUNKNOWN: "UNKNOWN", + CmdType_CmdOptionInfoReqCMD: "CMD", + CmdType_CmdOptionInfoReqCMD_OPTION: "CMD_OPTION", + CmdType_CmdOptionInfoReqCMD_OPTION_ONCE: "CMD_OPTION_ONCE", + CmdType_CmdOptionInfoReqCMD_OPTION_PERMANENT: "CMD_OPTION_PERMANENT", } var EnumValuesCmdType_CmdOptionInfoReq = map[string]CmdType_CmdOptionInfoReq{ - "UNKNOWN": CmdType_CmdOptionInfoReqUNKNOWN, - "CMD": CmdType_CmdOptionInfoReqCMD, - "CMD_OPTION": CmdType_CmdOptionInfoReqCMD_OPTION, + "UNKNOWN": CmdType_CmdOptionInfoReqUNKNOWN, + "CMD": CmdType_CmdOptionInfoReqCMD, + "CMD_OPTION": CmdType_CmdOptionInfoReqCMD_OPTION, + "CMD_OPTION_ONCE": CmdType_CmdOptionInfoReqCMD_OPTION_ONCE, + "CMD_OPTION_PERMANENT": CmdType_CmdOptionInfoReqCMD_OPTION_PERMANENT, } func (v CmdType_CmdOptionInfoReq) String() string { diff --git a/pkg/fbs/script/manager/fbtypes/CmdType_ListRegisteredCmdsOptions.go b/pkg/fbs/script/manager/fbtypes/CmdType_ListRegisteredCmdsOptions.go index 7e98229..5c98843 100644 --- a/pkg/fbs/script/manager/fbtypes/CmdType_ListRegisteredCmdsOptions.go +++ b/pkg/fbs/script/manager/fbtypes/CmdType_ListRegisteredCmdsOptions.go @@ -7,21 +7,27 @@ import "strconv" type CmdType_ListRegisteredCmdsOptions int8 const ( - CmdType_ListRegisteredCmdsOptionsUNKNOWN CmdType_ListRegisteredCmdsOptions = 0 - CmdType_ListRegisteredCmdsOptionsCMD CmdType_ListRegisteredCmdsOptions = 1 - CmdType_ListRegisteredCmdsOptionsCMD_OPTION CmdType_ListRegisteredCmdsOptions = 2 + CmdType_ListRegisteredCmdsOptionsUNKNOWN CmdType_ListRegisteredCmdsOptions = 0 + CmdType_ListRegisteredCmdsOptionsCMD CmdType_ListRegisteredCmdsOptions = 1 + CmdType_ListRegisteredCmdsOptionsCMD_OPTION CmdType_ListRegisteredCmdsOptions = 2 + CmdType_ListRegisteredCmdsOptionsCMD_OPTION_ONCE CmdType_ListRegisteredCmdsOptions = 3 + CmdType_ListRegisteredCmdsOptionsCMD_OPTION_PERMANENT CmdType_ListRegisteredCmdsOptions = 4 ) var EnumNamesCmdType_ListRegisteredCmdsOptions = map[CmdType_ListRegisteredCmdsOptions]string{ - CmdType_ListRegisteredCmdsOptionsUNKNOWN: "UNKNOWN", - CmdType_ListRegisteredCmdsOptionsCMD: "CMD", - CmdType_ListRegisteredCmdsOptionsCMD_OPTION: "CMD_OPTION", + CmdType_ListRegisteredCmdsOptionsUNKNOWN: "UNKNOWN", + CmdType_ListRegisteredCmdsOptionsCMD: "CMD", + CmdType_ListRegisteredCmdsOptionsCMD_OPTION: "CMD_OPTION", + CmdType_ListRegisteredCmdsOptionsCMD_OPTION_ONCE: "CMD_OPTION_ONCE", + CmdType_ListRegisteredCmdsOptionsCMD_OPTION_PERMANENT: "CMD_OPTION_PERMANENT", } var EnumValuesCmdType_ListRegisteredCmdsOptions = map[string]CmdType_ListRegisteredCmdsOptions{ - "UNKNOWN": CmdType_ListRegisteredCmdsOptionsUNKNOWN, - "CMD": CmdType_ListRegisteredCmdsOptionsCMD, - "CMD_OPTION": CmdType_ListRegisteredCmdsOptionsCMD_OPTION, + "UNKNOWN": CmdType_ListRegisteredCmdsOptionsUNKNOWN, + "CMD": CmdType_ListRegisteredCmdsOptionsCMD, + "CMD_OPTION": CmdType_ListRegisteredCmdsOptionsCMD_OPTION, + "CMD_OPTION_ONCE": CmdType_ListRegisteredCmdsOptionsCMD_OPTION_ONCE, + "CMD_OPTION_PERMANENT": CmdType_ListRegisteredCmdsOptionsCMD_OPTION_PERMANENT, } func (v CmdType_ListRegisteredCmdsOptions) String() string { diff --git a/pkg/fbs/script/manager/fbtypes/Cmd_AxsStop.go b/pkg/fbs/script/manager/fbtypes/Cmd_AxsStop.go new file mode 100644 index 0000000..3654013 --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/Cmd_AxsStop.go @@ -0,0 +1,134 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Cmd_AxsStopT struct { + Base *Cmd_BaseT `json:"base"` + DoStop bool `json:"doStop"` + Dec float64 `json:"dec"` + JrkDec float64 `json:"jrkDec"` +} + +func (t *Cmd_AxsStopT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + baseOffset := t.Base.Pack(builder) + Cmd_AxsStopStart(builder) + Cmd_AxsStopAddBase(builder, baseOffset) + Cmd_AxsStopAddDoStop(builder, t.DoStop) + Cmd_AxsStopAddDec(builder, t.Dec) + Cmd_AxsStopAddJrkDec(builder, t.JrkDec) + return Cmd_AxsStopEnd(builder) +} + +func (rcv *Cmd_AxsStop) UnPackTo(t *Cmd_AxsStopT) { + t.Base = rcv.Base(nil).UnPack() + t.DoStop = rcv.DoStop() + t.Dec = rcv.Dec() + t.JrkDec = rcv.JrkDec() +} + +func (rcv *Cmd_AxsStop) UnPack() *Cmd_AxsStopT { + if rcv == nil { return nil } + t := &Cmd_AxsStopT{} + rcv.UnPackTo(t) + return t +} + +type Cmd_AxsStop struct { + _tab flatbuffers.Table +} + +func GetRootAsCmd_AxsStop(buf []byte, offset flatbuffers.UOffsetT) *Cmd_AxsStop { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Cmd_AxsStop{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsCmd_AxsStop(buf []byte, offset flatbuffers.UOffsetT) *Cmd_AxsStop { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Cmd_AxsStop{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *Cmd_AxsStop) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Cmd_AxsStop) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Cmd_AxsStop) Base(obj *Cmd_Base) *Cmd_Base { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(Cmd_Base) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *Cmd_AxsStop) DoStop() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +func (rcv *Cmd_AxsStop) MutateDoStop(n bool) bool { + return rcv._tab.MutateBoolSlot(6, n) +} + +func (rcv *Cmd_AxsStop) Dec() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *Cmd_AxsStop) MutateDec(n float64) bool { + return rcv._tab.MutateFloat64Slot(8, n) +} + +func (rcv *Cmd_AxsStop) JrkDec() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *Cmd_AxsStop) MutateJrkDec(n float64) bool { + return rcv._tab.MutateFloat64Slot(10, n) +} + +func Cmd_AxsStopStart(builder *flatbuffers.Builder) { + builder.StartObject(4) +} +func Cmd_AxsStopAddBase(builder *flatbuffers.Builder, base flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(base), 0) +} +func Cmd_AxsStopAddDoStop(builder *flatbuffers.Builder, doStop bool) { + builder.PrependBoolSlot(1, doStop, false) +} +func Cmd_AxsStopAddDec(builder *flatbuffers.Builder, dec float64) { + builder.PrependFloat64Slot(2, dec, 0.0) +} +func Cmd_AxsStopAddJrkDec(builder *flatbuffers.Builder, jrkDec float64) { + builder.PrependFloat64Slot(3, jrkDec, 0.0) +} +func Cmd_AxsStopEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/script/manager/fbtypes/ProbeIndexType.go b/pkg/fbs/script/manager/fbtypes/ProbeIndexType.go new file mode 100644 index 0000000..93eedfa --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/ProbeIndexType.go @@ -0,0 +1,36 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import "strconv" + +/// type of probe index +type ProbeIndexType int8 + +const ( + ///< probe undefine + ProbeIndexTypePROBE_UNDEFINE ProbeIndexType = -1 + ///< probe1 channel + ProbeIndexTypePROBE1 ProbeIndexType = 0 + ///< probe2 channel + ProbeIndexTypePROBE2 ProbeIndexType = 1 +) + +var EnumNamesProbeIndexType = map[ProbeIndexType]string{ + ProbeIndexTypePROBE_UNDEFINE: "PROBE_UNDEFINE", + ProbeIndexTypePROBE1: "PROBE1", + ProbeIndexTypePROBE2: "PROBE2", +} + +var EnumValuesProbeIndexType = map[string]ProbeIndexType{ + "PROBE_UNDEFINE": ProbeIndexTypePROBE_UNDEFINE, + "PROBE1": ProbeIndexTypePROBE1, + "PROBE2": ProbeIndexTypePROBE2, +} + +func (v ProbeIndexType) String() string { + if s, ok := EnumNamesProbeIndexType[v]; ok { + return s + } + return "ProbeIndexType(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/pkg/fbs/script/manager/fbtypes/cmd_AxsProbeEx.go b/pkg/fbs/script/manager/fbtypes/cmd_AxsProbeEx.go new file mode 100644 index 0000000..11b9909 --- /dev/null +++ b/pkg/fbs/script/manager/fbtypes/cmd_AxsProbeEx.go @@ -0,0 +1,102 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package fbtypes + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type cmd_AxsProbeExT struct { + Base *Cmd_BaseT `json:"base"` + ProbeIndex ProbeIndexType `json:"probeIndex"` +} + +func (t *cmd_AxsProbeExT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + baseOffset := t.Base.Pack(builder) + cmd_AxsProbeExStart(builder) + cmd_AxsProbeExAddBase(builder, baseOffset) + cmd_AxsProbeExAddProbeIndex(builder, t.ProbeIndex) + return cmd_AxsProbeExEnd(builder) +} + +func (rcv *cmd_AxsProbeEx) UnPackTo(t *cmd_AxsProbeExT) { + t.Base = rcv.Base(nil).UnPack() + t.ProbeIndex = rcv.ProbeIndex() +} + +func (rcv *cmd_AxsProbeEx) UnPack() *cmd_AxsProbeExT { + if rcv == nil { return nil } + t := &cmd_AxsProbeExT{} + rcv.UnPackTo(t) + return t +} + +type cmd_AxsProbeEx struct { + _tab flatbuffers.Table +} + +func GetRootAscmd_AxsProbeEx(buf []byte, offset flatbuffers.UOffsetT) *cmd_AxsProbeEx { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &cmd_AxsProbeEx{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAscmd_AxsProbeEx(buf []byte, offset flatbuffers.UOffsetT) *cmd_AxsProbeEx { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &cmd_AxsProbeEx{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *cmd_AxsProbeEx) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *cmd_AxsProbeEx) Table() flatbuffers.Table { + return rcv._tab +} + +/// command base input +func (rcv *cmd_AxsProbeEx) Base(obj *Cmd_Base) *Cmd_Base { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(Cmd_Base) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +/// command base input +/// probe index +func (rcv *cmd_AxsProbeEx) ProbeIndex() ProbeIndexType { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return ProbeIndexType(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 0 +} + +/// probe index +func (rcv *cmd_AxsProbeEx) MutateProbeIndex(n ProbeIndexType) bool { + return rcv._tab.MutateInt8Slot(6, int8(n)) +} + +func cmd_AxsProbeExStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func cmd_AxsProbeExAddBase(builder *flatbuffers.Builder, base flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(base), 0) +} +func cmd_AxsProbeExAddProbeIndex(builder *flatbuffers.Builder, probeIndex ProbeIndexType) { + builder.PrependInt8Slot(1, int8(probeIndex), 0) +} +func cmd_AxsProbeExEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/pkg/fbs/web/automation/DeleteOptions.go b/pkg/fbs/web/automation/DeleteOptions.go new file mode 100644 index 0000000..f02ee17 --- /dev/null +++ b/pkg/fbs/web/automation/DeleteOptions.go @@ -0,0 +1,80 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package automation + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type DeleteOptionsT struct { + Forceclose bool `json:"forceclose"` +} + +func (t *DeleteOptionsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + if t == nil { return 0 } + DeleteOptionsStart(builder) + DeleteOptionsAddForceclose(builder, t.Forceclose) + return DeleteOptionsEnd(builder) +} + +func (rcv *DeleteOptions) UnPackTo(t *DeleteOptionsT) { + t.Forceclose = rcv.Forceclose() +} + +func (rcv *DeleteOptions) UnPack() *DeleteOptionsT { + if rcv == nil { return nil } + t := &DeleteOptionsT{} + rcv.UnPackTo(t) + return t +} + +type DeleteOptions struct { + _tab flatbuffers.Table +} + +func GetRootAsDeleteOptions(buf []byte, offset flatbuffers.UOffsetT) *DeleteOptions { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &DeleteOptions{} + x.Init(buf, n+offset) + return x +} + +func GetSizePrefixedRootAsDeleteOptions(buf []byte, offset flatbuffers.UOffsetT) *DeleteOptions { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &DeleteOptions{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func (rcv *DeleteOptions) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *DeleteOptions) Table() flatbuffers.Table { + return rcv._tab +} + +/// force close of all connections for this subscription +func (rcv *DeleteOptions) Forceclose() bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetBool(o + rcv._tab.Pos) + } + return false +} + +/// force close of all connections for this subscription +func (rcv *DeleteOptions) MutateForceclose(n bool) bool { + return rcv._tab.MutateBoolSlot(4, n) +} + +func DeleteOptionsStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func DeleteOptionsAddForceclose(builder *flatbuffers.Builder, forceclose bool) { + builder.PrependBoolSlot(0, forceclose, false) +} +func DeleteOptionsEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/test/datalayer/metadatabuilder_test.go b/test/datalayer/metadatabuilder_test.go index 84621ab..42bb8b8 100644 --- a/test/datalayer/metadatabuilder_test.go +++ b/test/datalayer/metadatabuilder_test.go @@ -1,7 +1,7 @@ /** * MIT License * - * Copyright (c) 2021-2022 Bosch Rexroth AG + * Copyright (c) 2021-2024 Bosch Rexroth AG * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal @@ -166,3 +166,19 @@ func TestMetadataDisplayNamesBuilder(t *testing.T) { assert.Equal(t, string(e.Text()), "value_"+s) } } + +/* +flatbuffers commit: https://github.com/google/flatbuffers/commit/96d438df47d +Problem with displaying flatbuffers provider nodes +*/ +func TestMetadataBuilderRequiredFieldsEmptyDescriptionUrl(t *testing.T) { + + m := datalayer.NewMetaDataBuilder(datalayer.AllowedOperationRead, "", "") + v := m.Build() + defer datalayer.DeleteVariant(v) + assert.NotNil(t, v) + d := fbs.GetRootAsMetadata(v.GetFlatbuffers(), 0) + assert.NotNil(t, d) + assert.NotNil(t, d.Description()) + assert.NotNil(t, d.DescriptionUrl()) +}