@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/telemetry.d.ts
CHANGED
|
@@ -1,7 +1,8 @@
|
|
|
1
1
|
import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
|
|
2
2
|
import { AquaTrollProbeMetadata, AquaTrollSensorMetadataArray, AquaTrollSensorParametersArray } from "./aquatroll.js";
|
|
3
3
|
import { Altitude, Annotation, Attitude, Battery, BatteryBQ40Z50, CalibrationState, CameraPanTiltZoom, CanisterHumidity, CanisterTemperature, ConnectedClient, ControlForce, ControllerHealth, ControlMode, CpProbe, CPUInfo, CPUTemperature, Depth, DiveTime, DroneInfo, DvlVelocity, ErrorFlags, FilterMessage, ForwardDistance, GenericServo, GnssStatus, Gripper, GripperDiagnostics, GripperInfo, GuestPortCurrent, Imu, IperfStatus, KernelLogEntry, Laser, LaserDetection, LatLongPosition, Lights, LogEntry, MagneticDeclination, MarineSnowFilterFrames, MedusaSpectrometerData, ModelDetections, MultibeamConfig, MultibeamDiscovery, MultibeamPing, MultibeamServo, Notification, NStreamers, PositionEstimate, PowerCanister, RecordState, Reference, RemovableStorageDevice, SotState, StorageSpace, SurfaceUnitBatteryInfo, SurfaceUnitVersionInfo, SystemPerformanceInfo, SystemTime, ThicknessGauge, TiltAngle, TiltStabilizationState, TimeLapseState, WaterTemperature } from "./message_formats.js";
|
|
4
|
-
import { MissionStatus, ReferenceAutoPilot } from "./mission_planning.js";
|
|
4
|
+
import { InstructionResult, MissionRuleStatus, MissionStatus, ReferenceAutoPilot } from "./mission_planning.js";
|
|
5
|
+
import { SlamAiding, SlamMap, SlamMapFrame, SlamMapUpdate, SlamPoseEstimate, SlamRecordingState, SlamScan, SlamSensorStatus } from "./slam.js";
|
|
5
6
|
/**
|
|
6
7
|
* Telemetry
|
|
7
8
|
*
|
|
@@ -62,6 +63,21 @@ export interface NotificationTel {
|
|
|
62
63
|
/** Notification from the control system. */
|
|
63
64
|
notification: Notification | undefined;
|
|
64
65
|
}
|
|
66
|
+
/**
|
|
67
|
+
* Result of an instruction started with RunInstructionCtrl.
|
|
68
|
+
*
|
|
69
|
+
* Published when the instruction is accepted or rejected, and again when it completes, fails or
|
|
70
|
+
* is cancelled.
|
|
71
|
+
*/
|
|
72
|
+
export interface InstructionResultTel {
|
|
73
|
+
/** Result of the instruction. */
|
|
74
|
+
result: InstructionResult | undefined;
|
|
75
|
+
}
|
|
76
|
+
/** State of the mission rules. */
|
|
77
|
+
export interface MissionRulesTel {
|
|
78
|
+
/** One entry per rule. */
|
|
79
|
+
rules: MissionRuleStatus[];
|
|
80
|
+
}
|
|
65
81
|
/** Control force in all directions. */
|
|
66
82
|
export interface ControlForceTel {
|
|
67
83
|
/** Control force in all directions. */
|
|
@@ -443,6 +459,80 @@ export interface AnnotationTel {
|
|
|
443
459
|
/** The annotation that was added. */
|
|
444
460
|
annotation: Annotation | undefined;
|
|
445
461
|
}
|
|
462
|
+
/**
|
|
463
|
+
* SLAM estimate of its platform's pose (SlamMapFrame.platform: the drone's, each
|
|
464
|
+
* sensor on it at its mount, which the estimate carries; or, without a known
|
|
465
|
+
* mount, the sensor's own).
|
|
466
|
+
*
|
|
467
|
+
* Published for every scan on the SLAM publisher, not the main telemetry socket.
|
|
468
|
+
*/
|
|
469
|
+
export interface SlamPoseTel {
|
|
470
|
+
/** The pose estimate. */
|
|
471
|
+
estimate: SlamPoseEstimate | undefined;
|
|
472
|
+
}
|
|
473
|
+
/**
|
|
474
|
+
* A change to the SLAM map: new keyframes and points, or a corrected trajectory.
|
|
475
|
+
*
|
|
476
|
+
* Published on the SLAM publisher. A client applies the updates that follow the
|
|
477
|
+
* map it holds (SlamMapTel); one it missed it asks for again (GetSlamMapReq).
|
|
478
|
+
*/
|
|
479
|
+
export interface SlamMapUpdateTel {
|
|
480
|
+
/** The change. */
|
|
481
|
+
update: SlamMapUpdate | undefined;
|
|
482
|
+
}
|
|
483
|
+
/**
|
|
484
|
+
* The latest scan placed in the SLAM map.
|
|
485
|
+
*
|
|
486
|
+
* Published on the SLAM publisher for live display; not part of the map.
|
|
487
|
+
*/
|
|
488
|
+
export interface SlamScanTel {
|
|
489
|
+
/** The scan. */
|
|
490
|
+
scan: SlamScan | undefined;
|
|
491
|
+
}
|
|
492
|
+
/**
|
|
493
|
+
* The whole SLAM map, or a part of it (SlamMap.part).
|
|
494
|
+
*
|
|
495
|
+
* Published on the SLAM publisher when a client asks for it (GetSlamMapReq). A
|
|
496
|
+
* client subscribes, asks, keeps the updates that arrive meanwhile, and applies
|
|
497
|
+
* those that follow the map's sequence once it has all of its parts (put together
|
|
498
|
+
* as SlamMap says: repeated fields concatenated, every other field the first
|
|
499
|
+
* part's). A SLAM recording has the map at its start, and ends each map it holds
|
|
500
|
+
* with it.
|
|
501
|
+
*/
|
|
502
|
+
export interface SlamMapTel {
|
|
503
|
+
/** The map, or a part of it. */
|
|
504
|
+
map: SlamMap | undefined;
|
|
505
|
+
}
|
|
506
|
+
/**
|
|
507
|
+
* The SLAM's state.
|
|
508
|
+
*
|
|
509
|
+
* Published on the SLAM publisher once a second, and when it changes.
|
|
510
|
+
*/
|
|
511
|
+
export interface SlamStatusTel {
|
|
512
|
+
/** True while the SLAM is mapping: its sensors are on and scans are placed. */
|
|
513
|
+
active: boolean;
|
|
514
|
+
/** Identifier of the current map, 0 when the SLAM has no map. */
|
|
515
|
+
mapId: number;
|
|
516
|
+
/** The recording, when one runs or ran. */
|
|
517
|
+
recording: SlamRecordingState | undefined;
|
|
518
|
+
/** The sensors that feed the SLAM. */
|
|
519
|
+
sensors: SlamSensorStatus[];
|
|
520
|
+
/** True if the map holds as many points as it may: it is placed in, but grows no more. */
|
|
521
|
+
mapFull: boolean;
|
|
522
|
+
/** True if the SLAM corrects its trajectory with loop closures (it has a back end). */
|
|
523
|
+
loopClosure: boolean;
|
|
524
|
+
/** How the current map's frame lies in the world (unset before its first scan). */
|
|
525
|
+
frame: SlamMapFrame | undefined;
|
|
526
|
+
/**
|
|
527
|
+
* Sequence of the newest update of the current map (SlamMapUpdate.sequence), 0 for none: a client
|
|
528
|
+
* that has applied less of the current map has missed one, and catches up (GetSlamMapReq).
|
|
529
|
+
*/
|
|
530
|
+
sequence: number;
|
|
531
|
+
/** What other than its sensors the estimate rests on now. */
|
|
532
|
+
aiding: SlamAiding | undefined;
|
|
533
|
+
/** True if the SLAM's back end failed and was dropped: the current map has no more loop closures. */
|
|
534
|
+
backendFailed: boolean;
|
|
535
|
+
}
|
|
446
536
|
export declare const AttitudeTel: MessageFns<AttitudeTel>;
|
|
447
537
|
export declare const MagneticDeclinationTel: MessageFns<MagneticDeclinationTel>;
|
|
448
538
|
export declare const AltitudeTel: MessageFns<AltitudeTel>;
|
|
@@ -454,6 +544,8 @@ export declare const ReferenceTel: MessageFns<ReferenceTel>;
|
|
|
454
544
|
export declare const ReferenceAutoPilotTel: MessageFns<ReferenceAutoPilotTel>;
|
|
455
545
|
export declare const MissionStatusTel: MessageFns<MissionStatusTel>;
|
|
456
546
|
export declare const NotificationTel: MessageFns<NotificationTel>;
|
|
547
|
+
export declare const InstructionResultTel: MessageFns<InstructionResultTel>;
|
|
548
|
+
export declare const MissionRulesTel: MessageFns<MissionRulesTel>;
|
|
457
549
|
export declare const ControlForceTel: MessageFns<ControlForceTel>;
|
|
458
550
|
export declare const ControllerHealthTel: MessageFns<ControllerHealthTel>;
|
|
459
551
|
export declare const LightsTel: MessageFns<LightsTel>;
|
|
@@ -515,6 +607,11 @@ export declare const MarineSnowFilterTel: MessageFns<MarineSnowFilterTel>;
|
|
|
515
607
|
export declare const CameraPanTiltZoomTel: MessageFns<CameraPanTiltZoomTel>;
|
|
516
608
|
export declare const SotStateTel: MessageFns<SotStateTel>;
|
|
517
609
|
export declare const AnnotationTel: MessageFns<AnnotationTel>;
|
|
610
|
+
export declare const SlamPoseTel: MessageFns<SlamPoseTel>;
|
|
611
|
+
export declare const SlamMapUpdateTel: MessageFns<SlamMapUpdateTel>;
|
|
612
|
+
export declare const SlamScanTel: MessageFns<SlamScanTel>;
|
|
613
|
+
export declare const SlamMapTel: MessageFns<SlamMapTel>;
|
|
614
|
+
export declare const SlamStatusTel: MessageFns<SlamStatusTel>;
|
|
518
615
|
type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
|
|
519
616
|
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 {} ? {
|
|
520
617
|
[K in keyof T]?: DeepPartial<T[K]>;
|
package/dist/telemetry.js
CHANGED
|
@@ -7,7 +7,8 @@
|
|
|
7
7
|
import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
|
|
8
8
|
import { AquaTrollProbeMetadata, AquaTrollSensorMetadataArray, AquaTrollSensorParametersArray } from "./aquatroll.js";
|
|
9
9
|
import { Altitude, Annotation, Attitude, Battery, BatteryBQ40Z50, CalibrationState, CameraPanTiltZoom, CanisterHumidity, CanisterTemperature, ConnectedClient, ControlForce, ControllerHealth, ControlMode, CpProbe, CPUInfo, CPUTemperature, Depth, DiveTime, DroneInfo, DvlVelocity, ErrorFlags, FilterMessage, ForwardDistance, GenericServo, GnssStatus, Gripper, GripperDiagnostics, GripperInfo, GuestPortCurrent, Imu, IperfStatus, KernelLogEntry, Laser, LaserDetection, LatLongPosition, Lights, LogEntry, MagneticDeclination, MarineSnowFilterFrames, MedusaSpectrometerData, ModelDetections, MultibeamConfig, MultibeamDiscovery, MultibeamPing, MultibeamServo, Notification, NStreamers, PositionEstimate, PowerCanister, RecordState, Reference, RemovableStorageDevice, SotState, StorageSpace, SurfaceUnitBatteryInfo, SurfaceUnitVersionInfo, SystemPerformanceInfo, SystemTime, ThicknessGauge, TiltAngle, TiltStabilizationState, TimeLapseState, WaterTemperature, } from "./message_formats.js";
|
|
10
|
-
import { MissionStatus, ReferenceAutoPilot } from "./mission_planning.js";
|
|
10
|
+
import { InstructionResult, MissionRuleStatus, MissionStatus, ReferenceAutoPilot } from "./mission_planning.js";
|
|
11
|
+
import { SlamAiding, SlamMap, SlamMapFrame, SlamMapUpdate, SlamPoseEstimate, SlamRecordingState, SlamScan, SlamSensorStatus, } from "./slam.js";
|
|
11
12
|
function createBaseAttitudeTel() {
|
|
12
13
|
return { attitude: undefined };
|
|
13
14
|
}
|
|
@@ -601,6 +602,112 @@ export const NotificationTel = {
|
|
|
601
602
|
return message;
|
|
602
603
|
},
|
|
603
604
|
};
|
|
605
|
+
function createBaseInstructionResultTel() {
|
|
606
|
+
return { result: undefined };
|
|
607
|
+
}
|
|
608
|
+
export const InstructionResultTel = {
|
|
609
|
+
encode(message, writer = new BinaryWriter()) {
|
|
610
|
+
if (message.result !== undefined) {
|
|
611
|
+
InstructionResult.encode(message.result, writer.uint32(10).fork()).join();
|
|
612
|
+
}
|
|
613
|
+
return writer;
|
|
614
|
+
},
|
|
615
|
+
decode(input, length) {
|
|
616
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
617
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
618
|
+
const message = createBaseInstructionResultTel();
|
|
619
|
+
while (reader.pos < end) {
|
|
620
|
+
const tag = reader.uint32();
|
|
621
|
+
switch (tag >>> 3) {
|
|
622
|
+
case 1: {
|
|
623
|
+
if (tag !== 10) {
|
|
624
|
+
break;
|
|
625
|
+
}
|
|
626
|
+
message.result = InstructionResult.decode(reader, reader.uint32());
|
|
627
|
+
continue;
|
|
628
|
+
}
|
|
629
|
+
}
|
|
630
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
631
|
+
break;
|
|
632
|
+
}
|
|
633
|
+
reader.skip(tag & 7);
|
|
634
|
+
}
|
|
635
|
+
return message;
|
|
636
|
+
},
|
|
637
|
+
fromJSON(object) {
|
|
638
|
+
return { result: isSet(object.result) ? InstructionResult.fromJSON(object.result) : undefined };
|
|
639
|
+
},
|
|
640
|
+
toJSON(message) {
|
|
641
|
+
const obj = {};
|
|
642
|
+
if (message.result !== undefined) {
|
|
643
|
+
obj.result = InstructionResult.toJSON(message.result);
|
|
644
|
+
}
|
|
645
|
+
return obj;
|
|
646
|
+
},
|
|
647
|
+
create(base) {
|
|
648
|
+
return InstructionResultTel.fromPartial(base ?? {});
|
|
649
|
+
},
|
|
650
|
+
fromPartial(object) {
|
|
651
|
+
const message = createBaseInstructionResultTel();
|
|
652
|
+
message.result = (object.result !== undefined && object.result !== null)
|
|
653
|
+
? InstructionResult.fromPartial(object.result)
|
|
654
|
+
: undefined;
|
|
655
|
+
return message;
|
|
656
|
+
},
|
|
657
|
+
};
|
|
658
|
+
function createBaseMissionRulesTel() {
|
|
659
|
+
return { rules: [] };
|
|
660
|
+
}
|
|
661
|
+
export const MissionRulesTel = {
|
|
662
|
+
encode(message, writer = new BinaryWriter()) {
|
|
663
|
+
for (const v of message.rules) {
|
|
664
|
+
MissionRuleStatus.encode(v, writer.uint32(10).fork()).join();
|
|
665
|
+
}
|
|
666
|
+
return writer;
|
|
667
|
+
},
|
|
668
|
+
decode(input, length) {
|
|
669
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
670
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
671
|
+
const message = createBaseMissionRulesTel();
|
|
672
|
+
while (reader.pos < end) {
|
|
673
|
+
const tag = reader.uint32();
|
|
674
|
+
switch (tag >>> 3) {
|
|
675
|
+
case 1: {
|
|
676
|
+
if (tag !== 10) {
|
|
677
|
+
break;
|
|
678
|
+
}
|
|
679
|
+
message.rules.push(MissionRuleStatus.decode(reader, reader.uint32()));
|
|
680
|
+
continue;
|
|
681
|
+
}
|
|
682
|
+
}
|
|
683
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
684
|
+
break;
|
|
685
|
+
}
|
|
686
|
+
reader.skip(tag & 7);
|
|
687
|
+
}
|
|
688
|
+
return message;
|
|
689
|
+
},
|
|
690
|
+
fromJSON(object) {
|
|
691
|
+
return {
|
|
692
|
+
rules: gt.Array.isArray(object?.rules) ? object.rules.map((e) => MissionRuleStatus.fromJSON(e)) : [],
|
|
693
|
+
};
|
|
694
|
+
},
|
|
695
|
+
toJSON(message) {
|
|
696
|
+
const obj = {};
|
|
697
|
+
if (message.rules?.length) {
|
|
698
|
+
obj.rules = message.rules.map((e) => MissionRuleStatus.toJSON(e));
|
|
699
|
+
}
|
|
700
|
+
return obj;
|
|
701
|
+
},
|
|
702
|
+
create(base) {
|
|
703
|
+
return MissionRulesTel.fromPartial(base ?? {});
|
|
704
|
+
},
|
|
705
|
+
fromPartial(object) {
|
|
706
|
+
const message = createBaseMissionRulesTel();
|
|
707
|
+
message.rules = object.rules?.map((e) => MissionRuleStatus.fromPartial(e)) || [];
|
|
708
|
+
return message;
|
|
709
|
+
},
|
|
710
|
+
};
|
|
604
711
|
function createBaseControlForceTel() {
|
|
605
712
|
return { controlForce: undefined };
|
|
606
713
|
}
|
|
@@ -4057,6 +4164,419 @@ export const AnnotationTel = {
|
|
|
4057
4164
|
return message;
|
|
4058
4165
|
},
|
|
4059
4166
|
};
|
|
4167
|
+
function createBaseSlamPoseTel() {
|
|
4168
|
+
return { estimate: undefined };
|
|
4169
|
+
}
|
|
4170
|
+
export const SlamPoseTel = {
|
|
4171
|
+
encode(message, writer = new BinaryWriter()) {
|
|
4172
|
+
if (message.estimate !== undefined) {
|
|
4173
|
+
SlamPoseEstimate.encode(message.estimate, writer.uint32(10).fork()).join();
|
|
4174
|
+
}
|
|
4175
|
+
return writer;
|
|
4176
|
+
},
|
|
4177
|
+
decode(input, length) {
|
|
4178
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
4179
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
4180
|
+
const message = createBaseSlamPoseTel();
|
|
4181
|
+
while (reader.pos < end) {
|
|
4182
|
+
const tag = reader.uint32();
|
|
4183
|
+
switch (tag >>> 3) {
|
|
4184
|
+
case 1: {
|
|
4185
|
+
if (tag !== 10) {
|
|
4186
|
+
break;
|
|
4187
|
+
}
|
|
4188
|
+
message.estimate = SlamPoseEstimate.decode(reader, reader.uint32());
|
|
4189
|
+
continue;
|
|
4190
|
+
}
|
|
4191
|
+
}
|
|
4192
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
4193
|
+
break;
|
|
4194
|
+
}
|
|
4195
|
+
reader.skip(tag & 7);
|
|
4196
|
+
}
|
|
4197
|
+
return message;
|
|
4198
|
+
},
|
|
4199
|
+
fromJSON(object) {
|
|
4200
|
+
return { estimate: isSet(object.estimate) ? SlamPoseEstimate.fromJSON(object.estimate) : undefined };
|
|
4201
|
+
},
|
|
4202
|
+
toJSON(message) {
|
|
4203
|
+
const obj = {};
|
|
4204
|
+
if (message.estimate !== undefined) {
|
|
4205
|
+
obj.estimate = SlamPoseEstimate.toJSON(message.estimate);
|
|
4206
|
+
}
|
|
4207
|
+
return obj;
|
|
4208
|
+
},
|
|
4209
|
+
create(base) {
|
|
4210
|
+
return SlamPoseTel.fromPartial(base ?? {});
|
|
4211
|
+
},
|
|
4212
|
+
fromPartial(object) {
|
|
4213
|
+
const message = createBaseSlamPoseTel();
|
|
4214
|
+
message.estimate = (object.estimate !== undefined && object.estimate !== null)
|
|
4215
|
+
? SlamPoseEstimate.fromPartial(object.estimate)
|
|
4216
|
+
: undefined;
|
|
4217
|
+
return message;
|
|
4218
|
+
},
|
|
4219
|
+
};
|
|
4220
|
+
function createBaseSlamMapUpdateTel() {
|
|
4221
|
+
return { update: undefined };
|
|
4222
|
+
}
|
|
4223
|
+
export const SlamMapUpdateTel = {
|
|
4224
|
+
encode(message, writer = new BinaryWriter()) {
|
|
4225
|
+
if (message.update !== undefined) {
|
|
4226
|
+
SlamMapUpdate.encode(message.update, writer.uint32(10).fork()).join();
|
|
4227
|
+
}
|
|
4228
|
+
return writer;
|
|
4229
|
+
},
|
|
4230
|
+
decode(input, length) {
|
|
4231
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
4232
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
4233
|
+
const message = createBaseSlamMapUpdateTel();
|
|
4234
|
+
while (reader.pos < end) {
|
|
4235
|
+
const tag = reader.uint32();
|
|
4236
|
+
switch (tag >>> 3) {
|
|
4237
|
+
case 1: {
|
|
4238
|
+
if (tag !== 10) {
|
|
4239
|
+
break;
|
|
4240
|
+
}
|
|
4241
|
+
message.update = SlamMapUpdate.decode(reader, reader.uint32());
|
|
4242
|
+
continue;
|
|
4243
|
+
}
|
|
4244
|
+
}
|
|
4245
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
4246
|
+
break;
|
|
4247
|
+
}
|
|
4248
|
+
reader.skip(tag & 7);
|
|
4249
|
+
}
|
|
4250
|
+
return message;
|
|
4251
|
+
},
|
|
4252
|
+
fromJSON(object) {
|
|
4253
|
+
return { update: isSet(object.update) ? SlamMapUpdate.fromJSON(object.update) : undefined };
|
|
4254
|
+
},
|
|
4255
|
+
toJSON(message) {
|
|
4256
|
+
const obj = {};
|
|
4257
|
+
if (message.update !== undefined) {
|
|
4258
|
+
obj.update = SlamMapUpdate.toJSON(message.update);
|
|
4259
|
+
}
|
|
4260
|
+
return obj;
|
|
4261
|
+
},
|
|
4262
|
+
create(base) {
|
|
4263
|
+
return SlamMapUpdateTel.fromPartial(base ?? {});
|
|
4264
|
+
},
|
|
4265
|
+
fromPartial(object) {
|
|
4266
|
+
const message = createBaseSlamMapUpdateTel();
|
|
4267
|
+
message.update = (object.update !== undefined && object.update !== null)
|
|
4268
|
+
? SlamMapUpdate.fromPartial(object.update)
|
|
4269
|
+
: undefined;
|
|
4270
|
+
return message;
|
|
4271
|
+
},
|
|
4272
|
+
};
|
|
4273
|
+
function createBaseSlamScanTel() {
|
|
4274
|
+
return { scan: undefined };
|
|
4275
|
+
}
|
|
4276
|
+
export const SlamScanTel = {
|
|
4277
|
+
encode(message, writer = new BinaryWriter()) {
|
|
4278
|
+
if (message.scan !== undefined) {
|
|
4279
|
+
SlamScan.encode(message.scan, writer.uint32(10).fork()).join();
|
|
4280
|
+
}
|
|
4281
|
+
return writer;
|
|
4282
|
+
},
|
|
4283
|
+
decode(input, length) {
|
|
4284
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
4285
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
4286
|
+
const message = createBaseSlamScanTel();
|
|
4287
|
+
while (reader.pos < end) {
|
|
4288
|
+
const tag = reader.uint32();
|
|
4289
|
+
switch (tag >>> 3) {
|
|
4290
|
+
case 1: {
|
|
4291
|
+
if (tag !== 10) {
|
|
4292
|
+
break;
|
|
4293
|
+
}
|
|
4294
|
+
message.scan = SlamScan.decode(reader, reader.uint32());
|
|
4295
|
+
continue;
|
|
4296
|
+
}
|
|
4297
|
+
}
|
|
4298
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
4299
|
+
break;
|
|
4300
|
+
}
|
|
4301
|
+
reader.skip(tag & 7);
|
|
4302
|
+
}
|
|
4303
|
+
return message;
|
|
4304
|
+
},
|
|
4305
|
+
fromJSON(object) {
|
|
4306
|
+
return { scan: isSet(object.scan) ? SlamScan.fromJSON(object.scan) : undefined };
|
|
4307
|
+
},
|
|
4308
|
+
toJSON(message) {
|
|
4309
|
+
const obj = {};
|
|
4310
|
+
if (message.scan !== undefined) {
|
|
4311
|
+
obj.scan = SlamScan.toJSON(message.scan);
|
|
4312
|
+
}
|
|
4313
|
+
return obj;
|
|
4314
|
+
},
|
|
4315
|
+
create(base) {
|
|
4316
|
+
return SlamScanTel.fromPartial(base ?? {});
|
|
4317
|
+
},
|
|
4318
|
+
fromPartial(object) {
|
|
4319
|
+
const message = createBaseSlamScanTel();
|
|
4320
|
+
message.scan = (object.scan !== undefined && object.scan !== null) ? SlamScan.fromPartial(object.scan) : undefined;
|
|
4321
|
+
return message;
|
|
4322
|
+
},
|
|
4323
|
+
};
|
|
4324
|
+
function createBaseSlamMapTel() {
|
|
4325
|
+
return { map: undefined };
|
|
4326
|
+
}
|
|
4327
|
+
export const SlamMapTel = {
|
|
4328
|
+
encode(message, writer = new BinaryWriter()) {
|
|
4329
|
+
if (message.map !== undefined) {
|
|
4330
|
+
SlamMap.encode(message.map, writer.uint32(10).fork()).join();
|
|
4331
|
+
}
|
|
4332
|
+
return writer;
|
|
4333
|
+
},
|
|
4334
|
+
decode(input, length) {
|
|
4335
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
4336
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
4337
|
+
const message = createBaseSlamMapTel();
|
|
4338
|
+
while (reader.pos < end) {
|
|
4339
|
+
const tag = reader.uint32();
|
|
4340
|
+
switch (tag >>> 3) {
|
|
4341
|
+
case 1: {
|
|
4342
|
+
if (tag !== 10) {
|
|
4343
|
+
break;
|
|
4344
|
+
}
|
|
4345
|
+
message.map = SlamMap.decode(reader, reader.uint32());
|
|
4346
|
+
continue;
|
|
4347
|
+
}
|
|
4348
|
+
}
|
|
4349
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
4350
|
+
break;
|
|
4351
|
+
}
|
|
4352
|
+
reader.skip(tag & 7);
|
|
4353
|
+
}
|
|
4354
|
+
return message;
|
|
4355
|
+
},
|
|
4356
|
+
fromJSON(object) {
|
|
4357
|
+
return { map: isSet(object.map) ? SlamMap.fromJSON(object.map) : undefined };
|
|
4358
|
+
},
|
|
4359
|
+
toJSON(message) {
|
|
4360
|
+
const obj = {};
|
|
4361
|
+
if (message.map !== undefined) {
|
|
4362
|
+
obj.map = SlamMap.toJSON(message.map);
|
|
4363
|
+
}
|
|
4364
|
+
return obj;
|
|
4365
|
+
},
|
|
4366
|
+
create(base) {
|
|
4367
|
+
return SlamMapTel.fromPartial(base ?? {});
|
|
4368
|
+
},
|
|
4369
|
+
fromPartial(object) {
|
|
4370
|
+
const message = createBaseSlamMapTel();
|
|
4371
|
+
message.map = (object.map !== undefined && object.map !== null) ? SlamMap.fromPartial(object.map) : undefined;
|
|
4372
|
+
return message;
|
|
4373
|
+
},
|
|
4374
|
+
};
|
|
4375
|
+
function createBaseSlamStatusTel() {
|
|
4376
|
+
return {
|
|
4377
|
+
active: false,
|
|
4378
|
+
mapId: 0,
|
|
4379
|
+
recording: undefined,
|
|
4380
|
+
sensors: [],
|
|
4381
|
+
mapFull: false,
|
|
4382
|
+
loopClosure: false,
|
|
4383
|
+
frame: undefined,
|
|
4384
|
+
sequence: 0,
|
|
4385
|
+
aiding: undefined,
|
|
4386
|
+
backendFailed: false,
|
|
4387
|
+
};
|
|
4388
|
+
}
|
|
4389
|
+
export const SlamStatusTel = {
|
|
4390
|
+
encode(message, writer = new BinaryWriter()) {
|
|
4391
|
+
if (message.active !== false) {
|
|
4392
|
+
writer.uint32(8).bool(message.active);
|
|
4393
|
+
}
|
|
4394
|
+
if (message.mapId !== 0) {
|
|
4395
|
+
writer.uint32(16).uint32(message.mapId);
|
|
4396
|
+
}
|
|
4397
|
+
if (message.recording !== undefined) {
|
|
4398
|
+
SlamRecordingState.encode(message.recording, writer.uint32(26).fork()).join();
|
|
4399
|
+
}
|
|
4400
|
+
for (const v of message.sensors) {
|
|
4401
|
+
SlamSensorStatus.encode(v, writer.uint32(34).fork()).join();
|
|
4402
|
+
}
|
|
4403
|
+
if (message.mapFull !== false) {
|
|
4404
|
+
writer.uint32(40).bool(message.mapFull);
|
|
4405
|
+
}
|
|
4406
|
+
if (message.loopClosure !== false) {
|
|
4407
|
+
writer.uint32(48).bool(message.loopClosure);
|
|
4408
|
+
}
|
|
4409
|
+
if (message.frame !== undefined) {
|
|
4410
|
+
SlamMapFrame.encode(message.frame, writer.uint32(58).fork()).join();
|
|
4411
|
+
}
|
|
4412
|
+
if (message.sequence !== 0) {
|
|
4413
|
+
writer.uint32(64).uint64(message.sequence);
|
|
4414
|
+
}
|
|
4415
|
+
if (message.aiding !== undefined) {
|
|
4416
|
+
SlamAiding.encode(message.aiding, writer.uint32(74).fork()).join();
|
|
4417
|
+
}
|
|
4418
|
+
if (message.backendFailed !== false) {
|
|
4419
|
+
writer.uint32(80).bool(message.backendFailed);
|
|
4420
|
+
}
|
|
4421
|
+
return writer;
|
|
4422
|
+
},
|
|
4423
|
+
decode(input, length) {
|
|
4424
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
4425
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
4426
|
+
const message = createBaseSlamStatusTel();
|
|
4427
|
+
while (reader.pos < end) {
|
|
4428
|
+
const tag = reader.uint32();
|
|
4429
|
+
switch (tag >>> 3) {
|
|
4430
|
+
case 1: {
|
|
4431
|
+
if (tag !== 8) {
|
|
4432
|
+
break;
|
|
4433
|
+
}
|
|
4434
|
+
message.active = reader.bool();
|
|
4435
|
+
continue;
|
|
4436
|
+
}
|
|
4437
|
+
case 2: {
|
|
4438
|
+
if (tag !== 16) {
|
|
4439
|
+
break;
|
|
4440
|
+
}
|
|
4441
|
+
message.mapId = reader.uint32();
|
|
4442
|
+
continue;
|
|
4443
|
+
}
|
|
4444
|
+
case 3: {
|
|
4445
|
+
if (tag !== 26) {
|
|
4446
|
+
break;
|
|
4447
|
+
}
|
|
4448
|
+
message.recording = SlamRecordingState.decode(reader, reader.uint32());
|
|
4449
|
+
continue;
|
|
4450
|
+
}
|
|
4451
|
+
case 4: {
|
|
4452
|
+
if (tag !== 34) {
|
|
4453
|
+
break;
|
|
4454
|
+
}
|
|
4455
|
+
message.sensors.push(SlamSensorStatus.decode(reader, reader.uint32()));
|
|
4456
|
+
continue;
|
|
4457
|
+
}
|
|
4458
|
+
case 5: {
|
|
4459
|
+
if (tag !== 40) {
|
|
4460
|
+
break;
|
|
4461
|
+
}
|
|
4462
|
+
message.mapFull = reader.bool();
|
|
4463
|
+
continue;
|
|
4464
|
+
}
|
|
4465
|
+
case 6: {
|
|
4466
|
+
if (tag !== 48) {
|
|
4467
|
+
break;
|
|
4468
|
+
}
|
|
4469
|
+
message.loopClosure = reader.bool();
|
|
4470
|
+
continue;
|
|
4471
|
+
}
|
|
4472
|
+
case 7: {
|
|
4473
|
+
if (tag !== 58) {
|
|
4474
|
+
break;
|
|
4475
|
+
}
|
|
4476
|
+
message.frame = SlamMapFrame.decode(reader, reader.uint32());
|
|
4477
|
+
continue;
|
|
4478
|
+
}
|
|
4479
|
+
case 8: {
|
|
4480
|
+
if (tag !== 64) {
|
|
4481
|
+
break;
|
|
4482
|
+
}
|
|
4483
|
+
message.sequence = longToNumber(reader.uint64());
|
|
4484
|
+
continue;
|
|
4485
|
+
}
|
|
4486
|
+
case 9: {
|
|
4487
|
+
if (tag !== 74) {
|
|
4488
|
+
break;
|
|
4489
|
+
}
|
|
4490
|
+
message.aiding = SlamAiding.decode(reader, reader.uint32());
|
|
4491
|
+
continue;
|
|
4492
|
+
}
|
|
4493
|
+
case 10: {
|
|
4494
|
+
if (tag !== 80) {
|
|
4495
|
+
break;
|
|
4496
|
+
}
|
|
4497
|
+
message.backendFailed = reader.bool();
|
|
4498
|
+
continue;
|
|
4499
|
+
}
|
|
4500
|
+
}
|
|
4501
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
4502
|
+
break;
|
|
4503
|
+
}
|
|
4504
|
+
reader.skip(tag & 7);
|
|
4505
|
+
}
|
|
4506
|
+
return message;
|
|
4507
|
+
},
|
|
4508
|
+
fromJSON(object) {
|
|
4509
|
+
return {
|
|
4510
|
+
active: isSet(object.active) ? gt.Boolean(object.active) : false,
|
|
4511
|
+
mapId: isSet(object.mapId) ? gt.Number(object.mapId) : 0,
|
|
4512
|
+
recording: isSet(object.recording) ? SlamRecordingState.fromJSON(object.recording) : undefined,
|
|
4513
|
+
sensors: gt.Array.isArray(object?.sensors) ? object.sensors.map((e) => SlamSensorStatus.fromJSON(e)) : [],
|
|
4514
|
+
mapFull: isSet(object.mapFull) ? gt.Boolean(object.mapFull) : false,
|
|
4515
|
+
loopClosure: isSet(object.loopClosure) ? gt.Boolean(object.loopClosure) : false,
|
|
4516
|
+
frame: isSet(object.frame) ? SlamMapFrame.fromJSON(object.frame) : undefined,
|
|
4517
|
+
sequence: isSet(object.sequence) ? gt.Number(object.sequence) : 0,
|
|
4518
|
+
aiding: isSet(object.aiding) ? SlamAiding.fromJSON(object.aiding) : undefined,
|
|
4519
|
+
backendFailed: isSet(object.backendFailed) ? gt.Boolean(object.backendFailed) : false,
|
|
4520
|
+
};
|
|
4521
|
+
},
|
|
4522
|
+
toJSON(message) {
|
|
4523
|
+
const obj = {};
|
|
4524
|
+
if (message.active !== false) {
|
|
4525
|
+
obj.active = message.active;
|
|
4526
|
+
}
|
|
4527
|
+
if (message.mapId !== 0) {
|
|
4528
|
+
obj.mapId = Math.round(message.mapId);
|
|
4529
|
+
}
|
|
4530
|
+
if (message.recording !== undefined) {
|
|
4531
|
+
obj.recording = SlamRecordingState.toJSON(message.recording);
|
|
4532
|
+
}
|
|
4533
|
+
if (message.sensors?.length) {
|
|
4534
|
+
obj.sensors = message.sensors.map((e) => SlamSensorStatus.toJSON(e));
|
|
4535
|
+
}
|
|
4536
|
+
if (message.mapFull !== false) {
|
|
4537
|
+
obj.mapFull = message.mapFull;
|
|
4538
|
+
}
|
|
4539
|
+
if (message.loopClosure !== false) {
|
|
4540
|
+
obj.loopClosure = message.loopClosure;
|
|
4541
|
+
}
|
|
4542
|
+
if (message.frame !== undefined) {
|
|
4543
|
+
obj.frame = SlamMapFrame.toJSON(message.frame);
|
|
4544
|
+
}
|
|
4545
|
+
if (message.sequence !== 0) {
|
|
4546
|
+
obj.sequence = Math.round(message.sequence);
|
|
4547
|
+
}
|
|
4548
|
+
if (message.aiding !== undefined) {
|
|
4549
|
+
obj.aiding = SlamAiding.toJSON(message.aiding);
|
|
4550
|
+
}
|
|
4551
|
+
if (message.backendFailed !== false) {
|
|
4552
|
+
obj.backendFailed = message.backendFailed;
|
|
4553
|
+
}
|
|
4554
|
+
return obj;
|
|
4555
|
+
},
|
|
4556
|
+
create(base) {
|
|
4557
|
+
return SlamStatusTel.fromPartial(base ?? {});
|
|
4558
|
+
},
|
|
4559
|
+
fromPartial(object) {
|
|
4560
|
+
const message = createBaseSlamStatusTel();
|
|
4561
|
+
message.active = object.active ?? false;
|
|
4562
|
+
message.mapId = object.mapId ?? 0;
|
|
4563
|
+
message.recording = (object.recording !== undefined && object.recording !== null)
|
|
4564
|
+
? SlamRecordingState.fromPartial(object.recording)
|
|
4565
|
+
: undefined;
|
|
4566
|
+
message.sensors = object.sensors?.map((e) => SlamSensorStatus.fromPartial(e)) || [];
|
|
4567
|
+
message.mapFull = object.mapFull ?? false;
|
|
4568
|
+
message.loopClosure = object.loopClosure ?? false;
|
|
4569
|
+
message.frame = (object.frame !== undefined && object.frame !== null)
|
|
4570
|
+
? SlamMapFrame.fromPartial(object.frame)
|
|
4571
|
+
: undefined;
|
|
4572
|
+
message.sequence = object.sequence ?? 0;
|
|
4573
|
+
message.aiding = (object.aiding !== undefined && object.aiding !== null)
|
|
4574
|
+
? SlamAiding.fromPartial(object.aiding)
|
|
4575
|
+
: undefined;
|
|
4576
|
+
message.backendFailed = object.backendFailed ?? false;
|
|
4577
|
+
return message;
|
|
4578
|
+
},
|
|
4579
|
+
};
|
|
4060
4580
|
const gt = (() => {
|
|
4061
4581
|
if (typeof globalThis !== "undefined") {
|
|
4062
4582
|
return globalThis;
|
|
@@ -4072,6 +4592,16 @@ const gt = (() => {
|
|
|
4072
4592
|
}
|
|
4073
4593
|
throw "Unable to locate global object";
|
|
4074
4594
|
})();
|
|
4595
|
+
function longToNumber(int64) {
|
|
4596
|
+
const num = gt.Number(int64.toString());
|
|
4597
|
+
if (num > gt.Number.MAX_SAFE_INTEGER) {
|
|
4598
|
+
throw new gt.Error("Value is larger than Number.MAX_SAFE_INTEGER");
|
|
4599
|
+
}
|
|
4600
|
+
if (num < gt.Number.MIN_SAFE_INTEGER) {
|
|
4601
|
+
throw new gt.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
|
|
4602
|
+
}
|
|
4603
|
+
return num;
|
|
4604
|
+
}
|
|
4075
4605
|
function isSet(value) {
|
|
4076
4606
|
return value !== null && value !== undefined;
|
|
4077
4607
|
}
|