gomavlib

package module
v4.0.0-aircast.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 17, 2026 License: MIT Imports: 27 Imported by: 0

README

gomavlib

Test Lint Dialects CodeCov PkgGoDev

gomavlib is a library that implements the Mavlink protocol (2.0 and 1.0) in the Go programming language. It can interact with Mavlink-capable devices through a serial port, UDP, TCP or a custom transport, and it can be used to power UGVs, UAVs, ground stations, monitoring systems or routers.

Mavlink is a lightweight and transport-independent protocol that is mostly used to communicate with unmanned ground vehicles (UGV) and unmanned aerial vehicles (UAV, drones, quadcopters, multirotors). It is supported by the most popular open-source flight controllers (Ardupilot and PX4).

This library powers the mavp2p router.

Features:

  • Create Mavlink nodes able to communicate with other nodes.
    • Supported transports: serial, UDP (server, client or broadcast mode), TCP (server or client mode), custom reader/writer.
    • Support both domain names and IPs.
    • Emit heartbeats automatically.
    • Send automatic stream requests to Ardupilot devices (disabled by default).
  • Decode and encode Mavlink v2.0 and v1.0.
    • Compute and validate checksums.
    • Support all v2 features: empty-byte truncation, signatures, message extensions.
  • Use dialects in multiple ways.
    • Ready-to-use standard dialects are available in directory dialects/.
    • Custom dialects can be defined. Aa dialect generator is available in order to convert XML definitions into their Go representation.
    • Use no dialect at all. Messages can be routed without having their content decoded.
  • Read and write telemetry logs (tlog)

Table of contents

Installation

  1. Install Go ≥ 1.25.

  2. Create an empty folder, open a terminal in it and initialize the Go modules system:

    go mod init main

  3. Download one of the example files and place it in the folder.

  4. Compile and run:

    go run name-of-the-go-file.go

Examples

API Documentation

Click to open the API Documentation

Dialect generation

Standard dialects are provided in the pkg/dialects/ folder, but it's also possible to use custom dialects, that can be converted into Go files by running:

go install github.com/aircast-one/gomavlib/v4/cmd/dialect-import@latest
dialect-import my_dialect.xml

Specifications

name area
main website protocol
packet format protocol
common dialect dialects
Golang project layout project layout

Related projects

Other Go libraries

Other non-Go libraries

Documentation

Overview

Package gomavlib is a library that implements Mavlink 2.0 and 1.0 in the Go programming language. It can power UGVs, UAVs, ground stations, monitoring systems or routers acting in a Mavlink network.

Mavlink is a lighweight and transport-independent protocol that is mostly used to communicate with unmanned ground vehicles (UGV) and unmanned aerial vehicles (UAV, drones, quadcopters, multirotors). It is supported by the most common open-source flight controllers (Ardupilot and PX4).

Examples are available at https://github.com/aircast-one/gomavlib/tree/main/examples

Index

Constants

This section is empty.

Variables

View Source 
var ErrDatagramTruncated = errors.New("datagram truncated: buffer too small")

ErrDatagramTruncated is returned when a received datagram exceeds the buffer size

Functions

func SetWebTransportLogger 

func SetWebTransportLogger(logger WebTransportLogger)

SetWebTransportLogger sets the default logger for all WebTransport endpoints. Pass nil to disable logging. This is a package-level setting. Thread-safe for concurrent access.

Types

type Channel 

type Channel struct {
	// contains filtered or unexported fields
}

Channel is a communication channel created by an Endpoint. An Endpoint can create channels. For instance, a TCP client endpoint creates a single channel, while a TCP server endpoint creates a channel for each incoming connection.

func (*Channel) Endpoint 

func (ch *Channel) Endpoint() Endpoint

Endpoint returns the channel Endpoint.

func (*Channel) String 

func (ch *Channel) String() string

String implements fmt.Stringer.

type ConnectionState 

type ConnectionState int32

ConnectionState represents the current state of a durable connection endpoint 

const (
	ConnStateDisconnected ConnectionState = iota
	ConnStateConnecting
	ConnStateConnected
	ConnStateReconnecting
)

Connection states of a durable endpoint.

func (ConnectionState) String 

func (s ConnectionState) String() string

type ConnectionStateCallback 

type ConnectionStateCallback func(oldState, newState ConnectionState, err error)

ConnectionStateCallback is called when the connection state changes

type Endpoint 

