@blueyerobotics/protocol-definitions 3.4.0-8187f91a → 3.4.0-efe27311
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/control.d.ts +28 -0
- package/dist/control.js +159 -0
- package/dist/index.blueye.protocol.d.ts +2 -1
- package/dist/index.blueye.protocol.js +2 -1
- package/dist/message_formats.d.ts +104 -2
- package/dist/message_formats.js +353 -2
- package/dist/mission_planning.d.ts +526 -5
- package/dist/mission_planning.js +3098 -143
- package/dist/req_rep.d.ts +229 -5
- package/dist/req_rep.js +1780 -400
- package/dist/slam.d.ts +512 -0
- package/dist/slam.js +2427 -0
- package/dist/telemetry.d.ts +98 -1
- package/dist/telemetry.js +531 -1
- package/package.json +1 -1
package/dist/req_rep.d.ts
CHANGED
|
@@ -1,7 +1,8 @@
|
|
|
1
1
|
import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
|
|
2
2
|
import { Any } from "./google/protobuf/any.js";
|
|
3
|
-
import { Battery, Camera, CameraParameters, ClientInfo, ConnectedClient, CvModelInfo, HeadingMode, MultibeamColorFilter, OverlayParameters, PersistentStorageSettings, SystemTime } from "./message_formats.js";
|
|
4
|
-
import { Instruction, Mission } from "./mission_planning.js";
|
|
3
|
+
import { Battery, Camera, CameraParameters, ClientInfo, ConnectedClient, CvModelInfo, HeadingMode, MultibeamColorFilter, OverlayParameters, PersistentStorageSettings, StorageLocation, SystemTime } from "./message_formats.js";
|
|
4
|
+
import { InsertInstruction, Instruction, Mission, MissionRule } from "./mission_planning.js";
|
|
5
|
+
import { SlamRecordingState, SlamRequestError, SlamSensorSettings } from "./slam.js";
|
|
5
6
|
/**
|
|
6
7
|
* Request reply
|
|
7
8
|
*
|
|
@@ -142,6 +143,16 @@ export interface SetMissionReq {
|
|
|
142
143
|
}
|
|
143
144
|
/** Response after setting a new mission. */
|
|
144
145
|
export interface SetMissionRep {
|
|
146
|
+
/**
|
|
147
|
+
* True when the mission was loaded. Drones without this field answer an empty message as soon
|
|
148
|
+
* as they have received the mission, before it is validated. Not accepted with no reason
|
|
149
|
+
* therefore only confirms receipt: wait for MissionStatusTel to show whether the mission loaded.
|
|
150
|
+
*/
|
|
151
|
+
accepted: boolean;
|
|
152
|
+
/** Why the mission was refused. */
|
|
153
|
+
reason: string;
|
|
154
|
+
/** Mission.load_id the drone gave the mission, when it was loaded. */
|
|
155
|
+
loadId: number;
|
|
145
156
|
}
|
|
146
157
|
/** Service request to the reference_generator to get the active mission. */
|
|
147
158
|
export interface GetMissionReq {
|
|
@@ -151,13 +162,56 @@ export interface GetMissionRep {
|
|
|
151
162
|
/** Active mission with waypoints. */
|
|
152
163
|
mission: Mission | undefined;
|
|
153
164
|
}
|
|
154
|
-
/**
|
|
165
|
+
/**
|
|
166
|
+
* Changes one instruction of the loaded mission. The mission is validated and
|
|
167
|
+
* planned again as a whole and Mission.revision increases. An instruction that
|
|
168
|
+
* has completed cannot be changed. Replacing or removing the instruction that
|
|
169
|
+
* is running stops it; a replacement starts from where the drone is.
|
|
170
|
+
*
|
|
171
|
+
* The change applies only to the mission load and revision the client edited.
|
|
172
|
+
* When load_id or revision differs from the loaded mission's, because the
|
|
173
|
+
* mission was replaced or changed since, the drone refuses it and changes nothing.
|
|
174
|
+
*/
|
|
155
175
|
export interface SetInstructionUpdateReq {
|
|
156
|
-
/** instruction that
|
|
157
|
-
|
|
176
|
+
/** Replace the instruction that has the same id. */
|
|
177
|
+
replace?: Instruction | undefined;
|
|
178
|
+
/** Add an instruction. */
|
|
179
|
+
insert?: InsertInstruction | undefined;
|
|
180
|
+
/** Remove the instruction with this id. */
|
|
181
|
+
removeId?: number | undefined;
|
|
182
|
+
/** Mission.load_id of the mission the client edited. */
|
|
183
|
+
loadId: number;
|
|
184
|
+
/** Mission.revision the client edited. */
|
|
185
|
+
revision: number;
|
|
158
186
|
}
|
|
159
187
|
/** Response after updating an instruction in the current mission. */
|
|
160
188
|
export interface SetInstructionUpdateRep {
|
|
189
|
+
/** True when the mission was changed. */
|
|
190
|
+
accepted: boolean;
|
|
191
|
+
/** Why the change was refused. */
|
|
192
|
+
reason: string;
|
|
193
|
+
/** Revision of the mission after the change. */
|
|
194
|
+
revision: number;
|
|
195
|
+
}
|
|
196
|
+
/** Replaces the mission rules. Rules run independently of missions. */
|
|
197
|
+
export interface SetMissionRulesReq {
|
|
198
|
+
/** The rules to run; an empty list clears them. */
|
|
199
|
+
rules: MissionRule[];
|
|
200
|
+
}
|
|
201
|
+
/** Response after setting the mission rules. */
|
|
202
|
+
export interface SetMissionRulesRep {
|
|
203
|
+
/** True when the rules were set. */
|
|
204
|
+
accepted: boolean;
|
|
205
|
+
/** Why the rules were refused. */
|
|
206
|
+
reason: string;
|
|
207
|
+
}
|
|
208
|
+
/** Get the mission rules. */
|
|
209
|
+
export interface GetMissionRulesReq {
|
|
210
|
+
}
|
|
211
|
+
/** The mission rules. */
|
|
212
|
+
export interface GetMissionRulesRep {
|
|
213
|
+
/** The rules currently set. */
|
|
214
|
+
rules: MissionRule[];
|
|
161
215
|
}
|
|
162
216
|
/** Set the heading mode used in dead reckoning. */
|
|
163
217
|
export interface SetHeadingModeReq {
|
|
@@ -191,6 +245,26 @@ export interface SetLogFrequencyRep {
|
|
|
191
245
|
/** True if message name valid and frequency successfully updated. */
|
|
192
246
|
success: boolean;
|
|
193
247
|
}
|
|
248
|
+
/** Request to reset the publishing frequency of a message to the drone's default. */
|
|
249
|
+
export interface ResetPubFrequencyReq {
|
|
250
|
+
/** Message name, f. ex. "AttitudeTel"; empty resets every message. */
|
|
251
|
+
messageType: string;
|
|
252
|
+
}
|
|
253
|
+
/** Response after resetting the publishing frequency. */
|
|
254
|
+
export interface ResetPubFrequencyRep {
|
|
255
|
+
/** True if the message name was valid and its frequency reset. */
|
|
256
|
+
success: boolean;
|
|
257
|
+
}
|
|
258
|
+
/** Request to reset the logging frequency of a message to the drone's default. */
|
|
259
|
+
export interface ResetLogFrequencyReq {
|
|
260
|
+
/** Message name, f. ex. "AttitudeTel"; empty resets every message. */
|
|
261
|
+
messageType: string;
|
|
262
|
+
}
|
|
263
|
+
/** Response after resetting the logging frequency. */
|
|
264
|
+
export interface ResetLogFrequencyRep {
|
|
265
|
+
/** True if the message name was valid and its frequency reset. */
|
|
266
|
+
success: boolean;
|
|
267
|
+
}
|
|
194
268
|
/** Request to get latest telemetry data */
|
|
195
269
|
export interface GetTelemetryReq {
|
|
196
270
|
/** Message name, f. ex. "AttitudeTel". */
|
|
@@ -297,6 +371,138 @@ export interface GetMultibeamColorFilterRep {
|
|
|
297
371
|
/** The current color filter. Empty rgb means none is set (grayscale). */
|
|
298
372
|
colorFilter: MultibeamColorFilter | undefined;
|
|
299
373
|
}
|
|
374
|
+
/**
|
|
375
|
+
* Request to catch up on the SLAM map.
|
|
376
|
+
*
|
|
377
|
+
* Nothing comes in the reply but what is coming: the SLAM publishes it on its own
|
|
378
|
+
* publisher, to the clients subscribed there. The SLAM keeps its latest map
|
|
379
|
+
* updates: when map_id is the current map and the updates after have_sequence are
|
|
380
|
+
* still kept, it publishes those again (SlamMapUpdateTel, as they were, so a client
|
|
381
|
+
* that has them already skips them by their sequence); otherwise it publishes the
|
|
382
|
+
* whole map (SlamMapTel, in parts when it is large).
|
|
383
|
+
*/
|
|
384
|
+
export interface GetSlamMapReq {
|
|
385
|
+
/** The map the client holds; 0 when it holds none. */
|
|
386
|
+
mapId: number;
|
|
387
|
+
/** The sequence of the last update the client applied to that map. */
|
|
388
|
+
haveSequence: number;
|
|
389
|
+
}
|
|
390
|
+
/** Response after asking to catch up on the SLAM map: what is published for it. */
|
|
391
|
+
export interface GetSlamMapRep {
|
|
392
|
+
/** True if the SLAM is running and answered. */
|
|
393
|
+
available: boolean;
|
|
394
|
+
/** The current map (0 when the SLAM has no map). */
|
|
395
|
+
mapId: number;
|
|
396
|
+
/**
|
|
397
|
+
* The client has the map at this sequence once it has what is published. The whole map may be one
|
|
398
|
+
* made earlier (its parts say their sequence): the updates after it are published again after it.
|
|
399
|
+
*/
|
|
400
|
+
sequence: number;
|
|
401
|
+
/**
|
|
402
|
+
* The updates from from_sequence to sequence are published again (none when from_sequence is past
|
|
403
|
+
* sequence: the client has the map already).
|
|
404
|
+
*/
|
|
405
|
+
fromSequence?: number | undefined;
|
|
406
|
+
/** The whole map is published, in this many SlamMapTel parts. */
|
|
407
|
+
partCount?: number | undefined;
|
|
408
|
+
}
|
|
409
|
+
/** Request to discard the SLAM map and start a new one from the current pose. */
|
|
410
|
+
export interface ResetSlamReq {
|
|
411
|
+
/**
|
|
412
|
+
* The map to discard: the SLAM resets only if it is still the current map, so that two clients
|
|
413
|
+
* asking at once start one new map, not two. 0 (map ids never are): only if the SLAM has no map yet.
|
|
414
|
+
*/
|
|
415
|
+
mapId: number;
|
|
416
|
+
}
|
|
417
|
+
/** Response after resetting the SLAM map. */
|
|
418
|
+
export interface ResetSlamRep {
|
|
419
|
+
/** True if the SLAM is running and answered. */
|
|
420
|
+
available: boolean;
|
|
421
|
+
/**
|
|
422
|
+
* Identifier of the map now (the new one, or the current one when the request's map_id was not
|
|
423
|
+
* the current map's); 0 when the SLAM has no map yet (it starts one with its next scan).
|
|
424
|
+
*/
|
|
425
|
+
mapId: number;
|
|
426
|
+
/** True if the map was discarded. */
|
|
427
|
+
reset: boolean;
|
|
428
|
+
/** Why the map was not discarded, when it was not. */
|
|
429
|
+
error: SlamRequestError;
|
|
430
|
+
}
|
|
431
|
+
/**
|
|
432
|
+
* Request to start or stop the SLAM.
|
|
433
|
+
*
|
|
434
|
+
* Starting switches the sensor on (for a sonar, its acoustics) and begins a new
|
|
435
|
+
* map from the current pose. Stopping switches the sensor off and keeps the map,
|
|
436
|
+
* so it can still be viewed. Asking for the state the SLAM is in already changes
|
|
437
|
+
* nothing (ResetSlamReq begins a new map). The SLAM reports its state in
|
|
438
|
+
* SlamStatusTel.
|
|
439
|
+
*/
|
|
440
|
+
export interface SetSlamActiveReq {
|
|
441
|
+
/** True to start the SLAM, false to stop it. */
|
|
442
|
+
active: boolean;
|
|
443
|
+
}
|
|
444
|
+
/** Response after starting or stopping the SLAM. */
|
|
445
|
+
export interface SetSlamActiveRep {
|
|
446
|
+
/** True if the SLAM is running and answered. */
|
|
447
|
+
available: boolean;
|
|
448
|
+
/** True if the SLAM is now mapping (false if its sensor did not switch on). */
|
|
449
|
+
active: boolean;
|
|
450
|
+
/** Why the SLAM is not in the state asked for, when it is not. */
|
|
451
|
+
error: SlamRequestError;
|
|
452
|
+
}
|
|
453
|
+
/**
|
|
454
|
+
* Request to start or stop recording the SLAM.
|
|
455
|
+
*
|
|
456
|
+
* A recording needs the SLAM to be mapping, and stopping the SLAM stops it. It is
|
|
457
|
+
* stored with the drone's other media (picture, video and multibeam recordings).
|
|
458
|
+
* Like a multibeam recording it holds the drone's DroneInfoTel, at its start and
|
|
459
|
+
* when it changes, which names the dive log it belongs with (log_name).
|
|
460
|
+
* Asking for the state the recording is in already changes nothing.
|
|
461
|
+
*/
|
|
462
|
+
export interface SetSlamRecordingReq {
|
|
463
|
+
/** True to start recording, false to stop. */
|
|
464
|
+
record: boolean;
|
|
465
|
+
/** Also the sensor's raw data, and the dive log faster, for running the SLAM offline. */
|
|
466
|
+
sensorData: boolean;
|
|
467
|
+
/** Where to store the recording. */
|
|
468
|
+
storageLocation: StorageLocation;
|
|
469
|
+
}
|
|
470
|
+
/** Response after starting or stopping a SLAM recording. */
|
|
471
|
+
export interface SetSlamRecordingRep {
|
|
472
|
+
/** True if the SLAM is running and answered. */
|
|
473
|
+
available: boolean;
|
|
474
|
+
/** The recording after the request. */
|
|
475
|
+
recording: SlamRecordingState | undefined;
|
|
476
|
+
/** Why the recording is not in the state asked for, when it is not. */
|
|
477
|
+
error: SlamRequestError;
|
|
478
|
+
}
|
|
479
|
+
/**
|
|
480
|
+
* Request to change the settings of a SLAM sensor.
|
|
481
|
+
*
|
|
482
|
+
* The settings go to the sensor named by sensor_id. Without one, they go to the
|
|
483
|
+
* SLAM's sensor of their kind when it has exactly one; with several, the request
|
|
484
|
+
* must name one (SLAM_REQUEST_ERROR_NO_SUCH_SENSOR otherwise). Settings left
|
|
485
|
+
* unspecified stay as they are. The map goes on at the resolution it was made
|
|
486
|
+
* with; the next new map (a start, or ResetSlamReq) takes the resolution the
|
|
487
|
+
* sensor's range then gives.
|
|
488
|
+
*/
|
|
489
|
+
export interface SetSlamSensorSettingsReq {
|
|
490
|
+
/** The settings to change. */
|
|
491
|
+
settings: SlamSensorSettings | undefined;
|
|
492
|
+
/** The sensor to change (SlamSensor.id); empty: the SLAM's only sensor of the settings' kind. */
|
|
493
|
+
sensorId: string;
|
|
494
|
+
}
|
|
495
|
+
/** Response after changing the settings of a SLAM sensor. */
|
|
496
|
+
export interface SetSlamSensorSettingsRep {
|
|
497
|
+
/** True if the SLAM is running and answered. */
|
|
498
|
+
available: boolean;
|
|
499
|
+
/** True if the sensor took the settings. */
|
|
500
|
+
applied: boolean;
|
|
501
|
+
/** The sensor's settings after the request. */
|
|
502
|
+
settings: SlamSensorSettings | undefined;
|
|
503
|
+
/** Why the settings were not applied, when they were not. */
|
|
504
|
+
error: SlamRequestError;
|
|
505
|
+
}
|
|
300
506
|
export declare const SetOverlayParametersReq: MessageFns<SetOverlayParametersReq>;
|
|
301
507
|
export declare const SetOverlayParametersRep: MessageFns<SetOverlayParametersRep>;
|
|
302
508
|
export declare const GetOverlayParametersReq: MessageFns<GetOverlayParametersReq>;
|
|
@@ -323,12 +529,20 @@ export declare const GetMissionReq: MessageFns<GetMissionReq>;
|
|
|
323
529
|
export declare const GetMissionRep: MessageFns<GetMissionRep>;
|
|
324
530
|
export declare const SetInstructionUpdateReq: MessageFns<SetInstructionUpdateReq>;
|
|
325
531
|
export declare const SetInstructionUpdateRep: MessageFns<SetInstructionUpdateRep>;
|
|
532
|
+
export declare const SetMissionRulesReq: MessageFns<SetMissionRulesReq>;
|
|
533
|
+
export declare const SetMissionRulesRep: MessageFns<SetMissionRulesRep>;
|
|
534
|
+
export declare const GetMissionRulesReq: MessageFns<GetMissionRulesReq>;
|
|
535
|
+
export declare const GetMissionRulesRep: MessageFns<GetMissionRulesRep>;
|
|
326
536
|
export declare const SetHeadingModeReq: MessageFns<SetHeadingModeReq>;
|
|
327
537
|
export declare const SetHeadingModeRep: MessageFns<SetHeadingModeRep>;
|
|
328
538
|
export declare const SetPubFrequencyReq: MessageFns<SetPubFrequencyReq>;
|
|
329
539
|
export declare const SetPubFrequencyRep: MessageFns<SetPubFrequencyRep>;
|
|
330
540
|
export declare const SetLogFrequencyReq: MessageFns<SetLogFrequencyReq>;
|
|
331
541
|
export declare const SetLogFrequencyRep: MessageFns<SetLogFrequencyRep>;
|
|
542
|
+
export declare const ResetPubFrequencyReq: MessageFns<ResetPubFrequencyReq>;
|
|
543
|
+
export declare const ResetPubFrequencyRep: MessageFns<ResetPubFrequencyRep>;
|
|
544
|
+
export declare const ResetLogFrequencyReq: MessageFns<ResetLogFrequencyReq>;
|
|
545
|
+
export declare const ResetLogFrequencyRep: MessageFns<ResetLogFrequencyRep>;
|
|
332
546
|
export declare const GetTelemetryReq: MessageFns<GetTelemetryReq>;
|
|
333
547
|
export declare const GetTelemetryRep: MessageFns<GetTelemetryRep>;
|
|
334
548
|
export declare const SetPersistentStorageSettingsReq: MessageFns<SetPersistentStorageSettingsReq>;
|
|
@@ -351,6 +565,16 @@ export declare const SetMultibeamColorFilterReq: MessageFns<SetMultibeamColorFil
|
|
|
351
565
|
export declare const SetMultibeamColorFilterRep: MessageFns<SetMultibeamColorFilterRep>;
|
|
352
566
|
export declare const GetMultibeamColorFilterReq: MessageFns<GetMultibeamColorFilterReq>;
|
|
353
567
|
export declare const GetMultibeamColorFilterRep: MessageFns<GetMultibeamColorFilterRep>;
|
|
568
|
+
export declare const GetSlamMapReq: MessageFns<GetSlamMapReq>;
|
|
569
|
+
export declare const GetSlamMapRep: MessageFns<GetSlamMapRep>;
|
|
570
|
+
export declare const ResetSlamReq: MessageFns<ResetSlamReq>;
|
|
571
|
+
export declare const ResetSlamRep: MessageFns<ResetSlamRep>;
|
|
572
|
+
export declare const SetSlamActiveReq: MessageFns<SetSlamActiveReq>;
|
|
573
|
+
export declare const SetSlamActiveRep: MessageFns<SetSlamActiveRep>;
|
|
574
|
+
export declare const SetSlamRecordingReq: MessageFns<SetSlamRecordingReq>;
|
|
575
|
+
export declare const SetSlamRecordingRep: MessageFns<SetSlamRecordingRep>;
|
|
576
|
+
export declare const SetSlamSensorSettingsReq: MessageFns<SetSlamSensorSettingsReq>;
|
|
577
|
+
export declare const SetSlamSensorSettingsRep: MessageFns<SetSlamSensorSettingsRep>;
|
|
354
578
|
type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
|
|
355
579
|
type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
|
|
356
580
|
[K in keyof T]?: DeepPartial<T[K]>;
|