Cadoles/go-emlid
22
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

feat: initial commit

Browse Source
This commit is contained in:
wpetit
2024-07-30 14:28:39 +02:00
commit 4729c54076
39 changed files with 3850 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

96
reach/client/client.go Normal file
View File

@ -0,0 +1,96 @@
package client
import (
"context"
"sync"
"forge.cadoles.com/cadoles/go-emlid/reach/client/protocol"
"github.com/pkg/errors"
)
type Client struct {
addr string
opts *Options
proto protocol.Identifier
ops protocol.Operations
getProtocolOnce sync.Once
getProtocolOnceErr error
}
func (c *Client) Protocol(ctx context.Context) (protocol.Identifier, protocol.Operations, error) {
id, ops, err := c.getProtocol(ctx)
if err != nil {
return "", nil, errors.WithStack(err)
}
return id, ops, nil
}
func (c *Client) getProtocol(ctx context.Context) (protocol.Identifier, protocol.Operations, error) {
c.getProtocolOnce.Do(func() {
availables, err := c.opts.Protocols.Availables(ctx, c.addr)
if err != nil {
c.getProtocolOnceErr = errors.WithStack(err)
return
}
var preferred protocol.Protocol
var fallback protocol.Protocol
for _, proto := range availables {
if proto.Identifier() == c.opts.FallbackProtocol {
fallback = proto
}
if proto.Identifier() == c.opts.PreferredProtocol {
preferred = proto
break
}
}
if preferred != nil {
c.proto = preferred.Identifier()
c.ops = preferred.Operations(c.addr)
return
}
if fallback != nil {
c.proto = fallback.Identifier()
c.ops = fallback.Operations(c.addr)
return
}
for _, proto := range availables {
if proto.Identifier() != c.opts.FallbackProtocol {
continue
}
fallback = proto
break
}
if fallback == nil {
c.getProtocolOnceErr = errors.Errorf("neither preferred protocol '%v' or fallback '%v' are available", c.opts.PreferredProtocol, c.opts.FallbackProtocol)
return
}
c.proto = fallback.Identifier()
c.ops = fallback.Operations(c.addr)
})
if c.getProtocolOnceErr != nil {
return "", nil, errors.WithStack(c.getProtocolOnceErr)
}
return c.proto, c.ops, nil
}
func NewClient(addr string, funcs ...OptionFunc) *Client {
opts := NewOptions(funcs...)
client := &Client{
addr: addr,
opts: opts,
}
return client
}

54
reach/client/helper.go Normal file
View File

@ -0,0 +1,54 @@
package client
import (
"context"
"github.com/mitchellh/mapstructure"
"github.com/pkg/errors"
)
func OnMessage[T any](ctx context.Context, client *Client, mType string) (chan T, error) {
ch := make(chan T)
rawChan, err := client.On(ctx, mType)
if err != nil {
return nil, errors.WithStack(err)
}
go func() {
defer close(ch)
for {
select {
case <-ctx.Done():
return
case rawMsg := <-rawChan:
var msg T
if err := mapstructure.Decode(rawMsg, &msg); err != nil {
panic(errors.WithStack(err))
}
ch <- msg
}
}
}()
return ch, nil
}
// Broadcast is a broadcasted message containing module realtime informations.
type Broadcast struct {
Name string `mapstructure:"name" json:"name"`
Payload any `mapstructure:"payload" json:"payload"`
}
// OnBroadcast listens for ReachView "broadcast" messages
func OnBroadcast(ctx context.Context, client *Client) (chan Broadcast, error) {
ch, err := OnMessage[Broadcast](ctx, client, "broadcast")
if err != nil {
return nil, errors.WithStack(err)
}
return ch, nil
}

140
reach/client/operations.go Normal file
View File

@ -0,0 +1,140 @@
package client
import (
"context"
"forge.cadoles.com/cadoles/go-emlid/reach/client/protocol"
"github.com/pkg/errors"
)
// Emit implements protocol.Operations.
func (c *Client) Emit(ctx context.Context, mType string, message any) error {
_, ops, err := c.getProtocol(ctx)
if err != nil {
return errors.WithStack(err)
}
if err := ops.Emit(ctx, mType, message); err != nil {
return errors.WithStack(err)
}
return nil
}
// Configuration implements protocol.Operations.
func (c *Client) Configuration(ctx context.Context) (any, error) {
_, ops, err := c.getProtocol(ctx)
if err != nil {
return nil, errors.WithStack(err)
}
config, err := ops.Configuration(ctx)
if err != nil {
return nil, errors.WithStack(err)
}
return config, nil
}
// Version implements protocol.Operations.
func (c *Client) Version(ctx context.Context) (string, bool, error) {
_, ops, err := c.getProtocol(ctx)
if err != nil {
return "", false, errors.WithStack(err)
}
version, stable, err := ops.Version(ctx)
if err != nil {
return "", false, errors.WithStack(err)
}
return version, stable, nil
}
// Close implements protocol.Operations.
func (c *Client) Close(ctx context.Context) error {
_, ops, err := c.getProtocol(ctx)
if err != nil {
return errors.WithStack(err)
}
if err := ops.Close(ctx); err != nil {
return errors.WithStack(err)
}
return nil
}
// Connect implements protocol.Operations.
func (c *Client) Connect(ctx context.Context) error {
_, ops, err := c.getProtocol(ctx)
if err != nil {
return errors.WithStack(err)
}
if err := ops.Connect(ctx); err != nil {
return errors.WithStack(err)
}
return nil
}
// Alive implements protocol.Operations.
func (c *Client) Alive(ctx context.Context) (bool, error) {
_, ops, err := c.getProtocol(ctx)
if err != nil {
return false, errors.WithStack(err)
}
alive, err := ops.Alive(ctx)
if err != nil {
return false, errors.WithStack(err)
}
return alive, nil
}
// On implements protocol.Operations.
func (c *Client) On(ctx context.Context, messageType string) (chan any, error) {
_, ops, err := c.getProtocol(ctx)
if err != nil {
return nil, errors.WithStack(err)
}
ch, err := ops.On(ctx, messageType)
if err != nil {
return nil, errors.WithStack(err)
}
return ch, nil
}
// SetBase implements protocol.Operations.
func (c *Client) SetBase(ctx context.Context, funcs ...protocol.SetBaseOptionFunc) error {
_, ops, err := c.getProtocol(ctx)
if err != nil {
return errors.WithStack(err)
}
if err := ops.SetBase(ctx, funcs...); err != nil {
return errors.WithStack(err)
}
return nil
}
// Reboot implements protocol.Operations.
func (c *Client) Reboot(ctx context.Context) error {
_, ops, err := c.getProtocol(ctx)
if err != nil {
return errors.WithStack(err)
}
if err := ops.Reboot(ctx); err != nil {
return errors.WithStack(err)
}
return nil
}
var _ protocol.Operations = &Client{}

47
reach/client/options.go Normal file
View File

@ -0,0 +1,47 @@
package client
import (
"forge.cadoles.com/cadoles/go-emlid/reach/client/protocol"
v1 "forge.cadoles.com/cadoles/go-emlid/reach/client/protocol/v1"
v2 "forge.cadoles.com/cadoles/go-emlid/reach/client/protocol/v2"
)
type Options struct {
Protocols *protocol.Registry
PreferredProtocol protocol.Identifier
FallbackProtocol protocol.Identifier
}
type OptionFunc func(opts *Options)
func NewOptions(funcs ...OptionFunc) *Options {
opts := &Options{
PreferredProtocol: v2.Identifier,
FallbackProtocol: v1.Identifier,
Protocols: protocol.DefaultRegistry(),
}
for _, fn := range funcs {
fn(opts)
}
return opts
}
func WithPreferredProtocol(identifier protocol.Identifier) OptionFunc {
return func(opts *Options) {
opts.PreferredProtocol = identifier
}
}
func WithFallbackProtocol(identifier protocol.Identifier) OptionFunc {
return func(opts *Options) {
opts.FallbackProtocol = identifier
}
}
func WithProtocols(protocols *protocol.Registry) OptionFunc {
return func(opts *Options) {
opts.Protocols = protocols
}
}

9
reach/client/protocol/error.go Normal file
View File

@ -0,0 +1,9 @@
package protocol
import "errors"
var (
ErrNotFound = errors.New("not found")
ErrClosed = errors.New("closed")
ErrUnimplemented = errors.New("unimplemented")
)

34
reach/client/protocol/operations.go Normal file
View File

@ -0,0 +1,34 @@
package protocol
import "context"
type Operations interface {
// Connect initiates a new connection to the ReachView service
// It should be called before any other operation
Connect(ctx context.Context) error
// Close closes the current connection to the ReachView service
Close(ctx context.Context) error
// Alive returns true if the ReachView websocket connection is alive, false otherwise
Alive(ctx context.Context) (bool, error)
// Version returns the current ReachView version,
// true if the module uses the stable channel or an error
Version(ctx context.Context) (string, bool, error)
// On listens for messages of the given type on ReachView websocket connection
On(ctx context.Context, mType string) (chan any, error)
// Emit sends the given message on the ReachView websocket connection
Emit(ctx context.Context, mType string, message any) error
// Configuration retrieves the module's configuration
Configuration(ctx context.Context) (any, error)
// SetBase updates the base configuration
SetBase(ctx context.Context, funcs ...SetBaseOptionFunc) error
// Reboot restarts the module
Reboot(ctx context.Context) error
}

13
reach/client/protocol/protocol.go Normal file
View File

@ -0,0 +1,13 @@
package protocol
import (
"context"
)
type Identifier string
type Protocol interface {
Identifier() Identifier
Available(ctx context.Context, addr string) (bool, error)
Operations(addr string) Operations
}

54
reach/client/protocol/registry.go Normal file
View File

@ -0,0 +1,54 @@
package protocol
import (
"context"
"github.com/pkg/errors"
)
type Registry struct {
protocols map[Identifier]Protocol
}
func (r *Registry) Register(protocol Protocol) {
r.protocols[protocol.Identifier()] = protocol
}
func (r *Registry) Availables(ctx context.Context, addr string) ([]Protocol, error) {
availables := make([]Protocol, 0)
for _, proto := range r.protocols {
available, err := proto.Available(ctx, addr)
if err != nil {
return nil, errors.WithStack(err)
}
if !available {
continue
}
availables = append(availables, proto)
}
return availables, nil
}
func NewRegistry() *Registry {
return &Registry{
protocols: make(map[Identifier]Protocol),
}
}
var defaultRegistry = NewRegistry()
func DefaultRegistry() *Registry {
return defaultRegistry
}
func Register(protocol Protocol) {
defaultRegistry.Register(protocol)
}
func Availables(ctx context.Context, addr string) ([]Protocol, error) {
return defaultRegistry.Availables(ctx, addr)
}