type Endpoint interface {
	// contains filtered or unexported methods
}

Endpoint is an endpoint, which provides Channels.

type EndpointCustomClient 

type EndpointCustomClient struct {
	// custom connect function that opens the connection
	Connect func(ctx context.Context) (net.Conn, error)

	// the label of the protocol
	Label string

	// whether the connection is datagram-based (e.g. UDP).
	IsDatagram bool
	// contains filtered or unexported fields
}

EndpointCustomClient is an endpoint that works with a custom implementation by providing a Connect func that returns a net.Conn.

type EndpointCustomPersistent 

type EndpointCustomPersistent struct {
	// struct or interface implementing Read(), Write() and Close()
	ReadWriteCloser io.ReadWriteCloser

	// whether the connection is datagram-based (e.g. UDP).
	IsDatagram bool
	// contains filtered or unexported fields
}

EndpointCustomPersistent sets up an endpoint for pre-established, persistent connections (e.g., WebSocket, named pipes, or any long-lived connection).

Unlike EndpointCustomClient, this ensures only ONE channel is created per connection, preventing goroutine leaks for persistent connections.

type EndpointCustomServer 

type EndpointCustomServer struct {
	// function to invoke when server should start listening
	Listen func() (net.Listener, error)

	// the label of the protocol
	Label string

	// whether the connection is datagram-based (e.g. UDP).
	IsDatagram bool
	// contains filtered or unexported fields
}

EndpointCustomServer is an endpoint that works with custom implementations by providing a custom Listen func that returns a net.Listener. This allows you to use custom protocols that conform to the net.listner. A use case could be to add encrypted protocol implementations like DTLS or TCP with TLS.

type EndpointSerial 

type EndpointSerial struct {
	// name of the device of the serial port (i.e: /dev/ttyUSB0)
	Device string

	// baud rate (i.e: 57600)
	Baud int

	EndpointCustomClient
}

EndpointSerial is an endpoint that works with a serial port.

type EndpointTCPClient 

type EndpointTCPClient struct {
	// domain name or IP of the server to connect to, example: 1.2.3.4:5600
	Address string

	EndpointCustomClient
}

EndpointTCPClient is an endpoint that works with a TCP client. TCP is fit for routing frames through the internet, but is not the most appropriate way for transferring frames from a UAV to a GCS, since it does not allow frame losses.

type EndpointTCPServer 

type EndpointTCPServer struct {
	// listen address, example: 0.0.0.0:5600
	Address string

	EndpointCustomServer
}

EndpointTCPServer is an endpoint that works with a TCP server. TCP is fit for routing frames through the internet, but is not the most appropriate way for transferring frames from a UAV to a GCS, since it does not allow frame losses.

type EndpointUDPBroadcast 

type EndpointUDPBroadcast struct {
	// broadcast address to which sending outgoing frames, example: 192.168.5.255:5600
	BroadcastAddress string

	// (optional) listening address. if empty, it will be computed
	// from the broadcast address.
	LocalAddress string

	EndpointCustomClient
}

EndpointUDPBroadcast is an endpoint that works with UDP broadcast packets.

type EndpointUDPClient 

type EndpointUDPClient struct {
	// domain name or IP of the server to connect to, example: 1.2.3.4:5600
	Address string

	EndpointCustomClient
}

EndpointUDPClient is an endpoint that works with a UDP client.

type EndpointUDPServer 

type EndpointUDPServer struct {
	// listen address, example: 0.0.0.0:5600
	Address string

	EndpointCustomServer
}

EndpointUDPServer is an endpoint that works with an UDP server. This is the most appropriate way for transferring frames from a UAV to a GCS if they are connected to the same network.

type EndpointWebSocket 

