@blueyerobotics/protocol-definitions 3.4.0-618bf0b0 → 3.4.0-sonar3d-slam.4e329580
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/message_formats.d.ts +510 -2
- package/dist/message_formats.js +11290 -8463
- package/dist/req_rep.d.ts +120 -1
- package/dist/req_rep.js +791 -1
- package/dist/telemetry.d.ts +78 -1
- package/dist/telemetry.js +419 -1
- package/package.json +1 -1
package/dist/req_rep.js
CHANGED
|
@@ -6,7 +6,7 @@
|
|
|
6
6
|
/* eslint-disable */
|
|
7
7
|
import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
|
|
8
8
|
import { Any } from "./google/protobuf/any.js";
|
|
9
|
-
import { Battery, cameraFromJSON, CameraParameters, cameraToJSON, ClientInfo, ConnectedClient, CvModelInfo, headingModeFromJSON, headingModeToJSON, MultibeamColorFilter, OverlayParameters, PersistentStorageSettings, SystemTime, } from "./message_formats.js";
|
|
9
|
+
import { Battery, cameraFromJSON, CameraParameters, cameraToJSON, ClientInfo, ConnectedClient, CvModelInfo, headingModeFromJSON, headingModeToJSON, MultibeamColorFilter, OverlayParameters, PersistentStorageSettings, SlamRecordingState, SlamSensorSettings, storageLocationFromJSON, storageLocationToJSON, SystemTime, } from "./message_formats.js";
|
|
10
10
|
import { Instruction, Mission } from "./mission_planning.js";
|
|
11
11
|
function createBaseSetOverlayParametersReq() {
|
|
12
12
|
return { overlayParameters: undefined };
|
|
@@ -1624,6 +1624,210 @@ export const SetLogFrequencyRep = {
|
|
|
1624
1624
|
return message;
|
|
1625
1625
|
},
|
|
1626
1626
|
};
|
|
1627
|
+
function createBaseResetPubFrequencyReq() {
|
|
1628
|
+
return { messageType: "" };
|
|
1629
|
+
}
|
|
1630
|
+
export const ResetPubFrequencyReq = {
|
|
1631
|
+
encode(message, writer = new BinaryWriter()) {
|
|
1632
|
+
if (message.messageType !== "") {
|
|
1633
|
+
writer.uint32(10).string(message.messageType);
|
|
1634
|
+
}
|
|
1635
|
+
return writer;
|
|
1636
|
+
},
|
|
1637
|
+
decode(input, length) {
|
|
1638
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
1639
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1640
|
+
const message = createBaseResetPubFrequencyReq();
|
|
1641
|
+
while (reader.pos < end) {
|
|
1642
|
+
const tag = reader.uint32();
|
|
1643
|
+
switch (tag >>> 3) {
|
|
1644
|
+
case 1: {
|
|
1645
|
+
if (tag !== 10) {
|
|
1646
|
+
break;
|
|
1647
|
+
}
|
|
1648
|
+
message.messageType = reader.string();
|
|
1649
|
+
continue;
|
|
1650
|
+
}
|
|
1651
|
+
}
|
|
1652
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
1653
|
+
break;
|
|
1654
|
+
}
|
|
1655
|
+
reader.skip(tag & 7);
|
|
1656
|
+
}
|
|
1657
|
+
return message;
|
|
1658
|
+
},
|
|
1659
|
+
fromJSON(object) {
|
|
1660
|
+
return { messageType: isSet(object.messageType) ? gt.String(object.messageType) : "" };
|
|
1661
|
+
},
|
|
1662
|
+
toJSON(message) {
|
|
1663
|
+
const obj = {};
|
|
1664
|
+
if (message.messageType !== "") {
|
|
1665
|
+
obj.messageType = message.messageType;
|
|
1666
|
+
}
|
|
1667
|
+
return obj;
|
|
1668
|
+
},
|
|
1669
|
+
create(base) {
|
|
1670
|
+
return ResetPubFrequencyReq.fromPartial(base ?? {});
|
|
1671
|
+
},
|
|
1672
|
+
fromPartial(object) {
|
|
1673
|
+
const message = createBaseResetPubFrequencyReq();
|
|
1674
|
+
message.messageType = object.messageType ?? "";
|
|
1675
|
+
return message;
|
|
1676
|
+
},
|
|
1677
|
+
};
|
|
1678
|
+
function createBaseResetPubFrequencyRep() {
|
|
1679
|
+
return { success: false };
|
|
1680
|
+
}
|
|
1681
|
+
export const ResetPubFrequencyRep = {
|
|
1682
|
+
encode(message, writer = new BinaryWriter()) {
|
|
1683
|
+
if (message.success !== false) {
|
|
1684
|
+
writer.uint32(8).bool(message.success);
|
|
1685
|
+
}
|
|
1686
|
+
return writer;
|
|
1687
|
+
},
|
|
1688
|
+
decode(input, length) {
|
|
1689
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
1690
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1691
|
+
const message = createBaseResetPubFrequencyRep();
|
|
1692
|
+
while (reader.pos < end) {
|
|
1693
|
+
const tag = reader.uint32();
|
|
1694
|
+
switch (tag >>> 3) {
|
|
1695
|
+
case 1: {
|
|
1696
|
+
if (tag !== 8) {
|
|
1697
|
+
break;
|
|
1698
|
+
}
|
|
1699
|
+
message.success = reader.bool();
|
|
1700
|
+
continue;
|
|
1701
|
+
}
|
|
1702
|
+
}
|
|
1703
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
1704
|
+
break;
|
|
1705
|
+
}
|
|
1706
|
+
reader.skip(tag & 7);
|
|
1707
|
+
}
|
|
1708
|
+
return message;
|
|
1709
|
+
},
|
|
1710
|
+
fromJSON(object) {
|
|
1711
|
+
return { success: isSet(object.success) ? gt.Boolean(object.success) : false };
|
|
1712
|
+
},
|
|
1713
|
+
toJSON(message) {
|
|
1714
|
+
const obj = {};
|
|
1715
|
+
if (message.success !== false) {
|
|
1716
|
+
obj.success = message.success;
|
|
1717
|
+
}
|
|
1718
|
+
return obj;
|
|
1719
|
+
},
|
|
1720
|
+
create(base) {
|
|
1721
|
+
return ResetPubFrequencyRep.fromPartial(base ?? {});
|
|
1722
|
+
},
|
|
1723
|
+
fromPartial(object) {
|
|
1724
|
+
const message = createBaseResetPubFrequencyRep();
|
|
1725
|
+
message.success = object.success ?? false;
|
|
1726
|
+
return message;
|
|
1727
|
+
},
|
|
1728
|
+
};
|
|
1729
|
+
function createBaseResetLogFrequencyReq() {
|
|
1730
|
+
return { messageType: "" };
|
|
1731
|
+
}
|
|
1732
|
+
export const ResetLogFrequencyReq = {
|
|
1733
|
+
encode(message, writer = new BinaryWriter()) {
|
|
1734
|
+
if (message.messageType !== "") {
|
|
1735
|
+
writer.uint32(10).string(message.messageType);
|
|
1736
|
+
}
|
|
1737
|
+
return writer;
|
|
1738
|
+
},
|
|
1739
|
+
decode(input, length) {
|
|
1740
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
1741
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1742
|
+
const message = createBaseResetLogFrequencyReq();
|
|
1743
|
+
while (reader.pos < end) {
|
|
1744
|
+
const tag = reader.uint32();
|
|
1745
|
+
switch (tag >>> 3) {
|
|
1746
|
+
case 1: {
|
|
1747
|
+
if (tag !== 10) {
|
|
1748
|
+
break;
|
|
1749
|
+
}
|
|
1750
|
+
message.messageType = reader.string();
|
|
1751
|
+
continue;
|
|
1752
|
+
}
|
|
1753
|
+
}
|
|
1754
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
1755
|
+
break;
|
|
1756
|
+
}
|
|
1757
|
+
reader.skip(tag & 7);
|
|
1758
|
+
}
|
|
1759
|
+
return message;
|
|
1760
|
+
},
|
|
1761
|
+
fromJSON(object) {
|
|
1762
|
+
return { messageType: isSet(object.messageType) ? gt.String(object.messageType) : "" };
|
|
1763
|
+
},
|
|
1764
|
+
toJSON(message) {
|
|
1765
|
+
const obj = {};
|
|
1766
|
+
if (message.messageType !== "") {
|
|
1767
|
+
obj.messageType = message.messageType;
|
|
1768
|
+
}
|
|
1769
|
+
return obj;
|
|
1770
|
+
},
|
|
1771
|
+
create(base) {
|
|
1772
|
+
return ResetLogFrequencyReq.fromPartial(base ?? {});
|
|
1773
|
+
},
|
|
1774
|
+
fromPartial(object) {
|
|
1775
|
+
const message = createBaseResetLogFrequencyReq();
|
|
1776
|
+
message.messageType = object.messageType ?? "";
|
|
1777
|
+
return message;
|
|
1778
|
+
},
|
|
1779
|
+
};
|
|
1780
|
+
function createBaseResetLogFrequencyRep() {
|
|
1781
|
+
return { success: false };
|
|
1782
|
+
}
|
|
1783
|
+
export const ResetLogFrequencyRep = {
|
|
1784
|
+
encode(message, writer = new BinaryWriter()) {
|
|
1785
|
+
if (message.success !== false) {
|
|
1786
|
+
writer.uint32(8).bool(message.success);
|
|
1787
|
+
}
|
|
1788
|
+
return writer;
|
|
1789
|
+
},
|
|
1790
|
+
decode(input, length) {
|
|
1791
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
1792
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1793
|
+
const message = createBaseResetLogFrequencyRep();
|
|
1794
|
+
while (reader.pos < end) {
|
|
1795
|
+
const tag = reader.uint32();
|
|
1796
|
+
switch (tag >>> 3) {
|
|
1797
|
+
case 1: {
|
|
1798
|
+
if (tag !== 8) {
|
|
1799
|
+
break;
|
|
1800
|
+
}
|
|
1801
|
+
message.success = reader.bool();
|
|
1802
|
+
continue;
|
|
1803
|
+
}
|
|
1804
|
+
}
|
|
1805
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
1806
|
+
break;
|
|
1807
|
+
}
|
|
1808
|
+
reader.skip(tag & 7);
|
|
1809
|
+
}
|
|
1810
|
+
return message;
|
|
1811
|
+
},
|
|
1812
|
+
fromJSON(object) {
|
|
1813
|
+
return { success: isSet(object.success) ? gt.Boolean(object.success) : false };
|
|
1814
|
+
},
|
|
1815
|
+
toJSON(message) {
|
|
1816
|
+
const obj = {};
|
|
1817
|
+
if (message.success !== false) {
|
|
1818
|
+
obj.success = message.success;
|
|
1819
|
+
}
|
|
1820
|
+
return obj;
|
|
1821
|
+
},
|
|
1822
|
+
create(base) {
|
|
1823
|
+
return ResetLogFrequencyRep.fromPartial(base ?? {});
|
|
1824
|
+
},
|
|
1825
|
+
fromPartial(object) {
|
|
1826
|
+
const message = createBaseResetLogFrequencyRep();
|
|
1827
|
+
message.success = object.success ?? false;
|
|
1828
|
+
return message;
|
|
1829
|
+
},
|
|
1830
|
+
};
|
|
1627
1831
|
function createBaseGetTelemetryReq() {
|
|
1628
1832
|
return { messageType: "" };
|
|
1629
1833
|
}
|
|
@@ -2701,6 +2905,592 @@ export const GetMultibeamColorFilterRep = {
|
|
|
2701
2905
|
return message;
|
|
2702
2906
|
},
|
|
2703
2907
|
};
|
|
2908
|
+
function createBaseGetSlamMapReq() {
|
|
2909
|
+
return {};
|
|
2910
|
+
}
|
|
2911
|
+
export const GetSlamMapReq = {
|
|
2912
|
+
encode(_, writer = new BinaryWriter()) {
|
|
2913
|
+
return writer;
|
|
2914
|
+
},
|
|
2915
|
+
decode(input, length) {
|
|
2916
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2917
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2918
|
+
const message = createBaseGetSlamMapReq();
|
|
2919
|
+
while (reader.pos < end) {
|
|
2920
|
+
const tag = reader.uint32();
|
|
2921
|
+
switch (tag >>> 3) {
|
|
2922
|
+
}
|
|
2923
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2924
|
+
break;
|
|
2925
|
+
}
|
|
2926
|
+
reader.skip(tag & 7);
|
|
2927
|
+
}
|
|
2928
|
+
return message;
|
|
2929
|
+
},
|
|
2930
|
+
fromJSON(_) {
|
|
2931
|
+
return {};
|
|
2932
|
+
},
|
|
2933
|
+
toJSON(_) {
|
|
2934
|
+
const obj = {};
|
|
2935
|
+
return obj;
|
|
2936
|
+
},
|
|
2937
|
+
create(base) {
|
|
2938
|
+
return GetSlamMapReq.fromPartial(base ?? {});
|
|
2939
|
+
},
|
|
2940
|
+
fromPartial(_) {
|
|
2941
|
+
const message = createBaseGetSlamMapReq();
|
|
2942
|
+
return message;
|
|
2943
|
+
},
|
|
2944
|
+
};
|
|
2945
|
+
function createBaseGetSlamMapRep() {
|
|
2946
|
+
return { available: false };
|
|
2947
|
+
}
|
|
2948
|
+
export const GetSlamMapRep = {
|
|
2949
|
+
encode(message, writer = new BinaryWriter()) {
|
|
2950
|
+
if (message.available !== false) {
|
|
2951
|
+
writer.uint32(8).bool(message.available);
|
|
2952
|
+
}
|
|
2953
|
+
return writer;
|
|
2954
|
+
},
|
|
2955
|
+
decode(input, length) {
|
|
2956
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2957
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2958
|
+
const message = createBaseGetSlamMapRep();
|
|
2959
|
+
while (reader.pos < end) {
|
|
2960
|
+
const tag = reader.uint32();
|
|
2961
|
+
switch (tag >>> 3) {
|
|
2962
|
+
case 1: {
|
|
2963
|
+
if (tag !== 8) {
|
|
2964
|
+
break;
|
|
2965
|
+
}
|
|
2966
|
+
message.available = reader.bool();
|
|
2967
|
+
continue;
|
|
2968
|
+
}
|
|
2969
|
+
}
|
|
2970
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2971
|
+
break;
|
|
2972
|
+
}
|
|
2973
|
+
reader.skip(tag & 7);
|
|
2974
|
+
}
|
|
2975
|
+
return message;
|
|
2976
|
+
},
|
|
2977
|
+
fromJSON(object) {
|
|
2978
|
+
return { available: isSet(object.available) ? gt.Boolean(object.available) : false };
|
|
2979
|
+
},
|
|
2980
|
+
toJSON(message) {
|
|
2981
|
+
const obj = {};
|
|
2982
|
+
if (message.available !== false) {
|
|
2983
|
+
obj.available = message.available;
|
|
2984
|
+
}
|
|
2985
|
+
return obj;
|
|
2986
|
+
},
|
|
2987
|
+
create(base) {
|
|
2988
|
+
return GetSlamMapRep.fromPartial(base ?? {});
|
|
2989
|
+
},
|
|
2990
|
+
fromPartial(object) {
|
|
2991
|
+
const message = createBaseGetSlamMapRep();
|
|
2992
|
+
message.available = object.available ?? false;
|
|
2993
|
+
return message;
|
|
2994
|
+
},
|
|
2995
|
+
};
|
|
2996
|
+
function createBaseResetSlamReq() {
|
|
2997
|
+
return {};
|
|
2998
|
+
}
|
|
2999
|
+
export const ResetSlamReq = {
|
|
3000
|
+
encode(_, writer = new BinaryWriter()) {
|
|
3001
|
+
return writer;
|
|
3002
|
+
},
|
|
3003
|
+
decode(input, length) {
|
|
3004
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
3005
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
3006
|
+
const message = createBaseResetSlamReq();
|
|
3007
|
+
while (reader.pos < end) {
|
|
3008
|
+
const tag = reader.uint32();
|
|
3009
|
+
switch (tag >>> 3) {
|
|
3010
|
+
}
|
|
3011
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
3012
|
+
break;
|
|
3013
|
+
}
|
|
3014
|
+
reader.skip(tag & 7);
|
|
3015
|
+
}
|
|
3016
|
+
return message;
|
|
3017
|
+
},
|
|
3018
|
+
fromJSON(_) {
|
|
3019
|
+
return {};
|
|
3020
|
+
},
|
|
3021
|
+
toJSON(_) {
|
|
3022
|
+
const obj = {};
|
|
3023
|
+
return obj;
|
|
3024
|
+
},
|
|
3025
|
+
create(base) {
|
|
3026
|
+
return ResetSlamReq.fromPartial(base ?? {});
|
|
3027
|
+
},
|
|
3028
|
+
fromPartial(_) {
|
|
3029
|
+
const message = createBaseResetSlamReq();
|
|
3030
|
+
return message;
|
|
3031
|
+
},
|
|
3032
|
+
};
|
|
3033
|
+
function createBaseResetSlamRep() {
|
|
3034
|
+
return { mapId: 0 };
|
|
3035
|
+
}
|
|
3036
|
+
export const ResetSlamRep = {
|
|
3037
|
+
encode(message, writer = new BinaryWriter()) {
|
|
3038
|
+
if (message.mapId !== 0) {
|
|
3039
|
+
writer.uint32(8).uint32(message.mapId);
|
|
3040
|
+
}
|
|
3041
|
+
return writer;
|
|
3042
|
+
},
|
|
3043
|
+
decode(input, length) {
|
|
3044
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
3045
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
3046
|
+
const message = createBaseResetSlamRep();
|
|
3047
|
+
while (reader.pos < end) {
|
|
3048
|
+
const tag = reader.uint32();
|
|
3049
|
+
switch (tag >>> 3) {
|
|
3050
|
+
case 1: {
|
|
3051
|
+
if (tag !== 8) {
|
|
3052
|
+
break;
|
|
3053
|
+
}
|
|
3054
|
+
message.mapId = reader.uint32();
|
|
3055
|
+
continue;
|
|
3056
|
+
}
|
|
3057
|
+
}
|
|
3058
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
3059
|
+
break;
|
|
3060
|
+
}
|
|
3061
|
+
reader.skip(tag & 7);
|
|
3062
|
+
}
|
|
3063
|
+
return message;
|
|
3064
|
+
},
|
|
3065
|
+
fromJSON(object) {
|
|
3066
|
+
return { mapId: isSet(object.mapId) ? gt.Number(object.mapId) : 0 };
|
|
3067
|
+
},
|
|
3068
|
+
toJSON(message) {
|
|
3069
|
+
const obj = {};
|
|
3070
|
+
if (message.mapId !== 0) {
|
|
3071
|
+
obj.mapId = Math.round(message.mapId);
|
|
3072
|
+
}
|
|
3073
|
+
return obj;
|
|
3074
|
+
},
|
|
3075
|
+
create(base) {
|
|
3076
|
+
return ResetSlamRep.fromPartial(base ?? {});
|
|
3077
|
+
},
|
|
3078
|
+
fromPartial(object) {
|
|
3079
|
+
const message = createBaseResetSlamRep();
|
|
3080
|
+
message.mapId = object.mapId ?? 0;
|
|
3081
|
+
return message;
|
|
3082
|
+
},
|
|
3083
|
+
};
|
|
3084
|
+
function createBaseSetSlamActiveReq() {
|
|
3085
|
+
return { active: false };
|
|
3086
|
+
}
|
|
3087
|
+
export const SetSlamActiveReq = {
|
|
3088
|
+
encode(message, writer = new BinaryWriter()) {
|
|
3089
|
+
if (message.active !== false) {
|
|
3090
|
+
writer.uint32(8).bool(message.active);
|
|
3091
|
+
}
|
|
3092
|
+
return writer;
|
|
3093
|
+
},
|
|
3094
|
+
decode(input, length) {
|
|
3095
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
3096
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
3097
|
+
const message = createBaseSetSlamActiveReq();
|
|
3098
|
+
while (reader.pos < end) {
|
|
3099
|
+
const tag = reader.uint32();
|
|
3100
|
+
switch (tag >>> 3) {
|
|
3101
|
+
case 1: {
|
|
3102
|
+
if (tag !== 8) {
|
|
3103
|
+
break;
|
|
3104
|
+
}
|
|
3105
|
+
message.active = reader.bool();
|
|
3106
|
+
continue;
|
|
3107
|
+
}
|
|
3108
|
+
}
|
|
3109
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
3110
|
+
break;
|
|
3111
|
+
}
|
|
3112
|
+
reader.skip(tag & 7);
|
|
3113
|
+
}
|
|
3114
|
+
return message;
|
|
3115
|
+
},
|
|
3116
|
+
fromJSON(object) {
|
|
3117
|
+
return { active: isSet(object.active) ? gt.Boolean(object.active) : false };
|
|
3118
|
+
},
|
|
3119
|
+
toJSON(message) {
|
|
3120
|
+
const obj = {};
|
|
3121
|
+
if (message.active !== false) {
|
|
3122
|
+
obj.active = message.active;
|
|
3123
|
+
}
|
|
3124
|
+
return obj;
|
|
3125
|
+
},
|
|
3126
|
+
create(base) {
|
|
3127
|
+
return SetSlamActiveReq.fromPartial(base ?? {});
|
|
3128
|
+
},
|
|
3129
|
+
fromPartial(object) {
|
|
3130
|
+
const message = createBaseSetSlamActiveReq();
|
|
3131
|
+
message.active = object.active ?? false;
|
|
3132
|
+
return message;
|
|
3133
|
+
},
|
|
3134
|
+
};
|
|
3135
|
+
function createBaseSetSlamActiveRep() {
|
|
3136
|
+
return { available: false, active: false };
|
|
3137
|
+
}
|
|
3138
|
+
export const SetSlamActiveRep = {
|
|
3139
|
+
encode(message, writer = new BinaryWriter()) {
|
|
3140
|
+
if (message.available !== false) {
|
|
3141
|
+
writer.uint32(8).bool(message.available);
|
|
3142
|
+
}
|
|
3143
|
+
if (message.active !== false) {
|
|
3144
|
+
writer.uint32(16).bool(message.active);
|
|
3145
|
+
}
|
|
3146
|
+
return writer;
|
|
3147
|
+
},
|
|
3148
|
+
decode(input, length) {
|
|
3149
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
3150
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
3151
|
+
const message = createBaseSetSlamActiveRep();
|
|
3152
|
+
while (reader.pos < end) {
|
|
3153
|
+
const tag = reader.uint32();
|
|
3154
|
+
switch (tag >>> 3) {
|
|
3155
|
+
case 1: {
|
|
3156
|
+
if (tag !== 8) {
|
|
3157
|
+
break;
|
|
3158
|
+
}
|
|
3159
|
+
message.available = reader.bool();
|
|
3160
|
+
continue;
|
|
3161
|
+
}
|
|
3162
|
+
case 2: {
|
|
3163
|
+
if (tag !== 16) {
|
|
3164
|
+
break;
|
|
3165
|
+
}
|
|
3166
|
+
message.active = reader.bool();
|
|
3167
|
+
continue;
|
|
3168
|
+
}
|
|
3169
|
+
}
|
|
3170
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
3171
|
+
break;
|
|
3172
|
+
}
|
|
3173
|
+
reader.skip(tag & 7);
|
|
3174
|
+
}
|
|
3175
|
+
return message;
|
|
3176
|
+
},
|
|
3177
|
+
fromJSON(object) {
|
|
3178
|
+
return {
|
|
3179
|
+
available: isSet(object.available) ? gt.Boolean(object.available) : false,
|
|
3180
|
+
active: isSet(object.active) ? gt.Boolean(object.active) : false,
|
|
3181
|
+
};
|
|
3182
|
+
},
|
|
3183
|
+
toJSON(message) {
|
|
3184
|
+
const obj = {};
|
|
3185
|
+
if (message.available !== false) {
|
|
3186
|
+
obj.available = message.available;
|
|
3187
|
+
}
|
|
3188
|
+
if (message.active !== false) {
|
|
3189
|
+
obj.active = message.active;
|
|
3190
|
+
}
|
|
3191
|
+
return obj;
|
|
3192
|
+
},
|
|
3193
|
+
create(base) {
|
|
3194
|
+
return SetSlamActiveRep.fromPartial(base ?? {});
|
|
3195
|
+
},
|
|
3196
|
+
fromPartial(object) {
|
|
3197
|
+
const message = createBaseSetSlamActiveRep();
|
|
3198
|
+
message.available = object.available ?? false;
|
|
3199
|
+
message.active = object.active ?? false;
|
|
3200
|
+
return message;
|
|
3201
|
+
},
|
|
3202
|
+
};
|
|
3203
|
+
function createBaseSetSlamRecordingReq() {
|
|
3204
|
+
return { record: false, sensorData: false, storageLocation: 0 };
|
|
3205
|
+
}
|
|
3206
|
+
export const SetSlamRecordingReq = {
|
|
3207
|
+
encode(message, writer = new BinaryWriter()) {
|
|
3208
|
+
if (message.record !== false) {
|
|
3209
|
+
writer.uint32(8).bool(message.record);
|
|
3210
|
+
}
|
|
3211
|
+
if (message.sensorData !== false) {
|
|
3212
|
+
writer.uint32(16).bool(message.sensorData);
|
|
3213
|
+
}
|
|
3214
|
+
if (message.storageLocation !== 0) {
|
|
3215
|
+
writer.uint32(24).int32(message.storageLocation);
|
|
3216
|
+
}
|
|
3217
|
+
return writer;
|
|
3218
|
+
},
|
|
3219
|
+
decode(input, length) {
|
|
3220
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
3221
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
3222
|
+
const message = createBaseSetSlamRecordingReq();
|
|
3223
|
+
while (reader.pos < end) {
|
|
3224
|
+
const tag = reader.uint32();
|
|
3225
|
+
switch (tag >>> 3) {
|
|
3226
|
+
case 1: {
|
|
3227
|
+
if (tag !== 8) {
|
|
3228
|
+
break;
|
|
3229
|
+
}
|
|
3230
|
+
message.record = reader.bool();
|
|
3231
|
+
continue;
|
|
3232
|
+
}
|
|
3233
|
+
case 2: {
|
|
3234
|
+
if (tag !== 16) {
|
|
3235
|
+
break;
|
|
3236
|
+
}
|
|
3237
|
+
message.sensorData = reader.bool();
|
|
3238
|
+
continue;
|
|
3239
|
+
}
|
|
3240
|
+
case 3: {
|
|
3241
|
+
if (tag !== 24) {
|
|
3242
|
+
break;
|
|
3243
|
+
}
|
|
3244
|
+
message.storageLocation = reader.int32();
|
|
3245
|
+
continue;
|
|
3246
|
+
}
|
|
3247
|
+
}
|
|
3248
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
3249
|
+
break;
|
|
3250
|
+
}
|
|
3251
|
+
reader.skip(tag & 7);
|
|
3252
|
+
}
|
|
3253
|
+
return message;
|
|
3254
|
+
},
|
|
3255
|
+
fromJSON(object) {
|
|
3256
|
+
return {
|
|
3257
|
+
record: isSet(object.record) ? gt.Boolean(object.record) : false,
|
|
3258
|
+
sensorData: isSet(object.sensorData) ? gt.Boolean(object.sensorData) : false,
|
|
3259
|
+
storageLocation: isSet(object.storageLocation) ? storageLocationFromJSON(object.storageLocation) : 0,
|
|
3260
|
+
};
|
|
3261
|
+
},
|
|
3262
|
+
toJSON(message) {
|
|
3263
|
+
const obj = {};
|
|
3264
|
+
if (message.record !== false) {
|
|
3265
|
+
obj.record = message.record;
|
|
3266
|
+
}
|
|
3267
|
+
if (message.sensorData !== false) {
|
|
3268
|
+
obj.sensorData = message.sensorData;
|
|
3269
|
+
}
|
|
3270
|
+
if (message.storageLocation !== 0) {
|
|
3271
|
+
obj.storageLocation = storageLocationToJSON(message.storageLocation);
|
|
3272
|
+
}
|
|
3273
|
+
return obj;
|
|
3274
|
+
},
|
|
3275
|
+
create(base) {
|
|
3276
|
+
return SetSlamRecordingReq.fromPartial(base ?? {});
|
|
3277
|
+
},
|
|
3278
|
+
fromPartial(object) {
|
|
3279
|
+
const message = createBaseSetSlamRecordingReq();
|
|
3280
|
+
message.record = object.record ?? false;
|
|
3281
|
+
message.sensorData = object.sensorData ?? false;
|
|
3282
|
+
message.storageLocation = object.storageLocation ?? 0;
|
|
3283
|
+
return message;
|
|
3284
|
+
},
|
|
3285
|
+
};
|
|
3286
|
+
function createBaseSetSlamRecordingRep() {
|
|
3287
|
+
return { available: false, recording: undefined };
|
|
3288
|
+
}
|
|
3289
|
+
export const SetSlamRecordingRep = {
|
|
3290
|
+
encode(message, writer = new BinaryWriter()) {
|
|
3291
|
+
if (message.available !== false) {
|
|
3292
|
+
writer.uint32(8).bool(message.available);
|
|
3293
|
+
}
|
|
3294
|
+
if (message.recording !== undefined) {
|
|
3295
|
+
SlamRecordingState.encode(message.recording, writer.uint32(18).fork()).join();
|
|
3296
|
+
}
|
|
3297
|
+
return writer;
|
|
3298
|
+
},
|
|
3299
|
+
decode(input, length) {
|
|
3300
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
3301
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
3302
|
+
const message = createBaseSetSlamRecordingRep();
|
|
3303
|
+
while (reader.pos < end) {
|
|
3304
|
+
const tag = reader.uint32();
|
|
3305
|
+
switch (tag >>> 3) {
|
|
3306
|
+
case 1: {
|
|
3307
|
+
if (tag !== 8) {
|
|
3308
|
+
break;
|
|
3309
|
+
}
|
|
3310
|
+
message.available = reader.bool();
|
|
3311
|
+
continue;
|
|
3312
|
+
}
|
|
3313
|
+
case 2: {
|
|
3314
|
+
if (tag !== 18) {
|
|
3315
|
+
break;
|
|
3316
|
+
}
|
|
3317
|
+
message.recording = SlamRecordingState.decode(reader, reader.uint32());
|
|
3318
|
+
continue;
|
|
3319
|
+
}
|
|
3320
|
+
}
|
|
3321
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
3322
|
+
break;
|
|
3323
|
+
}
|
|
3324
|
+
reader.skip(tag & 7);
|
|
3325
|
+
}
|
|
3326
|
+
return message;
|
|
3327
|
+
},
|
|
3328
|
+
fromJSON(object) {
|
|
3329
|
+
return {
|
|
3330
|
+
available: isSet(object.available) ? gt.Boolean(object.available) : false,
|
|
3331
|
+
recording: isSet(object.recording) ? SlamRecordingState.fromJSON(object.recording) : undefined,
|
|
3332
|
+
};
|
|
3333
|
+
},
|
|
3334
|
+
toJSON(message) {
|
|
3335
|
+
const obj = {};
|
|
3336
|
+
if (message.available !== false) {
|
|
3337
|
+
obj.available = message.available;
|
|
3338
|
+
}
|
|
3339
|
+
if (message.recording !== undefined) {
|
|
3340
|
+
obj.recording = SlamRecordingState.toJSON(message.recording);
|
|
3341
|
+
}
|
|
3342
|
+
return obj;
|
|
3343
|
+
},
|
|
3344
|
+
create(base) {
|
|
3345
|
+
return SetSlamRecordingRep.fromPartial(base ?? {});
|
|
3346
|
+
},
|
|
3347
|
+
fromPartial(object) {
|
|
3348
|
+
const message = createBaseSetSlamRecordingRep();
|
|
3349
|
+
message.available = object.available ?? false;
|
|
3350
|
+
message.recording = (object.recording !== undefined && object.recording !== null)
|
|
3351
|
+
? SlamRecordingState.fromPartial(object.recording)
|
|
3352
|
+
: undefined;
|
|
3353
|
+
return message;
|
|
3354
|
+
},
|
|
3355
|
+
};
|
|
3356
|
+
function createBaseSetSlamSensorSettingsReq() {
|
|
3357
|
+
return { settings: undefined };
|
|
3358
|
+
}
|
|
3359
|
+
export const SetSlamSensorSettingsReq = {
|
|
3360
|
+
encode(message, writer = new BinaryWriter()) {
|
|
3361
|
+
if (message.settings !== undefined) {
|
|
3362
|
+
SlamSensorSettings.encode(message.settings, writer.uint32(10).fork()).join();
|
|
3363
|
+
}
|
|
3364
|
+
return writer;
|
|
3365
|
+
},
|
|
3366
|
+
decode(input, length) {
|
|
3367
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
3368
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
3369
|
+
const message = createBaseSetSlamSensorSettingsReq();
|
|
3370
|
+
while (reader.pos < end) {
|
|
3371
|
+
const tag = reader.uint32();
|
|
3372
|
+
switch (tag >>> 3) {
|
|
3373
|
+
case 1: {
|
|
3374
|
+
if (tag !== 10) {
|
|
3375
|
+
break;
|
|
3376
|
+
}
|
|
3377
|
+
message.settings = SlamSensorSettings.decode(reader, reader.uint32());
|
|
3378
|
+
continue;
|
|
3379
|
+
}
|
|
3380
|
+
}
|
|
3381
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
3382
|
+
break;
|
|
3383
|
+
}
|
|
3384
|
+
reader.skip(tag & 7);
|
|
3385
|
+
}
|
|
3386
|
+
return message;
|
|
3387
|
+
},
|
|
3388
|
+
fromJSON(object) {
|
|
3389
|
+
return { settings: isSet(object.settings) ? SlamSensorSettings.fromJSON(object.settings) : undefined };
|
|
3390
|
+
},
|
|
3391
|
+
toJSON(message) {
|
|
3392
|
+
const obj = {};
|
|
3393
|
+
if (message.settings !== undefined) {
|
|
3394
|
+
obj.settings = SlamSensorSettings.toJSON(message.settings);
|
|
3395
|
+
}
|
|
3396
|
+
return obj;
|
|
3397
|
+
},
|
|
3398
|
+
create(base) {
|
|
3399
|
+
return SetSlamSensorSettingsReq.fromPartial(base ?? {});
|
|
3400
|
+
},
|
|
3401
|
+
fromPartial(object) {
|
|
3402
|
+
const message = createBaseSetSlamSensorSettingsReq();
|
|
3403
|
+
message.settings = (object.settings !== undefined && object.settings !== null)
|
|
3404
|
+
? SlamSensorSettings.fromPartial(object.settings)
|
|
3405
|
+
: undefined;
|
|
3406
|
+
return message;
|
|
3407
|
+
},
|
|
3408
|
+
};
|
|
3409
|
+
function createBaseSetSlamSensorSettingsRep() {
|
|
3410
|
+
return { available: false, applied: false, settings: undefined };
|
|
3411
|
+
}
|
|
3412
|
+
export const SetSlamSensorSettingsRep = {
|
|
3413
|
+
encode(message, writer = new BinaryWriter()) {
|
|
3414
|
+
if (message.available !== false) {
|
|
3415
|
+
writer.uint32(8).bool(message.available);
|
|
3416
|
+
}
|
|
3417
|
+
if (message.applied !== false) {
|
|
3418
|
+
writer.uint32(16).bool(message.applied);
|
|
3419
|
+
}
|
|
3420
|
+
if (message.settings !== undefined) {
|
|
3421
|
+
SlamSensorSettings.encode(message.settings, writer.uint32(26).fork()).join();
|
|
3422
|
+
}
|
|
3423
|
+
return writer;
|
|
3424
|
+
},
|
|
3425
|
+
decode(input, length) {
|
|
3426
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
3427
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
3428
|
+
const message = createBaseSetSlamSensorSettingsRep();
|
|
3429
|
+
while (reader.pos < end) {
|
|
3430
|
+
const tag = reader.uint32();
|
|
3431
|
+
switch (tag >>> 3) {
|
|
3432
|
+
case 1: {
|
|
3433
|
+
if (tag !== 8) {
|
|
3434
|
+
break;
|
|
3435
|
+
}
|
|
3436
|
+
message.available = reader.bool();
|
|
3437
|
+
continue;
|
|
3438
|
+
}
|
|
3439
|
+
case 2: {
|
|
3440
|
+
if (tag !== 16) {
|
|
3441
|
+
break;
|
|
3442
|
+
}
|
|
3443
|
+
message.applied = reader.bool();
|
|
3444
|
+
continue;
|
|
3445
|
+
}
|
|
3446
|
+
case 3: {
|
|
3447
|
+
if (tag !== 26) {
|
|
3448
|
+
break;
|
|
3449
|
+
}
|
|
3450
|
+
message.settings = SlamSensorSettings.decode(reader, reader.uint32());
|
|
3451
|
+
continue;
|
|
3452
|
+
}
|
|
3453
|
+
}
|
|
3454
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
3455
|
+
break;
|
|
3456
|
+
}
|
|
3457
|
+
reader.skip(tag & 7);
|
|
3458
|
+
}
|
|
3459
|
+
return message;
|
|
3460
|
+
},
|
|
3461
|
+
fromJSON(object) {
|
|
3462
|
+
return {
|
|
3463
|
+
available: isSet(object.available) ? gt.Boolean(object.available) : false,
|
|
3464
|
+
applied: isSet(object.applied) ? gt.Boolean(object.applied) : false,
|
|
3465
|
+
settings: isSet(object.settings) ? SlamSensorSettings.fromJSON(object.settings) : undefined,
|
|
3466
|
+
};
|
|
3467
|
+
},
|
|
3468
|
+
toJSON(message) {
|
|
3469
|
+
const obj = {};
|
|
3470
|
+
if (message.available !== false) {
|
|
3471
|
+
obj.available = message.available;
|
|
3472
|
+
}
|
|
3473
|
+
if (message.applied !== false) {
|
|
3474
|
+
obj.applied = message.applied;
|
|
3475
|
+
}
|
|
3476
|
+
if (message.settings !== undefined) {
|
|
3477
|
+
obj.settings = SlamSensorSettings.toJSON(message.settings);
|
|
3478
|
+
}
|
|
3479
|
+
return obj;
|
|
3480
|
+
},
|
|
3481
|
+
create(base) {
|
|
3482
|
+
return SetSlamSensorSettingsRep.fromPartial(base ?? {});
|
|
3483
|
+
},
|
|
3484
|
+
fromPartial(object) {
|
|
3485
|
+
const message = createBaseSetSlamSensorSettingsRep();
|
|
3486
|
+
message.available = object.available ?? false;
|
|
3487
|
+
message.applied = object.applied ?? false;
|
|
3488
|
+
message.settings = (object.settings !== undefined && object.settings !== null)
|
|
3489
|
+
? SlamSensorSettings.fromPartial(object.settings)
|
|
3490
|
+
: undefined;
|
|
3491
|
+
return message;
|
|
3492
|
+
},
|
|
3493
|
+
};
|
|
2704
3494
|
const gt = (() => {
|
|
2705
3495
|
if (typeof globalThis !== "undefined") {
|
|
2706
3496
|
return globalThis;
|