49
reach/client/protocol/set_base.go Normal file
View File

@ -0,0 +1,49 @@
package protocol
type SetBaseOptions struct {
Mode *string
AntennaOffset *float64
Latitude *float64
Longitude *float64
Height *float64
}
type SetBaseOptionFunc func(opts *SetBaseOptions)
func NewSetBaseOptions(funcs ...SetBaseOptionFunc) *SetBaseOptions {
opts := &SetBaseOptions{}
for _, fn := range funcs {
fn(opts)
}
return opts
}
func WithBaseMode(value string) SetBaseOptionFunc {
return func(opts *SetBaseOptions) {
opts.Mode = &value
}
}
func WithBaseAntennaOffset(value float64) SetBaseOptionFunc {
return func(opts *SetBaseOptions) {
opts.AntennaOffset = &value
}
}
func WithBaseLatitude(value float64) SetBaseOptionFunc {
return func(opts *SetBaseOptions) {
opts.Latitude = &value
}
}
func WithBaseLongitude(value float64) SetBaseOptionFunc {
return func(opts *SetBaseOptions) {
opts.Longitude = &value
}
}
func WithBaseHeight(value float64) SetBaseOptionFunc {
return func(opts *SetBaseOptions) {
opts.Height = &value
}
}

182
reach/client/protocol/testsuite/operations.go Normal file
View File

@ -0,0 +1,182 @@
package testsuite
import (
"context"
"os"
"testing"
"time"
"forge.cadoles.com/cadoles/go-emlid/reach"
"forge.cadoles.com/cadoles/go-emlid/reach/client/protocol"
"github.com/davecgh/go-spew/spew"
"github.com/pkg/errors"
)
type OperationsFactoryFunc func(addr string) (protocol.Operations, error)
type operationTestCase struct {
Name string
Run func(t *testing.T, ops protocol.Operations)
}
var testCases = []operationTestCase{
{
Name: "Connect to ReachView",
Run: func(t *testing.T, ops protocol.Operations) {
ctx := context.Background()
if err := ops.Connect(ctx); err != nil {
t.Errorf("%+v", errors.WithStack(err))
return
}
defer func() {
if err := ops.Close(ctx); err != nil {
t.Errorf("%+v", errors.WithStack(err))
}
}()
alive, err := ops.Alive(ctx)
if err != nil {
t.Errorf("%+v", errors.WithStack(err))
return
}
if e, g := true, alive; e != g {
t.Errorf("alive: expected '%v', got '%v'", e, g)
}
},
},
{
Name: "Retrieve ReachView version",
Run: func(t *testing.T, ops protocol.Operations) {
ctx := context.Background()
version, stable, err := ops.Version(ctx)
if err != nil {
t.Errorf("%+v", errors.WithStack(err))
return
}
t.Logf("ReachView version: %s", version)
t.Logf("ReachView stable channel: %v", stable)
},
},
{
Name: "Listen to ReachView 'broadcast' messages",
Run: func(t *testing.T, ops protocol.Operations) {
ctx := context.Background()
if err := ops.Connect(ctx); err != nil {
t.Errorf("%+v", errors.WithStack(err))
return
}
defer func() {
if err := ops.Close(ctx); err != nil {
t.Errorf("%+v", errors.WithStack(err))
}
}()
broadcastCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
messages, err := ops.On(broadcastCtx, "broadcast")
if err != nil {
t.Errorf("%+v", errors.WithStack(err))
return
}
count := 0
for m := range messages {
t.Logf("new message: %s", spew.Sdump(m))
count++
}
if e, g := 1, count; g < e {
t.Errorf("expected total messages > %d, got %d", e, g)
}
},
},
{
Name: "Retrieve module configuration",
Run: func(t *testing.T, ops protocol.Operations) {
ctx := context.Background()
config, err := ops.Configuration(ctx)
if err != nil {
t.Errorf("%+v", errors.WithStack(err))
return
}
t.Logf("Module configuration: %s", spew.Sdump(config))
},
},
{
Name: "Set base",
Run: func(t *testing.T, ops protocol.Operations) {
ctx := context.Background()
opts := []protocol.SetBaseOptionFunc{
protocol.WithBaseLatitude(47.72769),
protocol.WithBaseLongitude(4.72783),
protocol.WithBaseHeight(101),
protocol.WithBaseMode("manual"),
}
if err := ops.SetBase(ctx, opts...); err != nil {
t.Errorf("%+v", errors.WithStack(err))
return
}
},
},
{
Name: "Reboot",
Run: func(t *testing.T, ops protocol.Operations) {
ctx := context.Background()
if err := ops.Connect(ctx); err != nil {
t.Errorf("%+v", errors.WithStack(err))
return
}
defer func() {
if err := ops.Close(ctx); err != nil {
t.Errorf("%+v", errors.WithStack(err))
}
}()
if err := ops.Reboot(ctx); err != nil {
t.Errorf("%+v", errors.WithStack(err))
return
}
},
},
}
func TestOperations(t *testing.T, opsFactory OperationsFactoryFunc) {
reach.AssertIntegrationTests(t)
addr := os.Getenv("REACHRS_HOST")
if addr == "" {
addr = "192.168.42.1"
t.Logf("Targeting '%s'. You can modify targeted host by specifying environment variable REACHRS_HOST", addr)
} else {
t.Logf("Targeting '%s'", addr)
}
for _, tc := range testCases {
t.Run(tc.Name, func(t *testing.T) {
ops, err := opsFactory(addr)
if err != nil {
t.Fatalf("could not initialize protocol operations: %+v", errors.WithStack(err))
}
tc.Run(t, ops)
})
}
}

7
reach/client/protocol/v1/init.go Normal file
View File

@ -0,0 +1,7 @@
package v1
import "forge.cadoles.com/cadoles/go-emlid/reach/client/protocol"
func init() {
protocol.Register(&Protocol{})
}

91
reach/client/protocol/v1/internal.go Normal file
View File

@ -0,0 +1,91 @@
package v1
import (
"context"
"sync"
"forge.cadoles.com/cadoles/go-emlid/reach/client/protocol"
"forge.cadoles.com/cadoles/go-emlid/reach/client/protocol/v1/model"
"forge.cadoles.com/cadoles/go-emlid/reach/client/socketio"
"github.com/mitchellh/mapstructure"
"github.com/pkg/errors"
)
const (
eventGetConfiguration = "get configuration"
eventCurrentConfiguration = "current configuration"
eventApplyConfiguration = "apply configuration"
eventConfigurationApplied = "configuration applied"
eventResetConfiguration = "reset configuration to default"
eventSettingsResetToDefault = "settings reset to default"
)
type configurationApplied struct {
Configuration *model.Configuration `mapstructure:"configuration,omitempty"`
Result string `mapstructure:"result"`
Constraints *model.Constraints `mapstructure:"constraints,omitempty"`
}
func (o *Operations) ApplyConfiguration(ctx context.Context, config *model.Configuration) (string, *model.Configuration, error) {
res := &configurationApplied{}
if err := o.ReqResp(ctx, eventApplyConfiguration, config, eventConfigurationApplied, res); err != nil {
return configurationApplyFailed, nil, err
}
return res.Result, res.Configuration, nil
}
func (o *Operations) RequestConfiguration(ctx context.Context) (*model.Configuration, error) {
configuration := &model.Configuration{}
if err := o.ReqResp(ctx, eventGetConfiguration, nil, eventCurrentConfiguration, configuration); err != nil {
return nil, err
}
return configuration, nil
}
// ReqResp emits an event with the given data and waits for a response
func (o *Operations) ReqResp(ctx context.Context,
requestEvent string, requestData any,
responseEvent string, res any) error {
o.mutex.RLock()
defer o.mutex.RUnlock()
if o.client == nil || !o.client.Alive() {
return errors.WithStack(protocol.ErrClosed)
}
var err error
var wg sync.WaitGroup
var once sync.Once
done := func() {
o.client.Off(responseEvent)
wg.Done()
}
wg.Add(1)
go func() {
<-ctx.Done()
err = ctx.Err()
once.Do(done)
}()
err = o.client.On(responseEvent, func(_ *socketio.Channel, data interface{}) {
if res != nil {
err = mapstructure.WeakDecode(data, res)
}
once.Do(done)
})
if err != nil {
return errors.Wrapf(err, "error while binding to '%s' event", responseEvent)
}
if err = o.client.Emit(requestEvent, requestData); err != nil {
return errors.Wrapf(err, "error while emitting event '%s'", requestEvent)
}
wg.Wait()
return err
}

243
reach/client/protocol/v1/model/configuration.go Normal file
View File