type EndpointWebSocket struct {
	// WebSocket URL to connect to (e.g., "ws://localhost:8080/mavlink")
	URL string

	// Optional HTTP headers to send during WebSocket handshake.
	// For static headers that don't change between reconnections.
	Headers map[string]string

	// Optional callback that provides headers dynamically on each connection attempt.
	// When set, this is called instead of using the static Headers map.
	// This is useful for authentication tokens that may expire and need refreshing
	// between reconnection attempts.
	//
	// If the provider returns a non-nil error, the connection attempt is skipped
	// entirely (no HTTP request is made) and the error is counted as a failure
	// for the circuit breaker. This prevents sending unauthenticated requests
	// when the token cannot be obtained.
	HeaderProvider func() (map[string]string, error)

	// Optional label for logging (defaults to "websocket")
	Label string

	// Reconnection configuration (optional, uses defaults if not set)
	InitialRetryPeriod   time.Duration // Default: 1s
	MaxRetryPeriod       time.Duration // Default: 30s
	BackoffMultiplier    float64       // Default: 1.5
	MaxReconnectAttempts int           // Default: 0 (unlimited)

	// Connection timeouts (optional, uses defaults if not set)
	HandshakeTimeout time.Duration // Default: 5s
	PingPeriod       time.Duration // Default: 30s
	PongWait         time.Duration // Default: 120s

	// Circuit breaker configuration
	MaxConsecutiveErrors  int           // Default: 10
	CircuitBreakerTimeout time.Duration // Default: 5 minutes

	// State change callback (optional)
	OnStateChange WebSocketStateCallback

	// NetDialContext specifies a custom dial function for creating TCP connections.
	// This is useful for routing through custom networks like Tailscale.
	// If nil, the default dialer is used.
	NetDialContext func(ctx context.Context, network, addr string) (net.Conn, error)
	// contains filtered or unexported fields
}

EndpointWebSocket sets up a durable WebSocket endpoint with automatic reconnection. This is designed for persistent WebSocket connections used in MAVLink-over-WebSocket scenarios.

Features: - Automatic reconnection with exponential backoff - Connection health monitoring with ping/pong - Circuit breaker pattern to prevent connection storms - Error categorization and intelligent retry strategies - Connection state callbacks for monitoring

Example: 

node := &gomavlib.Node{
    Endpoints: []gomavlib.Endpoint{
        &gomavlib.EndpointWebSocket{
            URL: "ws://localhost:8080/mavlink",
            Headers: map[string]string{
                "Authorization": "Bearer token",
            },
            OnStateChange: func(old, new WebSocketState, err error) {
                log.Printf("WebSocket state: %s -> %s", old, new)
            },
        },
    },
}
err := node.Initialize()

func (*EndpointWebSocket) GetState 

func (e *EndpointWebSocket) GetState() WebSocketState

GetState returns the current connection state

func (*EndpointWebSocket) GetStats 

func (e *EndpointWebSocket) GetStats() map[string]any

GetStats returns connection statistics

func (*EndpointWebSocket) IsHealthy 

func (e *EndpointWebSocket) IsHealthy() bool

IsHealthy returns true if the connection is currently healthy

type EndpointWebTransport 

type EndpointWebTransport struct {
	// WebTransport URL to connect to (must be https://)
	URL string

	// Optional HTTP headers for the WebTransport handshake.
	// For static headers that don't change between reconnections.
	Headers map[string]string

	// Optional callback that provides headers dynamically on each connection attempt.
	// When set, this is called instead of using the static Headers map.
	// This is useful for authentication tokens that may expire and need refreshing
	// between reconnection attempts.
	//
	// If the provider returns a non-nil error, the connection attempt is skipped
	// entirely (no HTTP request is made) and the error is counted as a failure
	// for the circuit breaker.
	HeaderProvider func() (map[string]string, error)

	// Optional label for logging (defaults to "webtransport")
	Label string

	// UseDatagrams enables unreliable datagram mode (lower latency, may drop)
	// If false, uses reliable bidirectional streams
	UseDatagrams bool

	// Reconnection configuration
	InitialRetryPeriod   time.Duration // Default: 1s
	MaxRetryPeriod       time.Duration // Default: 30s
	BackoffMultiplier    float64       // Default: 1.5
	MaxReconnectAttempts int           // Default: 0 (unlimited)

	// TLS configuration (optional)
	TLSConfig *tls.Config

	// QUIC configuration for connection migration (optional)
	QUICConfig *quic.Config

	// DialAddr is a custom function for dialing the QUIC connection.
	// This can be used to route connections through Tailscale or other custom transports.
	// If nil, the default quic.DialAddrEarly will be used.
	DialAddr func(ctx context.Context, addr string, tlsCfg *tls.Config, cfg *quic.Config) (*quic.Conn, error)

	// State change callback (optional)
	OnStateChange ConnectionStateCallback

	// Logger for WebTransport debugging (optional).
	// If nil, uses the package-level default logger.
	// Set to a custom logger or use SetWebTransportLogger(nil) to disable logging.
	Logger WebTransportLogger
	// contains filtered or unexported fields
}

