Choose a protocol

1
package main
2
3
import (
4
	"context"
5
	"fmt"
6
	"math"
7
	"net/http"
8
	"os"
9
	"time"
10
11
	Lattice "github.com/anduril/lattice-sdk-go/v4"
12
	"github.com/anduril/lattice-sdk-go/v4/client"
13
	"github.com/anduril/lattice-sdk-go/v4/option"
14
	"github.com/google/uuid"
15
)
16
17
// velocityToYawEnu converts an ENU velocity vector into a yaw angle, in
18
// radians. It uses the ENU mathematical convention where a yaw of 0 points
19
// East and a yaw of pi/2 points North.
20
func velocityToYawEnu(velocityEast, velocityNorth float64) float64 {
21
	return math.Atan2(velocityNorth, velocityEast)
22
}
23
24
// yawToQuaternionEnu converts a yaw angle into the attitude_enu quaternion.
25
// Yaw is a rotation about the ENU Up (Z) axis, so the quaternion only has Z
26
// and W components. The result is already unit-normalized.
27
func yawToQuaternionEnu(yawRad float64) *Lattice.Quaternion {
28
	return &Lattice.Quaternion{
29
		X: Lattice.Float64(0.0),
30
		Y: Lattice.Float64(0.0),
31
		Z: Lattice.Float64(math.Sin(yawRad / 2.0)),
32
		W: Lattice.Float64(math.Cos(yawRad / 2.0)),
33
	}
34
}
35
36
func main() {
37
	// Get environment variables
38
	latticeEndpoint := os.Getenv("LATTICE_ENDPOINT")
39
	clientSecret := os.Getenv("LATTICE_CLIENT_SECRET")
40
	clientId := os.Getenv("LATTICE_CLIENT_ID")
41
42
	// Remove sandboxesToken from the following statements if you are not developing on Sandboxes
43
	sandboxesToken := os.Getenv("SANDBOXES_TOKEN")
44
45
	// Check required environment variables
46
	if latticeEndpoint == "" || clientId == "" || clientSecret == "" || sandboxesToken == "" {
47
		fmt.Println("Missing required environment variables")
48
		os.Exit(1)
49
	}
50
51
	// Initialize headers for sandbox authorization
52
	headers := http.Header{}
53
	headers.Add("Anduril-Sandbox-Authorization", fmt.Sprintf("Bearer %s", sandboxesToken))
54
55
	// Create the client
56
	LatticeClient := client.NewClient(
57
		option.WithClientCredentials(clientId, clientSecret),
58
		option.WithBaseURL(fmt.Sprintf("https://%s", latticeEndpoint)),
59
		option.WithHTTPHeader(headers),
60
	)
61
62
	// Generate a unique ID for the entity
63
	entityId := uuid.New().String()
64
65
	// Set a radius, in degrees, to simulate the entity moving in a circle
66
	radiusDegrees := 0.1
67
	count := 0.0
68
	centerLat := 50.91402185768586
69
	centerLon := 0.79203612077257
70
	creationTime := time.Now().UTC()
71
72
	// Continuously publish the entity
73
	for {
74
		latestTimestamp := time.Now().UTC()
75
		ctx := context.Background()
76
77
		// Update position
78
		count += 0.1
79
		t := math.Pi * count / 180.0
80
81
		// Derive the ENU velocity from the circular motion, then convert it
82
		// into a yaw angle and an attitude_enu quaternion.
83
		lat := centerLat + (radiusDegrees * math.Cos(t))
84
		metersPerDegreeLat := 111320.0
85
		metersPerDegreeLon := 111320.0 * math.Cos(lat*math.Pi/180.0)
86
		velocityEast := radiusDegrees * math.Cos(t) * metersPerDegreeLon
87
		velocityNorth := -radiusDegrees * math.Sin(t) * metersPerDegreeLat
88
		yawRad := velocityToYawEnu(velocityEast, velocityNorth)
89
90
		// Create entity to publish
91
		entity := Lattice.Entity{
92
			EntityID:    &entityId,
93
			Description: Lattice.String("Friendly drone asset"),
94
			Aliases: &Lattice.Aliases{
95
				Name: Lattice.String("Drone 1"),
96
			},
97
			IsLive:      Lattice.Bool(true),
98
			CreatedTime: Lattice.Time(creationTime),
99
			ExpiryTime:  Lattice.Time(latestTimestamp.Add(1 * time.Hour)),
100
			Ontology: &Lattice.Ontology{
101
				Template:     Lattice.OntologyTemplateTemplateAsset.Ptr(),
102
				PlatformType: Lattice.String("UAV"),
103
			},
104
			MilView: &Lattice.MilView{
105
				Disposition: Lattice.MilViewDispositionDispositionFriendly.Ptr(),
106
				Environment: Lattice.MilViewEnvironmentEnvironmentAir.Ptr(),
107
			},
108
			Location: &Lattice.Location{
109
				Position: &Lattice.Position{
110
					LatitudeDegrees:   Lattice.Float64(centerLat + (radiusDegrees * math.Cos(t))),
111
					LongitudeDegrees:  Lattice.Float64(centerLon + (radiusDegrees * math.Sin(t))),
112
					AltitudeAsfMeters: Lattice.Float64(1000),
113
				},
114
				// Report the velocity in the ENU frame, in meters per second.
115
				// Vertical velocity is 0 at constant altitude.
116
				VelocityEnu: &Lattice.Enu{
117
					E: Lattice.Float64(velocityEast),
118
					N: Lattice.Float64(velocityNorth),
119
					U: Lattice.Float64(0.0),
120
				},
121
				// Report the heading as a quaternion derived from velocity.
122
				AttitudeEnu: yawToQuaternionEnu(yawRad),
123
			},
124
			Provenance: &Lattice.Provenance{
125
				IntegrationName:  Lattice.String("your_integration_name"),
126
				DataType:         Lattice.String("your_data_type"),
127
				SourceUpdateTime: Lattice.Time(latestTimestamp),
128
			},
129
			Health: &Lattice.Health{
130
				ConnectionStatus: Lattice.HealthConnectionStatusConnectionStatusOnline.Ptr(),
131
				HealthStatus:     Lattice.HealthHealthStatusHealthStatusHealthy.Ptr(),
132
				// Report the health of individual subsystems in components.
133
				// Each component needs a stable ID, a display name, and a
134
				// health status. Here, the drone reports its battery as healthy.
135
				Components: []*Lattice.ComponentHealth{
136
					{
137
						ID:     Lattice.String("battery-0"),
138
						Name:   Lattice.String("Battery"),
139
						Health: Lattice.ComponentHealthHealthHealthStatusHealthy.Ptr(),
140
						Messages: []*Lattice.ComponentMessage{
141
							{
142
								Status:  Lattice.ComponentMessageStatusHealthStatusHealthy.Ptr(),
143
								Message: Lattice.String("Battery at 87% charge."),
144
							},
145
						},
146
						UpdateTime: Lattice.Time(latestTimestamp),
147
					},
148
				},
149
				// Live list of active alerts for the asset. Remove entries
150
				// when the underlying condition clears; Lattice does not
151
				// filter stale entries automatically.
152
				ActiveAlerts: []*Lattice.Alert{},
153
				UpdateTime:   Lattice.Time(latestTimestamp),
154
			},
155
			// Declare the sensors carried by the asset. Each entry requires a
156
			// stable sensor_id, a sensor_type, and at least one field of view
157
			// so Lattice can render the sensor cone.
158
			Sensors: &Lattice.Sensors{
159
				Sensors: []*Lattice.Sensor{
160
					{
161
						SensorID:         Lattice.String("camera-1"),
162
						SensorType:       Lattice.SensorSensorTypeSensorTypeCamera.Ptr(),
163
						OperationalState: Lattice.SensorOperationalStateOperationalStateOperational.Ptr(),
164
						FieldsOfView: []*Lattice.FieldOfView{
165
							{
166
								CenterRayPose: &Lattice.EntityManagerPose{
167
									Orientation: &Lattice.Quaternion{
168
										X: Lattice.Float64(0.0),
169
										Y: Lattice.Float64(0.0),
170
										Z: Lattice.Float64(0.0),
171
										W: Lattice.Float64(1.0),
172
									},
173
								},
174
								HorizontalFov: Lattice.Float64(1.047),
175
								VerticalFov:   Lattice.Float64(0.785),
176
								Range:         Lattice.Float64(2000.0),
177
								Mode:          Lattice.FieldOfViewModeSensorModeSearch.Ptr(),
178
							},
179
						},
180
					},
181
				},
182
			},
183
			TaskCatalog: &Lattice.TaskCatalog{
184
				TaskDefinitions: []*Lattice.TaskDefinition{
185
					{TaskSpecificationURL: Lattice.String("type.googleapis.com/anduril.tasks.v2.VisualId")},
186
					{TaskSpecificationURL: Lattice.String("type.googleapis.com/anduril.tasks.v2.Investigate")},
187
				},
188
			},
189
		}
190
191
		// Publish the entity
192
		_, err := LatticeClient.Entities.PublishEntity(ctx, &entity)
193
194
		// Handle errors
195
		if err != nil {
196
			fmt.Printf("Error publishing entity: %v\n", err)
197
		} else {
198
			fmt.Println("Publishing asset")
199
		}
200
201
		// Wait before next request
202
		time.Sleep(1 * time.Second)
203
	}
204
}