@ -0,0 +1,243 @@
package model
var (
// On -
On = String("on")
// Off -
Off = String("off")
// True -
True = Bool(true)
// False -
False = Bool(false)
// GPSARModeFixAndHold -
GPSARModeFixAndHold = String("fix-and-hold")
// GPSARModeContinuous -
GPSARModeContinuous = String("continuous")
// PositionningModeKinematic -
PositionningModeKinematic = String("kinematic")
// PositionningModeSingle -
PositionningModeSingle = String("single")
// PositionningModeStatic -
PositionningModeStatic = String("static")
// IOFormatRTCM3 -
IOFormatRTCM3 = String("rtcm3")
// IOTypeLoRa -
IOTypeLoRa = String("lora")
// BaseCoordinatesModeManual -
BaseCoordinatesModeManual = String("manual")
// BaseCoordinatesModeAverageFix -
BaseCoordinatesModeAverageFix = String("fix-and-hold")
// BaseCoordinatesModeAverageSingle -
BaseCoordinatesModeAverageSingle = String("single-and-hold")
// BaseCoordinatesModeAverageFloat -
BaseCoordinatesModeAverageFloat = String("float-and-hold")
// BaseCoordinatesFormatLLH -
BaseCoordinatesFormatLLH = String("llh")
// BaseCoordinatesFormatXYZ -
BaseCoordinatesFormatXYZ = String("xyz")
)
// String returns an string pointer
// This is a helper to constructs partials configations objects
// for the ApplyConfiguration() method
func String(v string) *string {
return &v
}
// Int returns an int pointer
// This is a helper to constructs partials configations objects
// for the ApplyConfiguration() method
func Int(v int) *int {
return &v
}
// Bool returns a bool pointer
// This is a helper to constructs partials configations objects
// for the ApplyConfiguration() method
func Bool(v bool) *bool {
return &v
}
// Float returns a float64 pointer
// This is a helper to constructs partials configations objects
// for the ApplyConfiguration() method
func Float(v float64) *float64 {
return &v
}
// Configuration -
type Configuration struct {
RTKSettings *RTKSettings `mapstructure:"rtk settings,omitempty" json:"rtk settings,omitempty"`
CorrectionInput *CorrectionInput `mapstructure:"correction input,omitempty" json:"correction input,omitempty"`
PositionOutput *PositionOutput `mapstructure:"position output,omitempty" json:"position output,omitempty"`
BaseMode *BaseMode `mapstructure:"base mode,omitempty" json:"base mode,omitempty"`
Logging *Logging `mapstructure:"logging,omitempty" json:"logging,omitempty"`
Bluetooth *Bluetooth `mapstructure:"bluetooth,omitempty" json:"bluetooth,omitempty"`
LoRa *LoRa `mapstructure:"lora,omitempty" json:"lora,omitempty"`
Constraints *Constraints `mapstructure:"constraints,omitempty" json:"constraints,omitempty"`
}
// RTKSettings -
type RTKSettings struct {
GLONASSARMode *string `mapstructure:"glonass ar mode,omitempty" json:"glonass ar mode,omitempty"`
UpdateRate *float64 `mapstructure:"update rate,omitempty" json:"update rate,omitempty"`
ElevationMaskAngle *string `mapstructure:"elevation mask angle,omitempty" json:"elevation mask angle,omitempty"`
MaxHorizontalAcceleration *string `mapstructure:"max horizontal acceleration,omitempty" json:"max horizontal acceleration,omitempty"`
SNRMask *string `mapstructure:"snr mask,omitempty" json:"snr mask,omitempty"`
GPSARMode *string `mapstructure:"gps ar mode,omitempty" json:"gps ar mode,omitempty"`
PositionningMode *string `mapstructure:"positioning mode,omitempty" json:"positioning mode,omitempty"`
PositioningSystems *PositionningSystems `mapstructure:"positioning systems,omitempty" json:"positioning systems,omitempty"`
MaxVerticalAcceleration *string `mapstructure:"max vertical acceleration,omitempty" json:"max vertical acceleration,omitempty"`
}
// PositionningSystems -
type PositionningSystems struct {
GLONASS *bool `mapstructure:"glonass,omitempty" json:"glonass,omitempty"`
SBAS *bool `mapstructure:"sbas,omitempty" json:"sbas,omitempty"`
QZS *bool `mapstructure:"qzs,omitempty" json:"qzs,omitempty"`
QZSS *bool `mapstructure:"qzss,omitempty" json:"qzss,omitempty"`
Compass *bool `mapstructure:"compass,omitempty" json:"compass,omitempty"`
Galileo *bool `mapstructure:"galileo,omitempty" json:"galileo,omitempty"`
GPS *bool `mapstructure:"gps,omitempty" json:"gps,omitempty"`
}
// CorrectionInput -
type CorrectionInput struct {
Input2 *Input2 `mapstructure:"input2,omitempty" json:"input2,omitempty"`
Input3 *Input3 `mapstructure:"input3,omitempty" json:"input3,omitempty"`
}
// Input -
type Input struct {
Path *string `mapstructure:"path,omitempty" json:"path,omitempty"`
Type *string `mapstructure:"type,omitempty" json:"type,omitempty"`
Enabled *bool `mapstructure:"enabled,omitempty" json:"enabled,omitempty"`
Format *string `mapstructure:"format,omitempty" json:"format,omitempty"`
}
// Input2 -
type Input2 struct {
Input `mapstructure:",squash"`
SendPositionToBase *string `mapstructure:"send position to base,omitempty" json:"send position to base,omitempty"`
}
// Input3 -
type Input3 struct {
Input `mapstructure:",squash"`
}
// PositionOutput -
type PositionOutput struct {
Output1 *Output `mapstructure:"output1,omitempty" json:"output1,omitempty"`
Output2 *Output `mapstructure:"output2,omitempty" json:"output2,omitempty"`
Output3 *Output `mapstructure:"output3,omitempty" json:"output3,omitempty"`
Output4 *Output `mapstructure:"output4,omitempty" json:"output4,omitempty"`
}
// Output -
type Output struct {
Path *string `mapstructure:"path,omitempty" json:"path,omitempty"`
Type *string `mapstructure:"type,omitempty" json:"type,omitempty"`
Enabled *bool `mapstructure:"enabled,omitempty" json:"enabled,omitempty"`
Format *string `mapstructure:"format,omitempty" json:"format,omitempty"`
}
// BaseMode -
type BaseMode struct {
Output *Output `mapstructure:"output,omitempty" json:"output,omitempty"`
BaseCoordinates *BaseCoordinates `mapstructure:"base coordinates,omitempty" json:"base coordinates,omitempty"`
RTCM3Messages *RTCM3Messages `mapstructure:"rtcm3 messages,omitempty" json:"rtcm3 messages,omitempty"`
}
// BaseCoordinates -
type BaseCoordinates struct {
Format *string `mapstructure:"format,omitempty" json:"format,omitempty"`
AntennaOffset *AntennaOffset `mapstructure:"antenna offset,omitempty" json:"antenna offset,omitempty"`
Accumulation *string `mapstructure:"accumulation,omitempty" json:"accumulation,omitempty"`
Coordinates []*string `mapstructure:"coordinates,omitempty" json:"coordinates,omitempty"`
Mode *string `mapstructure:"mode,omitempty" json:"mode,omitempty"`
}
// AntennaOffset -
type AntennaOffset struct {
East *string `mapstructure:"east,omitempty" json:"east,omitempty"`
North *string `mapstructure:"north,omitempty" json:"north,omitempty"`
Up *string `mapstructure:"up,omitempty" json:"up,omitempty"`
}
// RTCM3Messages -
type RTCM3Messages struct {
// GPS L1 code and phase and ambiguities and carrier-to-noise ratio
Type1002 *RTCMMessageType `mapstructure:"1002,omitemtpy" json:"1002,omitemtpy"`
// Station coordinates XYZ for antenna reference point and antenna height.
Type1006 *RTCMMessageType `mapstructure:"1006,omitemtpy" json:"1006,omitemtpy"`
// Antenna serial number.
Type1008 *RTCMMessageType `mapstructure:"1008,omitemtpy" json:"1008,omitemtpy"`
// GLONASS L1 code and phase and ambiguities and carrier-to-noise ratio.
Type1010 *RTCMMessageType `mapstructure:"1010,omitemtpy" json:"1010,omitemtpy"`
// GPS ephemeris.
Type1019 *RTCMMessageType `mapstructure:"1019,omitemtpy" json:"1019,omitemtpy"`
// GLONASS ephemeris.
Type1020 *RTCMMessageType `mapstructure:"1020,omitemtpy" json:"1020,omitemtpy"`
// The type 7 Multiple Signal Message format for Europe’s Galileo system
Type1097 *RTCMMessageType `mapstructure:"1097,omitemtpy" json:"1097,omitemtpy"`
// Full SBAS pseudo-ranges, carrier phases, Doppler and signal strength (high resolution)
Type1107 *RTCMMessageType `mapstructure:"1107,omitemtpy" json:"1107,omitemtpy"`
// Full QZSS pseudo-ranges, carrier phases, Doppler and signal strength (high resolution)
Type1117 *RTCMMessageType `mapstructure:"1117,omitemtpy" json:"1117,omitemtpy"`
// Full BeiDou pseudo-ranges, carrier phases, Doppler and signal strength (high resolution)
Type1127 *RTCMMessageType `mapstructure:"1127,omitemtpy" json:"1127,omitemtpy"`
}
// RTCMMessageType -
type RTCMMessageType struct {
Frequency *string `mapstructure:"frequency,omitempty" json:"frequency,omitempty"`
Enabled *bool `mapstructure:"enabled,omitempty" json:"enabled,omitempty"`
}
// Logging -
type Logging struct {
Correction *LoggingService `mapstructure:"correction,omitempty" json:"correction,omitempty"`
Interval *int `mapstructure:"interval,omitempty" json:"interval,omitempty"`
Solution *LoggingService `mapstructure:"solution,omitempty" json:"solution,omitempty"`
Raw *LoggingService `mapstructure:"raw,omitempty" json:"raw,omitempty"`
Base *LoggingService `mapstructure:"base,omitempty" json:"base,omitempty"`
Overwrite *bool `mapstructure:"overwrite,omitempty" json:"overwrite,omitempty"`
}
// LoggingService -
type LoggingService struct {
Started *bool `mapstructure:"started,omitempty" json:"started,omitempty"`
Version *string `mapstructure:"version,omitempty" json:"version,omitempty"`
Format *string `mapstructure:"format,omitempty" json:"format,omitempty"`
}
// Bluetooth -
type Bluetooth struct {
Enabled *bool `mapstructure:"enabled,omitempty" json:"enabled,omitempty"`
Discoverable *bool `mapstructure:"discoverable,omitempty" json:"discoverable,omitempty"`
Pin *int `mapstructure:"pin,omitempty" json:"pin,omitempty"`
}
// LoRa -
type LoRa struct {
AirRate *string `mapstructure:"air rate,omitempty" json:"air rate,omitempty"`
Frequency *float64 `mapstructure:"frequency,omitempty" json:"frequency,omitempty"`
OutputPower *string `mapstructure:"output power,omitempty" json:"output power,omitempty"`
}
// Constraints -
type Constraints struct {
LoRa *LoRaConstraints `mapstructure:"lora,omitempty" json:"lora,omitempty"`
}
// LoRaConstraints -
type LoRaConstraints struct {
Frequency [][]int `mapstructure:"frequency,omitempty" json:"frequency,omitempty"`
}
// LoRaFrequencyRange -
type LoRaFrequencyRange struct {
Min *int `mapstructure:"min,omitempty" json:"min,omitempty"`
Max *int `mapstructure:"max,omitempty" json:"max,omitempty"`
}