EndpointWebTransport sets up a WebTransport endpoint with QUIC connection migration. This endpoint survives IP address changes (e.g., cellular handoffs) without losing the connection, as QUIC uses connection IDs rather than IP:port tuples.

Features: - Connection migration across IP changes (QUIC RFC 9000) - Zero-RTT reconnection when supported - Both reliable streams and unreliable datagrams - Automatic reconnection with exponential backoff

Example: 

node := &gomavlib.Node{
    Endpoints: []gomavlib.Endpoint{
        &gomavlib.EndpointWebTransport{
            URL: "https://server.example.com:443/mavlink",
            Headers: map[string]string{
                "Authorization": "Bearer token",
            },
            UseDatagrams: true, // Use unreliable datagrams for lower latency
        },
    },
}
err := node.Initialize()

func (*EndpointWebTransport) GetState 

func (e *EndpointWebTransport) GetState() ConnectionState

GetState returns the current connection state

func (*EndpointWebTransport) GetStats 

func (e *EndpointWebTransport) GetStats() WebTransportStats

GetStats returns connection statistics

type Event 

type Event interface {
	// contains filtered or unexported methods
}

Event is the interface implemented by all events received with node.Events().

type EventChannelClose 

type EventChannelClose struct {
	Channel *Channel
	Error   error
}

EventChannelClose is fired when a channel is closed.

type EventChannelOpen 

type EventChannelOpen struct {
	Channel *Channel
}

EventChannelOpen is fired when a channel is opened.

type EventFrame 

type EventFrame struct {
	// frame
	Frame frame.Frame

	// channel from which the frame was received
	Channel *Channel
}

EventFrame is fired when a frame is received.

func (*EventFrame) ComponentID 

func (res *EventFrame) ComponentID() byte

ComponentID returns the frame component id.

func (*EventFrame) Message 

func (res *EventFrame) Message() message.Message

Message returns the message inside the frame.

func (*EventFrame) SystemID 

func (res *EventFrame) SystemID() byte

SystemID returns the frame system id.

type EventParseError 

type EventParseError struct {
	// error
	Error error

	// channel used to send the frame
	Channel *Channel
}

EventParseError is fired when a parse error occurs.

type EventStreamRequested 

type EventStreamRequested struct {
	// channel to which the stream request is addressed
	Channel *Channel

	// system id to which the stream requests is addressed
	SystemID byte

	// component id to which the stream requests is addressed
	ComponentID byte
}

EventStreamRequested is fired when an automatic stream request is sent.

type Node 

type Node struct {
	// endpoints with which this node will
	// communicate. Each endpoint contains zero or more channels
	Endpoints []Endpoint

	// (optional) dialect which contains the messages that will be encoded and decoded.
	// If not provided, messages are decoded in the MessageRaw struct.
	Dialect *dialect.Dialect

	// (optional) secret key used to validate incoming frames.
	// Non signed frames are discarded, as well as frames with a version < 2.0.
	InKey *frame.V2Key

	// Mavlink version used to encode messages. See Version
	// for the available options.
	OutVersion Version
	// system id, added to every outgoing frame and used to identify this
	// node in the network.
	OutSystemID byte
	// (optional) component id, added to every outgoing frame, defaults to 1.
	OutComponentID byte
	// (optional) secret key used to sign outgoing frames.
	// This feature requires a version >= 2.0.
	OutKey *frame.V2Key

	// (optional) disables the periodic sending of heartbeats to open channels.
	HeartbeatDisable bool
	// (optional) period between heartbeats. It defaults to 5 seconds.
	HeartbeatPeriod time.Duration
	// (optional) system type advertised by heartbeats.
	// It defaults to MAV_TYPE_GCS
	HeartbeatSystemType int
	// (optional) autopilot type advertised by heartbeats.
	// It defaults to MAV_AUTOPILOT_GENERIC
	HeartbeatAutopilotType int

	// (optional) automatically request streams to detected Ardupilot devices,
	// that need an explicit request in order to emit telemetry stream.
	StreamRequestEnable bool
	// (optional) requested stream frequency in Hz. It defaults to 4.
	StreamRequestFrequency int

	// (optional) read timeout.
	// It defaults to 10 seconds.
	ReadTimeout time.Duration
	// (optional) write timeout.
	// It defaults to 10 seconds.
	WriteTimeout time.Duration
	// (optional) timeout before closing idle connections.
	// It defaults to 60 seconds.
	IdleTimeout time.Duration
	// contains filtered or unexported fields
}