1
package main
2
3
import (
4
	"context"
5
	"errors"
6
	"fmt"
7
	"io"
8
	"log"
9
	"net/http"
10
	"os"
11
12
	Lattice "github.com/anduril/lattice-sdk-go/v4"
13
	"github.com/anduril/lattice-sdk-go/v4/client"
14
	"github.com/anduril/lattice-sdk-go/v4/option"
15
)
16
17
func main() {
18
	ctx, cancel := context.WithCancel(context.Background())
19
	defer cancel()
20
21
	latticeEndpoint := os.Getenv("LATTICE_ENDPOINT")
22
	clientSecret := os.Getenv("LATTICE_CLIENT_SECRET")
23
	clientId := os.Getenv("LATTICE_CLIENT_ID")
24
	sandboxesToken := os.Getenv("SANDBOXES_TOKEN")
25
26
	if latticeEndpoint == "" || clientId == "" || clientSecret == "" || sandboxesToken == "" {
27
		log.Fatal("Required environment variables not set.")
28
	}
29
30
	headers := http.Header{}
31
	headers.Add("Anduril-Sandbox-Authorization", fmt.Sprintf("Bearer %s", sandboxesToken))
32
33
	latticeClient := client.NewClient(
34
		option.WithClientCredentials(clientId, clientSecret),
35
		option.WithBaseURL(fmt.Sprintf("https://%s", latticeEndpoint)),
36
		option.WithHTTPHeader(headers),
37
	)
38
39
	// Create the entity stream.
40
	stream, err := latticeClient.Entities.StreamEntities(ctx, &Lattice.EntityStreamRequest{
41
		PreExistingOnly: Lattice.Bool(false),
42
		// Define a list of components to control which entities are fetched.
43
		// If set, Lattice streams only entities with the components you provide.
44
		ComponentsToInclude: []string{"aliases", "location_uncertainty"},
45
	})
46
	if err != nil {
47
		log.Fatalf("Failed to create entity stream: %v", err)
48
	}
49
	defer stream.Close()
50
51
	for {
52
		select {
53
		case <-ctx.Done():
54
			log.Printf("Context canceled: %v", ctx.Err())
55
			return
56
		default:
57
			// Continue processing
58
		}
59
		message, err := stream.Recv()
60
61
		// Handle stream completion
62
		if errors.Is(err, io.EOF) {
63
			log.Println("Stream completed successfully.")
64
			return
65
		}
66
67
		if err != nil {
68
			log.Printf("Error receiving message: %v", err)
69
			continue
70
		}
71
72
		// Process the event based whether it is a heartbeat or entity event.
73
		switch message.Event {
74
		case "heartbeat":
75
			timestamp := *message.Heartbeat.Timestamp
76
			log.Printf("Heartbeat: %s", timestamp)
77
		case "entity":
78
			log.Printf("Entity: %s", *message.Entity.Entity.Aliases.Name)
79
		default:
80
			log.Printf("Unknown event type: %s", message.Event)
81
		}
82
	}
83
}