283
reach/client/protocol/v1/operations.go Normal file
View File

@ -0,0 +1,283 @@
package v1
import (
"context"
"strconv"
"strings"
"sync"
"forge.cadoles.com/cadoles/go-emlid/reach/client/protocol"
"forge.cadoles.com/cadoles/go-emlid/reach/client/protocol/v1/model"
"forge.cadoles.com/cadoles/go-emlid/reach/client/socketio"
"github.com/pkg/errors"
)
type Operations struct {
addr string
client *socketio.Client
mutex sync.RWMutex
}
// Close implements protocol.Operations.
func (o *Operations) Close(ctx context.Context) error {
o.mutex.Lock()
defer o.mutex.Unlock()
if o.client == nil {
return nil
}
o.client.Close()
return nil
}
const (
// EventBrowserConnected is emitted after the initial connection to the
// ReachView endpoint
eventBrowserConnected = "browser connected"
)
// Connect implements protocol.Operations.
func (o *Operations) Connect(ctx context.Context) error {
o.mutex.Lock()
defer o.mutex.Unlock()
if o.client != nil {
o.client.Close()
}
endpoint, err := socketio.EndpointFromHAddr(o.addr)
if err != nil {
return errors.WithStack(err)
}
client := socketio.NewClient(endpoint)
if err := client.Connect(); err != nil {
return errors.WithStack(err)
}
// Notifies the ReachView endpoint of a new connection.
// See misc/reachview/update_main.js line 297
payload := map[string]string{
"data": "I'm connected",
}
if err := client.Emit(eventBrowserConnected, payload); err != nil {
return errors.WithStack(err)
}
o.client = client
return nil
}
// Emit implements protocol.Operations.
func (o *Operations) Emit(ctx context.Context, mType string, message any) error {
o.mutex.RLock()
defer o.mutex.RUnlock()
if o.client == nil || !o.client.Alive() {
return errors.WithStack(protocol.ErrClosed)
}
if err := o.client.Emit(mType, message); err != nil {
return errors.WithStack(err)
}
return nil
}
// On implements protocol.Operations.
func (o *Operations) On(ctx context.Context, event string) (chan any, error) {
o.mutex.RLock()
defer o.mutex.RUnlock()
if o.client == nil || !o.client.Alive() {
return nil, errors.WithStack(protocol.ErrClosed)
}
out := make(chan any)
closer := new(sync.Once)
handler := func(ch *socketio.Channel, data any) {
select {
case <-ctx.Done():
closer.Do(func() {
o.mutex.RLock()
defer o.mutex.RUnlock()
ch.Close()
close(out)
if o.client == nil {
return
}
})
return
default:
out <- data
}
}
if err := o.client.On(event, handler); err != nil {
return nil, errors.WithStack(err)
}
return out, nil
}
// Alive implements protocol.Operations.
func (o *Operations) Alive(ctx context.Context) (bool, error) {
o.mutex.RLock()
defer o.mutex.RUnlock()
if o.client == nil || !o.client.Alive() {
return false, errors.WithStack(protocol.ErrClosed)
}
return o.client.Alive(), nil
}
// Configuration implements protocol.Operations.
func (o *Operations) Configuration(ctx context.Context) (any, error) {
config, err := o.RequestConfiguration(ctx)
if err != nil {
return nil, errors.WithStack(err)
}
return config, nil
}
const (
eventReboot = "reboot"
)
// Reboot implements protocol.Operations.
func (o *Operations) Reboot(ctx context.Context) error {
o.mutex.RLock()
defer o.mutex.RUnlock()
if o.client == nil || !o.client.Alive() {
return errors.WithStack(protocol.ErrClosed)
}
var err error
var wg sync.WaitGroup
var once sync.Once
done := func() {
o.client.Off(socketio.OnDisconnection)
wg.Done()
}
wg.Add(1)
go func() {
<-ctx.Done()
err = ctx.Err()
once.Do(done)
}()
err = o.client.On(socketio.OnDisconnection, func(h *socketio.Channel, data any) {
once.Do(done)
})
if err != nil {
return errors.Wrapf(err, "error while binding to '%s' event", socketio.OnDisconnection)
}
if err = o.client.Emit(eventReboot, nil); err != nil {
return err
}
wg.Wait()
return err
}
const (
// ConfigurationApplySuccess -
configurationApplySuccess = "success"
// ConfigurationApplyFailed -
configurationApplyFailed = "failed"
)
// SetBase implements protocol.Operations.
func (o *Operations) SetBase(ctx context.Context, funcs ...protocol.SetBaseOptionFunc) error {
opts := protocol.NewSetBaseOptions(funcs...)
var lat string
if opts.Latitude != nil {
lat = strconv.FormatFloat(*opts.Latitude, 'f', -1, 64)
}
var lon string
if opts.Longitude != nil {
lon = strconv.FormatFloat(*opts.Longitude, 'f', -1, 64)
}
var alt string
if opts.Height != nil {
alt = strconv.FormatFloat(*opts.Height, 'f', -1, 64)
}
var antennaHeight string
if opts.AntennaOffset != nil {
antennaHeight = strconv.FormatFloat(*opts.AntennaOffset, 'f', -1, 64)
}
config := &model.Configuration{
BaseMode: &model.BaseMode{
BaseCoordinates: &model.BaseCoordinates{
Accumulation: model.String("1"),
Coordinates: []*string{
model.String(lat),
model.String(lon),
model.String(alt),
},
AntennaOffset: &model.AntennaOffset{
East: model.String("0"),
North: model.String("0"),
Up: model.String(antennaHeight),
},
Format: model.BaseCoordinatesFormatLLH,
Mode: model.BaseCoordinatesModeManual,
},
},
}
result, _, err := o.ApplyConfiguration(ctx, config)
if err != nil {
return errors.New("configuration update failed")
}
if result != configurationApplySuccess {
return errors.New("configuration update failed")
}
return nil
}
const (
eventGetReachViewVersion = "get reachview version"
eventReachViewVersionResults = "current reachview version"
)
type reachViewVersion struct {
Version string `json:"version"`
Stable bool `json:"bool"`
}
// Version implements protocol.Operations.
func (o *Operations) Version(ctx context.Context) (string, bool, error) {
res := &reachViewVersion{}
if err := o.ReqResp(ctx, eventGetReachViewVersion, nil, eventReachViewVersionResults, res); err != nil {
return "", false, err
}
return strings.TrimSpace(res.Version), res.Stable, nil
}
var _ protocol.Operations = &Operations{}

31
reach/client/protocol/v1/operations_test.go Normal file
View File

@ -0,0 +1,31 @@
package v1
import (
"context"
"testing"
"forge.cadoles.com/cadoles/go-emlid/reach/client/protocol"
"forge.cadoles.com/cadoles/go-emlid/reach/client/protocol/testsuite"
"github.com/pkg/errors"
)
func TestProtocolV1Operations(t *testing.T) {
proto := &Protocol{}
factory := func(addr string) (protocol.Operations, error) {
ctx := context.Background()
available, err := proto.Available(ctx, addr)
if err != nil {
return nil, errors.WithStack(err)
}
if !available {
return nil, errors.New("protocol is not available")
}
return proto.Operations(addr), nil
}
testsuite.TestOperations(t, factory)
}

29
reach/client/protocol/v1/protocol.go Normal file
View File

@ -0,0 +1,29 @@
package v1
import (
"context"
"forge.cadoles.com/cadoles/go-emlid/reach/client/protocol"
)
const Identifier protocol.Identifier = "v1"
type Protocol struct {
}
// Available implements protocol.Protocol.
func (p *Protocol) Available(ctx context.Context, addr string) (bool, error) {
return true, nil
}
// Identifier implements protocol.Protocol.
func (p *Protocol) Identifier() protocol.Identifier {
return Identifier
}
// Operations implements protocol.Protocol.
func (p *Protocol) Operations(addr string) protocol.Operations {
return &Operations{addr: addr}
}
var _ protocol.Protocol = &Protocol{}

7
reach/client/protocol/v2/init.go Normal file
View File

@ -0,0 +1,7 @@
package v2
import "forge.cadoles.com/cadoles/go-emlid/reach/client/protocol"
func init() {
protocol.Register(&Protocol{})
}

127
reach/client/protocol/v2/internal.go Normal file
View File

@ -0,0 +1,127 @@
package v2
import (
"bytes"
"context"
"encoding/json"
"fmt"
"io"
"net/http"
"forge.cadoles.com/cadoles/go-emlid/reach/client/protocol/v2/model"
"github.com/pkg/errors"
)
func (o *Operations) getURL(path string) string {
return fmt.Sprintf("http://%s%s", o.addr, path)
}
func (o *Operations) GetJSON(path string, dst any) error {
var res *http.Response
url := o.getURL(path)
res, err := http.Get(url)
if err != nil {
return errors.WithStack(err)
}
if res.StatusCode < http.StatusOK || res.StatusCode >= http.StatusBadRequest {
return errors.Errorf("unexpected http status code %d (%s)", res.StatusCode, res.Status)
}
defer func() {
if err := res.Body.Close(); err != nil {
errors.WithStack(err)
}
}()
var body []byte
body, err = io.ReadAll(res.Body)
if err != nil {
return errors.WithStack(err)
}
if err = json.Unmarshal(body, dst); err != nil {
return errors.WithStack(err)
}
return nil
}
func (o *Operations) PostJSON(path string, data any, dst any) error {
var res *http.Response
var buf bytes.Buffer
encoder := json.NewEncoder(&buf)
if err := encoder.Encode(data); err != nil {
return errors.WithStack(err)
}
url := o.getURL(path)
res, err := http.Post(url, "application/json", &buf)
if err != nil {
return errors.WithStack(err)
}
if res.StatusCode < http.StatusOK || res.StatusCode >= http.StatusBadRequest {
return errors.Errorf("unexpected http status code %d (%s)", res.StatusCode, res.Status)
}
defer func() {
if err := res.Body.Close(); err != nil {
errors.WithStack(err)
}
}()
var body []byte
body, err = io.ReadAll(res.Body)
if err != nil {
return errors.WithStack(err)
}
if err = json.Unmarshal(body, dst); err != nil {
return errors.WithStack(err)
}
return nil
}
func (o *Operations) PostBaseCoordinates(ctx context.Context, base *model.Base) (*model.Base, error) {
var updated model.Base
if err := o.PostJSON("/configuration/base_mode/base_coordinates", base, &updated); err != nil {
return nil, errors.WithStack(err)
}
return &updated, nil
}
func (o *Operations) GetUpdater(ctx context.Context) (*model.Updater, error) {
updater := &model.Updater{}
if err := o.GetJSON("/updater", updater); err != nil {
return nil, errors.WithStack(err)
}
return updater, nil
}
func (o *Operations) GetInfo(ctx context.Context) (*model.Info, error) {
info := &model.Info{}
if err := o.GetJSON("/info", info); err != nil {
return nil, errors.WithStack(err)
}
return info, nil
}
func (o *Operations) GetConfiguration(ctx context.Context) (*model.Configuration, error) {
config := &model.Configuration{}
if err := o.GetJSON("/configuration", config); err != nil {
return nil, errors.WithStack(err)
}
return config, nil
}