Node is a high-level Mavlink encoder and decoder that works with endpoints.

func (*Node) AddEndpoint 

func (n *Node) AddEndpoint(endpoint Endpoint) error

AddEndpoint adds a new endpoint to the node at runtime. The endpoint will be initialized and started immediately. Returns an error if initialization fails.

func (*Node) Close 

func (n *Node) Close()

Close halts node operations and waits for all routines to return.

func (*Node) Events 

func (n *Node) Events() chan Event

Events returns a channel from which receiving events. Possible events are:

* EventChannelOpen * EventChannelClose * EventFrame * EventParseError * EventStreamRequested

See individual events for details.

func (*Node) FixFrame 

func (n *Node) FixFrame(fr frame.Frame) error

FixFrame recomputes the Frame checksum and signature. This can be called on Frames whose content has been edited.

func (*Node) GetEndpoints 

func (n *Node) GetEndpoints() []Endpoint

GetEndpoints returns a list of all currently active endpoints. This is a snapshot and the list may change after this function returns.

func (*Node) Initialize 

func (n *Node) Initialize() error

Initialize initializes a Node.

func (*Node) RemoveEndpoint 

func (n *Node) RemoveEndpoint(endpoint Endpoint) error

RemoveEndpoint removes an endpoint from the node at runtime. The endpoint will be closed and all its channels will be terminated. Returns an error if the endpoint is not found.

func (*Node) WriteFrameAll 

func (n *Node) WriteFrameAll(fr frame.Frame) error

WriteFrameAll writes a frame to all channels. This function is intended only for routing pre-existing frames to other nodes, since all frame fields must be filled manually.

func (*Node) WriteFrameExcept 

func (n *Node) WriteFrameExcept(exceptChannel *Channel, fr frame.Frame) error

WriteFrameExcept writes a frame to all channels except specified channel. This function is intended only for routing pre-existing frames to other nodes, since all frame fields must be filled manually.

func (*Node) WriteFrameTo 

func (n *Node) WriteFrameTo(channel *Channel, fr frame.Frame) error

WriteFrameTo writes a frame to given channel. This function is intended only for routing pre-existing frames to other nodes, since all frame fields must be filled manually.

func (*Node) WriteMessageAll 

func (n *Node) WriteMessageAll(m message.Message) error

WriteMessageAll writes a message to all channels.

func (*Node) WriteMessageExcept 

func (n *Node) WriteMessageExcept(exceptChannel *Channel, m message.Message) error

WriteMessageExcept writes a message to all channels except specified channel.

func (*Node) WriteMessageTo 

func (n *Node) WriteMessageTo(channel *Channel, m message.Message) error

WriteMessageTo writes a message to given channel.

type RetryPolicy 

type RetryPolicy struct {
	// InitialRetryPeriod is the initial delay before first retry (default: 1s)
	InitialRetryPeriod time.Duration

	// MaxRetryPeriod is the maximum delay between retries (default: 30s)
	MaxRetryPeriod time.Duration

	// BackoffMultiplier is the factor to multiply the delay after each attempt (default: 1.5)
	BackoffMultiplier float64

	// MaxReconnectAttempts is the maximum number of reconnection attempts (0 = unlimited)
	MaxReconnectAttempts int

	// MaxConsecutiveErrors triggers circuit breaker when reached (default: 0 = disabled)
	MaxConsecutiveErrors int

	// CircuitBreakerTimeout is how long the circuit breaker stays open (default: 5 minutes)
	CircuitBreakerTimeout time.Duration
}

RetryPolicy defines the configuration for automatic reconnection with exponential backoff

func DefaultRetryPolicy 

func DefaultRetryPolicy() RetryPolicy

DefaultRetryPolicy returns a retry policy with sensible defaults

func (*RetryPolicy) ApplyDefaults 

func (p *RetryPolicy) ApplyDefaults()

ApplyDefaults fills in any zero values with defaults

type RetryState 

type RetryState struct {
	// contains filtered or unexported fields
}

RetryState tracks the current state of a retry loop. Thread-safe: uses atomic operations for counters and mutex for non-atomic fields.

func NewRetryState 

func NewRetryState(policy RetryPolicy) *RetryState

NewRetryState creates a new retry state with the given policy

func (*RetryState) BeforeAttempt 

func (s *RetryState) BeforeAttempt() (shouldWait bool, waitDuration time.Duration)

BeforeAttempt should be called before each connection attempt. Returns true if we should wait before connecting (i.e., this is a retry). The waitDuration is how long to wait before attempting. After waiting, the backoff period is increased for the next potential retry. Thread-safe.

func (*RetryState) CircuitBreakerWaitTime 

func (s *RetryState) CircuitBreakerWaitTime() time.Duration

CircuitBreakerWaitTime returns remaining time until circuit breaker closes. Thread-safe.

func (*RetryState) CloseCircuitBreaker 

func (s *RetryState) CloseCircuitBreaker()

CloseCircuitBreaker manually closes the circuit breaker (e.g., on successful connection). Thread-safe.

func (*RetryState) ConsecutiveErrors 

func (s *RetryState) ConsecutiveErrors() int32

ConsecutiveErrors returns the current consecutive error count

func (*RetryState) GetStats 

func (s *RetryState) GetStats() map[string]any

GetStats returns current retry statistics. Thread-safe.

func (*RetryState) IsCircuitBreakerOpen 

func (s *RetryState) IsCircuitBreakerOpen() bool

IsCircuitBreakerOpen returns true if the circuit breaker is currently open. Thread-safe.

func (*RetryState) OpenCircuitBreaker 

func (s *RetryState) OpenCircuitBreaker()

OpenCircuitBreaker manually opens the circuit breaker (for testing). Thread-safe.

func (*RetryState) ReconnectAttempts 

func (s *RetryState) ReconnectAttempts() int32

ReconnectAttempts returns the current reconnect attempt count

func (*RetryState) RecordAttempt 

func (s *RetryState) RecordAttempt()

RecordAttempt should be called when starting a connection attempt

func (*RetryState) RecordError 

func (s *RetryState) RecordError() bool

RecordError should be called when a connection fails. Returns true if we should continue retrying.

func (*RetryState) RecordSuccess 

func (s *RetryState) RecordSuccess()

RecordSuccess should be called when a connection succeeds. Thread-safe.

type Version 

type Version int

Version is a Mavlink version. 

const (
	// V1 is Mavlink 1.0
	V1 Version = 1

	// V2 is Mavlink 2.0
	V2 Version = 2
)

func (Version) String 

func (v Version) String() string

String implements fmt.Stringer.

type WebSocketErrorCategory 

type WebSocketErrorCategory int

WebSocketErrorCategory represents the type of error that occurred 

const (
	ErrorCategoryNetwork WebSocketErrorCategory = iota
	ErrorCategoryAuth
	ErrorCategoryProtocol
	ErrorCategoryTimeout
	ErrorCategoryUnknown
)

WebSocket error categories used to decide whether a failure is retryable.

type WebSocketState 

type WebSocketState int32

WebSocketState represents the current state of the WebSocket connection 

const (
	WSStateDisconnected WebSocketState = iota
	WSStateConnecting
	WSStateConnected
	WSStateReconnecting
)

WebSocket connection states.

func (WebSocketState) String 

func (s WebSocketState) String() string

type WebSocketStateCallback 

type WebSocketStateCallback func(oldState, newState WebSocketState, err error)

WebSocketStateCallback is called when the connection state changes

type WebTransportLogger 

type WebTransportLogger interface {
	Printf(format string, v ...any)
}

WebTransportLogger interface allows custom logging implementations. If not set, a default stderr logger is used.

type WebTransportStats 

type WebTransportStats struct {
	State             string    `json:"state"`
	ReconnectAttempts int32     `json:"reconnect_attempts"`
	ConsecutiveErrors int32     `json:"consecutive_errors"`
	LastConnectTime   time.Time `json:"last_connect_time"`
}

WebTransportStats contains connection statistics

Source Files

View all Source files

Directories

Path Synopsis
cmd
dialect-import command
dialect-import command.
 dialect-import command.
dialects-gen command
dialects-gen command.
 dialects-gen command.
examples
endpoint-dynamic command
Package main contains an example.
 Package main contains an example.
frame-read-writer command
Package main contains an example.
 Package main contains an example.
node-command-microservice command
Package main contains an example.
 Package main contains an example.
node-dialect-absent command
Package main contains an example.
 Package main contains an example.
node-dialect-custom command
Package main contains an example.
 Package main contains an example.