5
reach/client/protocol/v2/model/action.go Normal file
View File

@ -0,0 +1,5 @@
package model
type Action struct {
Name string `json:"name"`
}

14
reach/client/protocol/v2/model/base.go Normal file
View File

@ -0,0 +1,14 @@
package model
type Base struct {
Accumulation int `json:"accumulation,omitempty"`
AntennaOffset float64 `json:"antenna_offset,omitempty"`
Coordinates BaseCoordinates `json:"coordinates,omitempty"`
Mode string `json:"mode,omitempty"`
}
type BaseCoordinates struct {
Height float64 `json:"height,omitempty"`
Latitude float64 `json:"latitude,omitempty"`
Longitude float64 `json:"longitude,omitempty"`
}

563
reach/client/protocol/v2/model/configuration.go Normal file
View File

@ -0,0 +1,563 @@
package model
type Configuration struct {
BaseMode struct {
BaseCoordinates struct {
Accumulation int `json:"accumulation,omitempty"`
AntennaOffset float64 `json:"antenna_offset,omitempty"`
Coordinates struct {
Height float64 `json:"height,omitempty"`
Latitude float64 `json:"latitude,omitempty"`
Longitude float64 `json:"longitude,omitempty"`
} `json:"coordinates,omitempty"`
Mode string `json:"mode,omitempty"`
} `json:"base_coordinates,omitempty"`
Output struct {
IoType string `json:"io_type,omitempty"`
Settings struct {
Lora struct {
AirRate float64 `json:"air_rate,omitempty"`
Frequency int `json:"frequency,omitempty"`
OutputPower int `json:"output_power,omitempty"`
} `json:"lora,omitempty"`
Ntripcaster struct {
MountPoint string `json:"mount_point,omitempty"`
Password string `json:"password,omitempty"`
Port int `json:"port,omitempty"`
Username string `json:"username,omitempty"`
} `json:"ntripcaster,omitempty"`
Ntripsvr struct {
Address string `json:"address,omitempty"`
MountPoint string `json:"mount_point,omitempty"`
Password string `json:"password,omitempty"`
Port int `json:"port,omitempty"`
} `json:"ntripsvr,omitempty"`
Serial struct {
BaudRate int `json:"baud_rate,omitempty"`
Device string `json:"device,omitempty"`
} `json:"serial,omitempty"`
Tcpcli struct {
Address string `json:"address,omitempty"`
Port int `json:"port,omitempty"`
} `json:"tcpcli,omitempty"`
Tcpsvr struct {
Port int `json:"port,omitempty"`
} `json:"tcpsvr,omitempty"`
} `json:"settings,omitempty"`
} `json:"output,omitempty"`
Rtcm3Messages struct {
Num1004 struct {
Enabled bool `json:"enabled,omitempty"`
Frequency int `json:"frequency,omitempty"`
} `json:"1004,omitempty"`
Num1006 struct {
Enabled bool `json:"enabled,omitempty"`
Frequency float64 `json:"frequency,omitempty"`
} `json:"1006,omitempty"`
Num1008 struct {
Enabled bool `json:"enabled,omitempty"`
Frequency float64 `json:"frequency,omitempty"`
} `json:"1008,omitempty"`
Num1012 struct {
Enabled bool `json:"enabled,omitempty"`
Frequency int `json:"frequency,omitempty"`
} `json:"1012,omitempty"`
Num1033 struct {
Enabled bool `json:"enabled,omitempty"`
Frequency float64 `json:"frequency,omitempty"`
} `json:"1033,omitempty"`
Num1074 struct {
Enabled bool `json:"enabled,omitempty"`
Frequency float64 `json:"frequency,omitempty"`
} `json:"1074,omitempty"`
Num1084 struct {
Enabled bool `json:"enabled,omitempty"`
Frequency float64 `json:"frequency,omitempty"`
} `json:"1084,omitempty"`
Num1094 struct {
Enabled bool `json:"enabled,omitempty"`
Frequency float64 `json:"frequency,omitempty"`
} `json:"1094,omitempty"`
Num1124 struct {
Enabled bool `json:"enabled,omitempty"`
Frequency float64 `json:"frequency,omitempty"`
} `json:"1124,omitempty"`
Num1230 struct {
Enabled bool `json:"enabled,omitempty"`
Frequency float64 `json:"frequency,omitempty"`
} `json:"1230,omitempty"`
} `json:"rtcm3_messages,omitempty"`
} `json:"base_mode,omitempty"`
Bluetooth struct {
BleEnabled bool `json:"ble_enabled,omitempty"`
Enabled bool `json:"enabled,omitempty"`
Pairing struct {
Discoverable bool `json:"discoverable,omitempty"`
NoInputNoOutput bool `json:"no_input_no_output,omitempty"`
Pin string `json:"pin,omitempty"`
} `json:"pairing,omitempty"`
} `json:"bluetooth,omitempty"`
CorrectionInput struct {
BaseCorrections struct {
IoType string `json:"io_type,omitempty"`
LastUsed struct {
Ntrip string `json:"ntrip,omitempty"`
Radio string `json:"radio,omitempty"`
TCP string `json:"tcp,omitempty"`
} `json:"last_used,omitempty"`
Settings struct {
Ble struct {
Address string `json:"address,omitempty"`
MountPoint string `json:"mount_point,omitempty"`
Password string `json:"password,omitempty"`
Port int `json:"port,omitempty"`
SendPositionToBase bool `json:"send_position_to_base,omitempty"`
Username string `json:"username,omitempty"`
} `json:"ble,omitempty"`
Bluetooth struct {
SendPositionToBase bool `json:"send_position_to_base,omitempty"`
} `json:"bluetooth,omitempty"`
Lora struct {
AirRate float64 `json:"air_rate,omitempty"`
Frequency int `json:"frequency,omitempty"`
OutputPower int `json:"output_power,omitempty"`
SendPositionToBase bool `json:"send_position_to_base,omitempty"`
} `json:"lora,omitempty"`
Ntripcli struct {
Address string `json:"address,omitempty"`
MountPoint string `json:"mount_point,omitempty"`
Password string `json:"password,omitempty"`
Port int `json:"port,omitempty"`
SendPositionToBase bool `json:"send_position_to_base,omitempty"`
Username string `json:"username,omitempty"`
} `json:"ntripcli,omitempty"`
Serial struct {
BaudRate int `json:"baud_rate,omitempty"`
Device string `json:"device,omitempty"`
SendPositionToBase bool `json:"send_position_to_base,omitempty"`
} `json:"serial,omitempty"`
Tcpcli struct {
Address string `json:"address,omitempty"`
Port int `json:"port,omitempty"`
SendPositionToBase bool `json:"send_position_to_base,omitempty"`
} `json:"tcpcli,omitempty"`
Tcpsvr struct {
Port int `json:"port,omitempty"`
SendPositionToBase bool `json:"send_position_to_base,omitempty"`
} `json:"tcpsvr,omitempty"`
} `json:"settings,omitempty"`
} `json:"base_corrections,omitempty"`
} `json:"correction_input,omitempty"`
Device struct {
AntennaHeight float64 `json:"antenna_height,omitempty"`
NightMode bool `json:"night_mode,omitempty"`
OnboardingShown bool `json:"onboarding_shown,omitempty"`
PowerOnBottomConnector bool `json:"power_on_bottom_connector,omitempty"`
PrivacyPolicyAccepted bool `json:"privacy_policy_accepted,omitempty"`
Role string `json:"role,omitempty"`
UsageAnalysisAccepted bool `json:"usage_analysis_accepted,omitempty"`
} `json:"device,omitempty"`
Logging struct {
Logs struct {
Autostart bool `json:"autostart,omitempty"`
Base struct {
Enabled bool `json:"enabled,omitempty"`
Format string `json:"format,omitempty"`
} `json:"base,omitempty"`
Raw struct {
Enabled bool `json:"enabled,omitempty"`
Format string `json:"format,omitempty"`
RinexOptions struct {
LoggingInterval int `json:"logging_interval,omitempty"`
MarkerName any `json:"marker_name,omitempty"`
Preset string `json:"preset,omitempty"`
SatelliteSystems struct {
Beidou bool `json:"beidou,omitempty"`
Galileo bool `json:"galileo,omitempty"`
Glonass bool `json:"glonass,omitempty"`
Gps bool `json:"gps,omitempty"`
Qzss bool `json:"qzss,omitempty"`
Sbas bool `json:"sbas,omitempty"`
} `json:"satellite_systems,omitempty"`
TimeAdjustmentsEnabled bool `json:"time_adjustments_enabled,omitempty"`
} `json:"rinex_options,omitempty"`
Version string `json:"version,omitempty"`
} `json:"raw,omitempty"`
Solution struct {
Enabled bool `json:"enabled,omitempty"`
Format string `json:"format,omitempty"`
} `json:"solution,omitempty"`
Started bool `json:"started,omitempty"`
} `json:"logs,omitempty"`
Settings struct {
ArchiveName any `json:"archive_name,omitempty"`
Debug bool `json:"debug,omitempty"`
Interval int `json:"interval,omitempty"`
Overwrite bool `json:"overwrite,omitempty"`
SimultaneousLogging bool `json:"simultaneous_logging,omitempty"`
SplitAtMidnightUtc bool `json:"split_at_midnight_utc,omitempty"`
} `json:"settings,omitempty"`
} `json:"logging,omitempty"`
Network struct {
TCPOverModem bool `json:"tcp_over_modem,omitempty"`
} `json:"network,omitempty"`
PositionOutput struct {
Output1 struct {
IoType string `json:"io_type,omitempty"`
LastUsed struct {
TCP string `json:"tcp,omitempty"`
} `json:"last_used,omitempty"`
NmeaSettings struct {
Bluetooth struct {
Ebp struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"ebp,omitempty"`
Gga struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"gga,omitempty"`
Gsa struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"gsa,omitempty"`
Gst struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"gst,omitempty"`
Gsv struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"gsv,omitempty"`
MainTalkerID string `json:"main_talker_id,omitempty"`
Rmc struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"rmc,omitempty"`
Vtg struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"vtg,omitempty"`
Zda struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"zda,omitempty"`
} `json:"bluetooth,omitempty"`
Serial struct {
Ebp struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"ebp,omitempty"`
Gga struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"gga,omitempty"`
Gsa struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"gsa,omitempty"`
Gst struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"gst,omitempty"`
Gsv struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"gsv,omitempty"`
MainTalkerID string `json:"main_talker_id,omitempty"`
Rmc struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"rmc,omitempty"`
Vtg struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"vtg,omitempty"`
Zda struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"zda,omitempty"`
} `json:"serial,omitempty"`
Tcpcli struct {
Ebp struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"ebp,omitempty"`
Gga struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"gga,omitempty"`
Gsa struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"gsa,omitempty"`
Gst struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"gst,omitempty"`
Gsv struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"gsv,omitempty"`
MainTalkerID string `json:"main_talker_id,omitempty"`
Rmc struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"rmc,omitempty"`
Vtg struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"vtg,omitempty"`
Zda struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"zda,omitempty"`
} `json:"tcpcli,omitempty"`
Tcpsvr struct {
Ebp struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"ebp,omitempty"`
Gga struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"gga,omitempty"`
Gsa struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"gsa,omitempty"`
Gst struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"gst,omitempty"`
Gsv struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"gsv,omitempty"`
MainTalkerID string `json:"main_talker_id,omitempty"`
Rmc struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"rmc,omitempty"`
Vtg struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"vtg,omitempty"`
Zda struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"zda,omitempty"`
} `json:"tcpsvr,omitempty"`
} `json:"nmea_settings,omitempty"`
Settings struct {
Bluetooth struct {
Format string `json:"format,omitempty"`
} `json:"bluetooth,omitempty"`
Serial struct {
BaudRate int `json:"baud_rate,omitempty"`
Device string `json:"device,omitempty"`
Format string `json:"format,omitempty"`
} `json:"serial,omitempty"`
Tcpcli struct {
Address string `json:"address,omitempty"`
Format string `json:"format,omitempty"`
Port int `json:"port,omitempty"`
} `json:"tcpcli,omitempty"`
Tcpsvr struct {
Format string `json:"format,omitempty"`
Port int `json:"port,omitempty"`
} `json:"tcpsvr,omitempty"`
} `json:"settings,omitempty"`
} `json:"output1,omitempty"`
Output2 struct {
IoType string `json:"io_type,omitempty"`
LastUsed struct {
TCP string `json:"tcp,omitempty"`
} `json:"last_used,omitempty"`
NmeaSettings struct {
Bluetooth struct {
Ebp struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"ebp,omitempty"`
Gga struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"gga,omitempty"`
Gsa struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"gsa,omitempty"`
Gst struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"gst,omitempty"`
Gsv struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"gsv,omitempty"`
MainTalkerID string `json:"main_talker_id,omitempty"`
Rmc struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"rmc,omitempty"`
Vtg struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"vtg,omitempty"`
Zda struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"zda,omitempty"`
} `json:"bluetooth,omitempty"`
Serial struct {
Ebp struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"ebp,omitempty"`
Gga struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"gga,omitempty"`
Gsa struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"gsa,omitempty"`
Gst struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"gst,omitempty"`
Gsv struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"gsv,omitempty"`
MainTalkerID string `json:"main_talker_id,omitempty"`
Rmc struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"rmc,omitempty"`
Vtg struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"vtg,omitempty"`
Zda struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"zda,omitempty"`
} `json:"serial,omitempty"`
Tcpcli struct {
Ebp struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"ebp,omitempty"`
Gga struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"gga,omitempty"`
Gsa struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"gsa,omitempty"`
Gst struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"gst,omitempty"`
Gsv struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"gsv,omitempty"`
MainTalkerID string `json:"main_talker_id,omitempty"`
Rmc struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"rmc,omitempty"`
Vtg struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"vtg,omitempty"`
Zda struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"zda,omitempty"`
} `json:"tcpcli,omitempty"`
Tcpsvr struct {
Ebp struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"ebp,omitempty"`
Gga struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"gga,omitempty"`
Gsa struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"gsa,omitempty"`
Gst struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"gst,omitempty"`
Gsv struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"gsv,omitempty"`
MainTalkerID string `json:"main_talker_id,omitempty"`
Rmc struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"rmc,omitempty"`
Vtg struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"vtg,omitempty"`
Zda struct {
Enabled bool `json:"enabled,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"zda,omitempty"`
} `json:"tcpsvr,omitempty"`
} `json:"nmea_settings,omitempty"`
Settings struct {
Bluetooth struct {
Format string `json:"format,omitempty"`
} `json:"bluetooth,omitempty"`
Serial struct {
BaudRate int `json:"baud_rate,omitempty"`
Device string `json:"device,omitempty"`
Format string `json:"format,omitempty"`
} `json:"serial,omitempty"`
Tcpcli struct {
Address string `json:"address,omitempty"`
Format string `json:"format,omitempty"`
Port int `json:"port,omitempty"`
} `json:"tcpcli,omitempty"`
Tcpsvr struct {
Format string `json:"format,omitempty"`
Port int `json:"port,omitempty"`
} `json:"tcpsvr,omitempty"`
} `json:"settings,omitempty"`
} `json:"output2,omitempty"`
} `json:"position_output,omitempty"`
PositioningSettings struct {
ElevationMaskAngle int `json:"elevation_mask_angle,omitempty"`
GlonassArMode bool `json:"glonass_ar_mode,omitempty"`
GnssSettings struct {
PositioningSystems struct {
Beidou bool `json:"beidou,omitempty"`
Galileo bool `json:"galileo,omitempty"`
Glonass bool `json:"glonass,omitempty"`
Gps bool `json:"gps,omitempty"`
Qzss bool `json:"qzss,omitempty"`
} `json:"positioning_systems,omitempty"`
UpdateRate int `json:"update_rate,omitempty"`
} `json:"gnss_settings,omitempty"`
GpsArMode string `json:"gps_ar_mode,omitempty"`
MaxHorizontalAcceleration int `json:"max_horizontal_acceleration,omitempty"`
MaxVerticalAcceleration int `json:"max_vertical_acceleration,omitempty"`
PositioningMode string `json:"positioning_mode,omitempty"`
SnrMask int `json:"snr_mask,omitempty"`
} `json:"positioning_settings,omitempty"`
Sound struct {
Mute bool `json:"mute,omitempty"`
Volume int `json:"volume,omitempty"`
} `json:"sound,omitempty"`
}

166
reach/client/protocol/v2/model/info.go Normal file
View File

@ -0,0 +1,166 @@
package model
// GET http://<addr>/info
// {
// "device": {
// "cloud": {
// "supported": true,
// "usage_analysis_accepted": false
// },
// "country_code": "FR",
// "critical_self_tests_passed": true,
// "is_first_time_setup": false,
// "local_address": "Reach.local",
// "manufacturing_timestamp": "1693633066",
// "name": "Reach",
// "privacy_policy_accepted": true,
// "public_key": "378A5081F445771316A0563CFCC168C813261C6EE9C5C50DF70CC4503C6D8839BED7AA40146A9D8D72BFC4DB85382EEE51B90D03B6CC6DF34E860E15EFEA7D38",
// "self_tests": {
// "antenna_board_detected": true,
// "audio": true,
// "bluetooth_detected": true,
// "crypto-chip": true,
// "image_and_device": true,
// "lora": true,
// "modem": true,
// "mpu": true,
// "stm32": true,
// "u-blox": true,
// "wifi_detected": true
// },
// "serial_number": "8243276564AEA32D",
// "statistics": {
// "first_usage_timestamp": 4294967295
// },
// "time_sync_passed": true,
// "type": "ReachRS2+",
// "uptime": "2:50:57"
// },
// "firmware": {
// "api_version": "10.2",
// "app_mode": "default",
// "onboarding_shown": false,
// "version": "32.0",
// "version_full": "32.0-r0"
// },
// "gnss_receiver": {
// "firmware_version": "HPG_1.13"
// },
// "lora": {
// "firmware_version": "F-0LR-1F-1912161"
// },
// "modem": {
// "firmware_version": "MPSS.JO.2.0.2.c1.1-00098-9607_GENNS_PACK-1.402457.1 1 [May 18 2021 19:00:00]",
// "imei": "350588283544948",
// "modem_model": "\r\n^SYSSTART\r\n"
// },
// "pmu": {
// "balancer_version": "190602",
// "git_hash": "0a241756",
// "version": "3.35"
// },
// "reachview": {
// "api_version": "10.2",
// "app_mode": "default",
// "onboarding_shown": false,
// "version": "32.0",
// "version_full": "32.0-r0"
// },
// "storage": {
// "free": 11682,
// "total": 12374
// }
// }
type Info struct {
Device Device `json:"device,omitempty"`
Firmware Firmware `json:"firmware,omitempty"`
GnssReceiver GnssReceiver `json:"gnss_receiver,omitempty"`
Lora Lora `json:"lora,omitempty"`
Modem Modem `json:"modem,omitempty"`
Pmu Pmu `json:"pmu,omitempty"`
Reachview Reachview `json:"reachview,omitempty"`
Storage Storage `json:"storage,omitempty"`
}
type Cloud struct {
Supported bool `json:"supported,omitempty"`
UsageAnalysisAccepted bool `json:"usage_analysis_accepted,omitempty"`
}
type SelfTests struct {
AntennaBoardDetected bool `json:"antenna_board_detected,omitempty"`
Audio bool `json:"audio,omitempty"`
BluetoothDetected bool `json:"bluetooth_detected,omitempty"`
CryptoChip bool `json:"crypto-chip,omitempty"`
ImageAndDevice bool `json:"image_and_device,omitempty"`
Lora bool `json:"lora,omitempty"`
Modem bool `json:"modem,omitempty"`
Mpu bool `json:"mpu,omitempty"`
Stm32 bool `json:"stm32,omitempty"`
UBlox bool `json:"u-blox,omitempty"`
WifiDetected bool `json:"wifi_detected,omitempty"`
}
type Statistics struct {
FirstUsageTimestamp int64 `json:"first_usage_timestamp,omitempty"`
}
type Device struct {
Cloud Cloud `json:"cloud,omitempty"`
CountryCode string `json:"country_code,omitempty"`
CriticalSelfTestsPassed bool `json:"critical_self_tests_passed,omitempty"`
IsFirstTimeSetup bool `json:"is_first_time_setup,omitempty"`
LocalAddress string `json:"local_address,omitempty"`
ManufacturingTimestamp string `json:"manufacturing_timestamp,omitempty"`
Name string `json:"name,omitempty"`
PrivacyPolicyAccepted bool `json:"privacy_policy_accepted,omitempty"`
PublicKey string `json:"public_key,omitempty"`
SelfTests SelfTests `json:"self_tests,omitempty"`
SerialNumber string `json:"serial_number,omitempty"`
Statistics Statistics `json:"statistics,omitempty"`
TimeSyncPassed bool `json:"time_sync_passed,omitempty"`
Type string `json:"type,omitempty"`
Uptime string `json:"uptime,omitempty"`
}
type Firmware struct {
APIVersion string `json:"api_version,omitempty"`
AppMode string `json:"app_mode,omitempty"`
OnboardingShown bool `json:"onboarding_shown,omitempty"`
Version string `json:"version,omitempty"`
VersionFull string `json:"version_full,omitempty"`
}
type GnssReceiver struct {
FirmwareVersion string `json:"firmware_version,omitempty"`
}
type Lora struct {
FirmwareVersion string `json:"firmware_version,omitempty"`
}
type Modem struct {
FirmwareVersion string `json:"firmware_version,omitempty"`
Imei string `json:"imei,omitempty"`
ModemModel string `json:"modem_model,omitempty"`
}
type Pmu struct {
BalancerVersion string `json:"balancer_version,omitempty"`
GitHash string `json:"git_hash,omitempty"`
Version string `json:"version,omitempty"`
}
type Reachview struct {
APIVersion string `json:"api_version,omitempty"`
AppMode string `json:"app_mode,omitempty"`
OnboardingShown bool `json:"onboarding_shown,omitempty"`
Version string `json:"version,omitempty"`
VersionFull string `json:"version_full,omitempty"`
}
type Storage struct {
Free int `json:"free,omitempty"`
Total int `json:"total,omitempty"`
}