node-endpoint-custom-client command
Package main contains an example.
 Package main contains an example.
node-endpoint-custom-server command
Package main contains an example.
 Package main contains an example.
node-endpoint-serial command
Package main contains an example.
 Package main contains an example.
node-endpoint-tcp-client command
Package main contains an example.
 Package main contains an example.
node-endpoint-tcp-server command
Package main contains an example.
 Package main contains an example.
node-endpoint-udp-broadcast command
Package main contains an example.
 Package main contains an example.
node-endpoint-udp-client command
Package main contains an example.
 Package main contains an example.
node-endpoint-udp-server command
Package main contains an example.
 Package main contains an example.
node-events command
Package main contains an example.
 Package main contains an example.
node-message-read command
Package main contains an example.
 Package main contains an example.
node-message-write command
Package main contains an example.
 Package main contains an example.
node-router command
Package main contains an example.
 Package main contains an example.
node-router-edit command
Package main contains an example.
 Package main contains an example.
node-serial-to-json command
Package main contains an example.
 Package main contains an example.
node-signature command
Package main contains an example.
 Package main contains an example.
node-stream-requests command
Package main contains an example.
 Package main contains an example.
telemetry-log command
Package main contains an example.
 Package main contains an example.
pkg
conversion
Package conversion contains functions to convert definitions from XML to Go.
 Package conversion contains functions to convert definitions from XML to Go.
dialect
Package dialect contains the dialect definition and its parser.
 Package dialect contains the dialect definition and its parser.
dialects/all
Package all contains the all dialect.
 Package all contains the all dialect.
dialects/ardupilotmega
Package ardupilotmega contains the ardupilotmega dialect.
 Package ardupilotmega contains the ardupilotmega dialect.
dialects/asluav
Package asluav contains the asluav dialect.
 Package asluav contains the asluav dialect.
dialects/avssuas
Package avssuas contains the avssuas dialect.
 Package avssuas contains the avssuas dialect.
dialects/common
Package common contains the common dialect.
 Package common contains the common dialect.
dialects/csairlink
Package csairlink contains the csairlink dialect.
 Package csairlink contains the csairlink dialect.
dialects/cubepilot
Package cubepilot contains the cubepilot dialect.
 Package cubepilot contains the cubepilot dialect.
dialects/development
Package development contains the development dialect.
 Package development contains the development dialect.
dialects/icarous
Package icarous contains the icarous dialect.
 Package icarous contains the icarous dialect.
dialects/loweheiser
Package loweheiser contains the loweheiser dialect.
 Package loweheiser contains the loweheiser dialect.
dialects/marsh
Package marsh contains the marsh dialect.
 Package marsh contains the marsh dialect.
dialects/minimal
Package minimal contains the minimal dialect.
 Package minimal contains the minimal dialect.
dialects/paparazzi
Package paparazzi contains the paparazzi dialect.
 Package paparazzi contains the paparazzi dialect.
dialects/pythonarraytest
Package pythonarraytest contains the pythonarraytest dialect.
 Package pythonarraytest contains the pythonarraytest dialect.
dialects/standard
Package standard contains the standard dialect.
 Package standard contains the standard dialect.
dialects/stemstudios
Package stemstudios contains the stemstudios dialect.
 Package stemstudios contains the stemstudios dialect.
dialects/storm32
Package storm32 contains the storm32 dialect.
 Package storm32 contains the storm32 dialect.
dialects/test
Package test contains the test dialect.
 Package test contains the test dialect.
dialects/ualberta
Package ualberta contains the ualberta dialect.
 Package ualberta contains the ualberta dialect.
dialects/uavionix
Package uavionix contains the uavionix dialect.
 Package uavionix contains the uavionix dialect.
frame
Package frame contains frame definitions and a frame parser.
 Package frame contains frame definitions and a frame parser.
message
Package message contains the message definition and its parser.
 Package message contains the message definition and its parser.
streamwriter
Package streamwriter contains a message stream writer.
 Package streamwriter contains a message stream writer.
timednetconn
Package timednetconn contains a net.Conn wrapper with deadlines.
 Package timednetconn contains a net.Conn wrapper with deadlines.
tlog
Package tlog contains a Telemetry log reader and writer.
 Package tlog contains a Telemetry log reader and writer.
x25
Package x25 implements the X25 hash.
 Package x25 implements the X25 hash.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.