55
reach/client/protocol/v2/model/updater.go Normal file
View File

@ -0,0 +1,55 @@
package model
// {
// "allowance": {
// "allowed": true,
// "reason": null
// },
// "downgrade": {
// "available": false,
// "reason": "no_available_downgrades"
// },
// "release": {
// "channel": "stable"
// },
// "update_server": {
// "address": "https://update-provider.cloud.emlid.com/api/client/v1/firmware-available"
// },
// "upgrade": {
// "available": false,
// "reason": "up_to_date",
// "required": false
// }
// }
type Updater struct {
Allowance Allowance `json:"allowance,omitempty"`
Downgrade Downgrade `json:"downgrade,omitempty"`
Release Release `json:"release,omitempty"`
UpdateServer UpdateServer `json:"update_server,omitempty"`
Upgrade Upgrade `json:"upgrade,omitempty"`
}
type Allowance struct {
Allowed bool `json:"allowed,omitempty"`
Reason any `json:"reason,omitempty"`
}
type Downgrade struct {
Available bool `json:"available,omitempty"`
Reason string `json:"reason,omitempty"`
}
type Release struct {
Channel string `json:"channel,omitempty"`
}
type UpdateServer struct {
Address string `json:"address,omitempty"`
}
type Upgrade struct {
Available bool `json:"available,omitempty"`
Reason string `json:"reason,omitempty"`
Required bool `json:"required,omitempty"`
}

234
reach/client/protocol/v2/operations.go Normal file
View File

@ -0,0 +1,234 @@
package v2
import (
"context"
"sync"
"forge.cadoles.com/cadoles/go-emlid/reach/client/protocol"
"forge.cadoles.com/cadoles/go-emlid/reach/client/protocol/v2/model"
"forge.cadoles.com/cadoles/go-emlid/reach/client/socketio"
"github.com/pkg/errors"
)
type Operations struct {
addr string
client *socketio.Client
mutex sync.RWMutex
}
// Reboot implements protocol.Operations.
func (o *Operations) Reboot(ctx context.Context) error {
var err error
var wg sync.WaitGroup
var once sync.Once
done := func() {
o.client.Off(socketio.OnDisconnection)
wg.Done()
}
wg.Add(1)
go func() {
<-ctx.Done()
err = ctx.Err()
once.Do(done)
}()
err = o.client.On(socketio.OnDisconnection, func(h *socketio.Channel, data any) {
once.Do(done)
})
if err != nil {
return errors.Wrapf(err, "error while binding to '%s' event", socketio.OnDisconnection)
}
if err = o.client.Emit("action", &model.Action{Name: "reboot"}); err != nil {
return err
}
wg.Wait()
return err
}
// SetBase implements protocol.Operations.
func (o *Operations) SetBase(ctx context.Context, funcs ...protocol.SetBaseOptionFunc) error {
config, err := o.GetConfiguration(ctx)
if err != nil {
return errors.WithStack(err)
}
opts := protocol.NewSetBaseOptions(funcs...)
base := &model.Base{
Accumulation: config.BaseMode.BaseCoordinates.Accumulation,
AntennaOffset: config.BaseMode.BaseCoordinates.AntennaOffset,
Coordinates: model.BaseCoordinates{
Height: config.BaseMode.BaseCoordinates.Coordinates.Height,
Latitude: config.BaseMode.BaseCoordinates.Coordinates.Latitude,
Longitude: config.BaseMode.BaseCoordinates.Coordinates.Longitude,
},
Mode: config.BaseMode.BaseCoordinates.Mode,
}
if opts.Mode != nil {
base.Mode = *opts.Mode
}
if opts.Height != nil {
base.Coordinates.Height = *opts.Height
}
if opts.Latitude != nil {
base.Coordinates.Latitude = *opts.Latitude
}
if opts.Longitude != nil {
base.Coordinates.Longitude = *opts.Longitude
}
if opts.AntennaOffset != nil {
base.AntennaOffset = *opts.AntennaOffset
}
if _, err := o.PostBaseCoordinates(ctx, base); err != nil {
return errors.WithStack(err)
}
return nil
}
// Configuration implements protocol.Operations.
func (o *Operations) Configuration(ctx context.Context) (any, error) {
config, err := o.GetConfiguration(ctx)
if err != nil {
return nil, errors.WithStack(err)
}
return config, nil
}
// Alive implements protocol.Operations.
func (o *Operations) Alive(ctx context.Context) (bool, error) {
o.mutex.RLock()
defer o.mutex.RUnlock()
return o.client.Alive(), nil
}
// Version implements protocol.Operations.
func (o *Operations) Version(ctx context.Context) (string, bool, error) {
info, err := o.GetInfo(ctx)
if err != nil {
return "", false, errors.WithStack(err)
}
updater, err := o.GetUpdater(ctx)
if err != nil {
return "", false, errors.WithStack(err)
}
version := info.Reachview.Version
stable := updater.Release.Channel == "stable"
return version, stable, nil
}
// Close implements protocol.Operations.
func (o *Operations) Close(ctx context.Context) error {
o.mutex.Lock()
defer o.mutex.Unlock()
if o.client == nil {
return nil
}
o.client.Close()
return nil
}
// Connect implements protocol.Operations.
func (o *Operations) Connect(ctx context.Context) error {
o.mutex.Lock()
defer o.mutex.Unlock()
if o.client != nil {
o.client.Close()
}
endpoint, err := socketio.EndpointFromHAddr(o.addr)
if err != nil {
return errors.WithStack(err)
}
client := socketio.NewClient(endpoint)
if err := client.Connect(); err != nil {
return errors.WithStack(err)
}
o.client = client
return nil
}
// Emit implements protocol.Operations.
func (o *Operations) Emit(ctx context.Context, mType string, message any) error {
o.mutex.RLock()
defer o.mutex.RUnlock()
if o.client == nil || !o.client.Alive() {
return errors.WithStack(protocol.ErrClosed)
}
if err := o.client.Emit(mType, message); err != nil {
return errors.WithStack(err)
}
return nil
}
// On implements protocol.Operations.
func (o *Operations) On(ctx context.Context, event string) (chan any, error) {
o.mutex.RLock()
defer o.mutex.RUnlock()
if o.client == nil || !o.client.Alive() {
return nil, errors.WithStack(protocol.ErrClosed)
}
out := make(chan any)
closer := new(sync.Once)
handler := func(ch *socketio.Channel, data any) {
select {
case <-ctx.Done():
closer.Do(func() {
o.mutex.RLock()
defer o.mutex.RUnlock()
ch.Close()
close(out)
if o.client == nil {
return
}
})
return
default:
out <- data
}
}
if err := o.client.On(event, handler); err != nil {
return nil, errors.WithStack(err)
}
return out, nil
}
var _ protocol.Operations = &Operations{}

31
reach/client/protocol/v2/operations_test.go Normal file
View File

@ -0,0 +1,31 @@
package v2
import (
"context"
"testing"
"forge.cadoles.com/cadoles/go-emlid/reach/client/protocol"
"forge.cadoles.com/cadoles/go-emlid/reach/client/protocol/testsuite"
"github.com/pkg/errors"
)
func TestProtocolV2Operations(t *testing.T) {
proto := &Protocol{}
factory := func(addr string) (protocol.Operations, error) {
ctx := context.Background()
available, err := proto.Available(ctx, addr)
if err != nil {
return nil, errors.WithStack(err)
}
if !available {
return nil, errors.New("protocol is not available")
}
return proto.Operations(addr), nil
}
testsuite.TestOperations(t, factory)
}

54
reach/client/protocol/v2/protocol.go Normal file
View File

@ -0,0 +1,54 @@
package v2
import (
"context"
"forge.cadoles.com/cadoles/go-emlid/reach/client/protocol"
"github.com/Masterminds/semver/v3"
"github.com/pkg/errors"
)
const Identifier protocol.Identifier = "v2"
const compatibleVersionConstraint = ">= 32"
type Protocol struct {
}
// Available implements protocol.Protocol.
func (p *Protocol) Available(ctx context.Context, addr string) (bool, error) {
ops := p.Operations(addr).(*Operations)
info, err := ops.GetInfo(ctx)
if err != nil {
return false, errors.WithStack(err)
}
versionConstraint, err := semver.NewConstraint(compatibleVersionConstraint)
if err != nil {
return false, errors.WithStack(err)
}
version, err := semver.NewVersion(info.Reachview.Version)
if err != nil {
return false, errors.WithStack(err)
}
if !versionConstraint.Check(version) {
return false, errors.Errorf("reachview version '%s' does not match constraint '%s'", info.Reachview.Version, compatibleVersionConstraint)
}
return true, nil
}
// Identifier implements protocol.Protocol.
func (p *Protocol) Identifier() protocol.Identifier {
return Identifier
}
// Operations implements protocol.Protocol.
func (p *Protocol) Operations(addr string) protocol.Operations {
return &Operations{addr: addr}
}
var _ protocol.Protocol = &Protocol{}

137
reach/client/socketio/client.go Normal file
View File

@ -0,0 +1,137 @@
package socketio
import (
"sync"
gosocketio "forge.cadoles.com/Pyxis/golang-socketio"
"forge.cadoles.com/Pyxis/golang-socketio/transport"
"github.com/pkg/errors"
)
type Channel = gosocketio.Channel
const (
OnDisconnection = gosocketio.OnDisconnection
OnConnection = gosocketio.OnConnection
OnError = gosocketio.OnError
)
type Client struct {
conn *gosocketio.Client
mutex sync.RWMutex
endpoint string
opts *Options
}
func (c *Client) Connect() error {
c.mutex.Lock()
defer c.mutex.Unlock()
var err error
var wg sync.WaitGroup
wg.Add(1)
transport := &transport.WebsocketTransport{
PingInterval: c.opts.PingInterval,
PingTimeout: c.opts.PingTimeout,
ReceiveTimeout: c.opts.ReceiveTimeout,
SendTimeout: c.opts.SendTimeout,
BufferSize: c.opts.BufferSize,
}
conn, err := gosocketio.Dial(c.endpoint, transport)
if err != nil {
return errors.Wrap(err, "error while connecting to endpoint")
}
c.conn = nil
cleanup := func() {
conn.Off(gosocketio.OnError)
conn.Off(gosocketio.OnConnection)
}
err = conn.On(gosocketio.OnConnection, func(h *Channel) {
cleanup()
wg.Done()
})
if err != nil {
return errors.Wrap(err, "error while attaching to connection event")
}
err = conn.On(gosocketio.OnError, func(h *Channel) {
cleanup()
err = errors.Errorf("an unknown error occured")
wg.Done()
})
if err != nil {
return errors.Wrap(err, "error while attaching to error event")
}
wg.Wait()
c.conn = conn
return err
}
func (c *Client) Close() {
c.mutex.Lock()
defer c.mutex.Unlock()
if c.conn == nil {
return
}
c.conn.Close()
c.conn = nil
}
func (c *Client) Alive() bool {
c.mutex.RLock()
defer c.mutex.RUnlock()
if c.conn == nil {
return false
}
return c.conn.IsAlive()
}
// Emit a new event with the given data
func (c *Client) Emit(event string, data any) error {
c.mutex.RLock()
defer c.mutex.RUnlock()
if err := c.conn.Emit(event, data); err != nil {
return errors.Wrapf(err, "error while emitting '%s' event", event)
}
return nil
}
type Handler func(ch *Channel, data any)
// On binds and event handler to the given event
func (c *Client) On(event string, handler Handler) error {
c.mutex.RLock()
defer c.mutex.RUnlock()
return c.conn.On(event, handler)
}
// Off remove the handler bound to the given event
func (c *Client) Off(event string) {
c.mutex.RLock()
defer c.mutex.RUnlock()
c.conn.Off(event)
}
func NewClient(endpoint string, funcs ...OptionFunc) *Client {
opts := NewOptions(funcs...)
client := &Client{
endpoint: endpoint,
opts: opts,
}
return client
}

38
reach/client/socketio/endpoint.go Normal file
View File

@ -0,0 +1,38 @@
package socketio
import (
"net"
"strconv"
"strings"
gosocketio "forge.cadoles.com/Pyxis/golang-socketio"
"github.com/pkg/errors"
)
func EndpointFromHAddr(addr string) (string, error) {
host, rawPort, err := net.SplitHostPort(addr)
if err != nil {
var addrErr *net.AddrError
if !errors.As(err, &addrErr) || !strings.Contains(addrErr.Error(), "missing port in address") {
return "", errors.WithStack(err)
}
host = addr
}
port := int64(80)
if rawPort != "" {
port, err = strconv.ParseInt(rawPort, 10, 32)
if err != nil {
return "", errors.WithStack(err)
}
}
endpoint := Endpoint(host, int(port), false)
return endpoint, nil
}
func Endpoint(host string, port int, secure bool) string {
return gosocketio.GetUrl(host, port, false)
}

62
reach/client/socketio/options.go Normal file
View File

@ -0,0 +1,62 @@
package socketio
import "time"
type Options struct {
PingInterval time.Duration
PingTimeout time.Duration
ReceiveTimeout time.Duration
SendTimeout time.Duration
BufferSize int
}
type OptionFunc func(opts *Options)
func NewOptions(funcs ...OptionFunc) *Options {
opts := &Options{
PingInterval: 5 * time.Second,
PingTimeout: 60 * time.Second,
ReceiveTimeout: 60 * time.Second,
SendTimeout: 60 * time.Second,
BufferSize: 1024 * 32,
}
for _, fn := range funcs {
fn(opts)
}
return opts
}
// WithPingInterval configures the client to use the given ping interval
func WithPingInterval(interval time.Duration) OptionFunc {
return func(opts *Options) {
opts.PingInterval = interval
}
}
// WithPingTimeout configures the client to use the given ping timeout
func WithPingTimeout(timeout time.Duration) OptionFunc {
return func(opts *Options) {
opts.PingTimeout = timeout
}
}
// WithReceiveTimeout configures the client to use the given receive timeout
func WithReceiveTimeout(timeout time.Duration) OptionFunc {
return func(opts *Options) {
opts.ReceiveTimeout = timeout
}
}
// WithSendTimeout configures the client to use the given send timeout
func WithSendTimeout(timeout time.Duration) OptionFunc {
return func(opts *Options) {
opts.SendTimeout = timeout
}
}
// WithBufferSize configures the client to use the given buffer size
func WithBufferSize(size int) OptionFunc {
return func(opts *Options) {
opts.BufferSize = size
}
}

56
reach/discovery/discovery.go Normal file
View File

@ -0,0 +1,56 @@
package discovery
import (
"context"
"net"
"sync"
"github.com/grandcat/zeroconf"
)
// Service is a ReachRS service discovered via MDNS-SD
type Service struct {
Name string
AddrV4 *net.IP
Port int
}
// Discover tries to discover ReachRS services on the local network via mDNS-SD
func Discover(ctx context.Context) ([]Service, error) {
var wg sync.WaitGroup
wg.Add(1)
resolver, err := zeroconf.NewResolver()
if err != nil {
return nil, err
}
services := make([]Service, 0)
entries := make(chan *zeroconf.ServiceEntry)
go func() {
for e := range entries {
var addr *net.IP
if len(e.AddrIPv4) > 0 {
addr = &e.AddrIPv4[0]
}
srv := Service{
Name: e.Instance,
AddrV4: addr,
Port: e.Port,
}
services = append(services, srv)
}
wg.Done()
}()
if err = resolver.Browse(ctx, "_reach._tcp", ".local", entries); err != nil {
return nil, err
}
wg.Wait()
return services, nil
}

53
reach/discovery/discovery_test.go Normal file
View File

@ -0,0 +1,53 @@
package discovery
import (
"context"
"regexp"
"testing"
"time"
"forge.cadoles.com/cadoles/go-emlid/reach"
)
func TestDiscovery(t *testing.T) {
reach.AssertIntegrationTests(t)
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
services, err := Discover(ctx)
if err != nil {
t.Fatal(err)
}
if g, e := len(services), 1; g < e {
t.Fatalf("len(services): got '%d', expected > %d", g, e)
}
t.Logf("Found %d services", len(services))
patterns := []string{"reach", "Reach", "^RS.*"}
for i, s := range services {
t.Logf("Service #%d: %s - %s:%d", i, s.Name, s.AddrV4.String(), s.Port)
matched := false
for _, p := range patterns {
re, err := regexp.Compile(p)
if err != nil {
t.Fatal(err)
}
if re.Match([]byte(s.Name)) {
matched = true
break
}
}
if !matched {
t.Errorf("services[%d].Name ('%s') to match on of '%v'", i, s.Name, patterns)
}
}
}

30
reach/integration.go Normal file
View File

@ -0,0 +1,30 @@
package reach
import (
"os"
"strconv"
"testing"
"github.com/pkg/errors"
)
const skipIntegrationTestsEnv = "SKIP_INTEGRATION_TESTS"
func AssertIntegrationTests(t *testing.T) {
rawSkipIntegrationTests := os.Getenv(skipIntegrationTestsEnv)
if rawSkipIntegrationTests == "" {
rawSkipIntegrationTests = "false"
}
skipIntegrationTests, err := strconv.ParseBool(rawSkipIntegrationTests)
if err != nil {
t.Logf("[WARN] could not parse environment variable '%s': %+v", skipIntegrationTestsEnv, errors.WithStack(err))
skipIntegrationTests = false
}
if !skipIntegrationTests {
return
}
t.Skipf("Integration tests skipped. To enable, set environment variable %s=false", skipIntegrationTestsEnv)
}