@blueyerobotics/protocol-definitions 3.4.0-618bf0b0 → 3.4.0-eddb8a5e
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/index.blueye.protocol.d.ts +1 -0
- package/dist/index.blueye.protocol.js +1 -0
- package/dist/message_formats.d.ts +196 -2
- package/dist/message_formats.js +1139 -49
- package/dist/req_rep.d.ts +168 -1
- package/dist/req_rep.js +1033 -16
- package/dist/slam.d.ts +512 -0
- package/dist/slam.js +2427 -0
- package/dist/telemetry.d.ts +99 -1
- package/dist/telemetry.js +535 -1
- package/package.json +1 -1
package/dist/message_formats.js
CHANGED
|
@@ -1456,6 +1456,12 @@ export var GuestPortDeviceID;
|
|
|
1456
1456
|
GuestPortDeviceID[GuestPortDeviceID["GUEST_PORT_DEVICE_ID_OUTLAND_TECHNOLOGY_MP200"] = 51] = "GUEST_PORT_DEVICE_ID_OUTLAND_TECHNOLOGY_MP200";
|
|
1457
1457
|
/** GUEST_PORT_DEVICE_ID_REACH_ROBOTICS_REACH_ALPHA_5 - Reach Robotics Reach Alpha 5 Manipulator. */
|
|
1458
1458
|
GuestPortDeviceID[GuestPortDeviceID["GUEST_PORT_DEVICE_ID_REACH_ROBOTICS_REACH_ALPHA_5"] = 52] = "GUEST_PORT_DEVICE_ID_REACH_ROBOTICS_REACH_ALPHA_5";
|
|
1459
|
+
/** GUEST_PORT_DEVICE_ID_BLUEYE_MULTIBEAM_SERVO_V3 - Blueye Multibeam Skid Servo V3. */
|
|
1460
|
+
GuestPortDeviceID[GuestPortDeviceID["GUEST_PORT_DEVICE_ID_BLUEYE_MULTIBEAM_SERVO_V3"] = 53] = "GUEST_PORT_DEVICE_ID_BLUEYE_MULTIBEAM_SERVO_V3";
|
|
1461
|
+
/** GUEST_PORT_DEVICE_ID_BLUE_ROBOTICS_DETACHABLE_NEWTON_V2 - Detachable Blue Robotics Newton V2. */
|
|
1462
|
+
GuestPortDeviceID[GuestPortDeviceID["GUEST_PORT_DEVICE_ID_BLUE_ROBOTICS_DETACHABLE_NEWTON_V2"] = 54] = "GUEST_PORT_DEVICE_ID_BLUE_ROBOTICS_DETACHABLE_NEWTON_V2";
|
|
1463
|
+
/** GUEST_PORT_DEVICE_ID_BLUEYE_SCALING_LASER_V2 - Blueye Scaling Laser V2. */
|
|
1464
|
+
GuestPortDeviceID[GuestPortDeviceID["GUEST_PORT_DEVICE_ID_BLUEYE_SCALING_LASER_V2"] = 55] = "GUEST_PORT_DEVICE_ID_BLUEYE_SCALING_LASER_V2";
|
|
1459
1465
|
GuestPortDeviceID[GuestPortDeviceID["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
|
|
1460
1466
|
})(GuestPortDeviceID || (GuestPortDeviceID = {}));
|
|
1461
1467
|
export function guestPortDeviceIDFromJSON(object) {
|
|
@@ -1619,6 +1625,15 @@ export function guestPortDeviceIDFromJSON(object) {
|
|
|
1619
1625
|
case 52:
|
|
1620
1626
|
case "GUEST_PORT_DEVICE_ID_REACH_ROBOTICS_REACH_ALPHA_5":
|
|
1621
1627
|
return GuestPortDeviceID.GUEST_PORT_DEVICE_ID_REACH_ROBOTICS_REACH_ALPHA_5;
|
|
1628
|
+
case 53:
|
|
1629
|
+
case "GUEST_PORT_DEVICE_ID_BLUEYE_MULTIBEAM_SERVO_V3":
|
|
1630
|
+
return GuestPortDeviceID.GUEST_PORT_DEVICE_ID_BLUEYE_MULTIBEAM_SERVO_V3;
|
|
1631
|
+
case 54:
|
|
1632
|
+
case "GUEST_PORT_DEVICE_ID_BLUE_ROBOTICS_DETACHABLE_NEWTON_V2":
|
|
1633
|
+
return GuestPortDeviceID.GUEST_PORT_DEVICE_ID_BLUE_ROBOTICS_DETACHABLE_NEWTON_V2;
|
|
1634
|
+
case 55:
|
|
1635
|
+
case "GUEST_PORT_DEVICE_ID_BLUEYE_SCALING_LASER_V2":
|
|
1636
|
+
return GuestPortDeviceID.GUEST_PORT_DEVICE_ID_BLUEYE_SCALING_LASER_V2;
|
|
1622
1637
|
case -1:
|
|
1623
1638
|
case "UNRECOGNIZED":
|
|
1624
1639
|
default:
|
|
@@ -1733,6 +1748,12 @@ export function guestPortDeviceIDToJSON(object) {
|
|
|
1733
1748
|
return "GUEST_PORT_DEVICE_ID_OUTLAND_TECHNOLOGY_MP200";
|
|
1734
1749
|
case GuestPortDeviceID.GUEST_PORT_DEVICE_ID_REACH_ROBOTICS_REACH_ALPHA_5:
|
|
1735
1750
|
return "GUEST_PORT_DEVICE_ID_REACH_ROBOTICS_REACH_ALPHA_5";
|
|
1751
|
+
case GuestPortDeviceID.GUEST_PORT_DEVICE_ID_BLUEYE_MULTIBEAM_SERVO_V3:
|
|
1752
|
+
return "GUEST_PORT_DEVICE_ID_BLUEYE_MULTIBEAM_SERVO_V3";
|
|
1753
|
+
case GuestPortDeviceID.GUEST_PORT_DEVICE_ID_BLUE_ROBOTICS_DETACHABLE_NEWTON_V2:
|
|
1754
|
+
return "GUEST_PORT_DEVICE_ID_BLUE_ROBOTICS_DETACHABLE_NEWTON_V2";
|
|
1755
|
+
case GuestPortDeviceID.GUEST_PORT_DEVICE_ID_BLUEYE_SCALING_LASER_V2:
|
|
1756
|
+
return "GUEST_PORT_DEVICE_ID_BLUEYE_SCALING_LASER_V2";
|
|
1736
1757
|
case GuestPortDeviceID.UNRECOGNIZED:
|
|
1737
1758
|
default:
|
|
1738
1759
|
return "UNRECOGNIZED";
|
|
@@ -1831,6 +1852,10 @@ export var GuestPortCapability;
|
|
|
1831
1852
|
GuestPortCapability[GuestPortCapability["GUEST_PORT_CAPABILITY_PWM"] = 6] = "GUEST_PORT_CAPABILITY_PWM";
|
|
1832
1853
|
/** GUEST_PORT_CAPABILITY_ETHERNET_1G - Gigabit Ethernet. */
|
|
1833
1854
|
GuestPortCapability[GuestPortCapability["GUEST_PORT_CAPABILITY_ETHERNET_1G"] = 7] = "GUEST_PORT_CAPABILITY_ETHERNET_1G";
|
|
1855
|
+
/** GUEST_PORT_CAPABILITY_I2C_IO - TCA9536 I/O expander. */
|
|
1856
|
+
GuestPortCapability[GuestPortCapability["GUEST_PORT_CAPABILITY_I2C_IO"] = 8] = "GUEST_PORT_CAPABILITY_I2C_IO";
|
|
1857
|
+
/** GUEST_PORT_CAPABILITY_I2C_IO_V2 - PCA9554A I/O expander. */
|
|
1858
|
+
GuestPortCapability[GuestPortCapability["GUEST_PORT_CAPABILITY_I2C_IO_V2"] = 9] = "GUEST_PORT_CAPABILITY_I2C_IO_V2";
|
|
1834
1859
|
GuestPortCapability[GuestPortCapability["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
|
|
1835
1860
|
})(GuestPortCapability || (GuestPortCapability = {}));
|
|
1836
1861
|
export function guestPortCapabilityFromJSON(object) {
|
|
@@ -1859,6 +1884,12 @@ export function guestPortCapabilityFromJSON(object) {
|
|
|
1859
1884
|
case 7:
|
|
1860
1885
|
case "GUEST_PORT_CAPABILITY_ETHERNET_1G":
|
|
1861
1886
|
return GuestPortCapability.GUEST_PORT_CAPABILITY_ETHERNET_1G;
|
|
1887
|
+
case 8:
|
|
1888
|
+
case "GUEST_PORT_CAPABILITY_I2C_IO":
|
|
1889
|
+
return GuestPortCapability.GUEST_PORT_CAPABILITY_I2C_IO;
|
|
1890
|
+
case 9:
|
|
1891
|
+
case "GUEST_PORT_CAPABILITY_I2C_IO_V2":
|
|
1892
|
+
return GuestPortCapability.GUEST_PORT_CAPABILITY_I2C_IO_V2;
|
|
1862
1893
|
case -1:
|
|
1863
1894
|
case "UNRECOGNIZED":
|
|
1864
1895
|
default:
|
|
@@ -1883,6 +1914,10 @@ export function guestPortCapabilityToJSON(object) {
|
|
|
1883
1914
|
return "GUEST_PORT_CAPABILITY_PWM";
|
|
1884
1915
|
case GuestPortCapability.GUEST_PORT_CAPABILITY_ETHERNET_1G:
|
|
1885
1916
|
return "GUEST_PORT_CAPABILITY_ETHERNET_1G";
|
|
1917
|
+
case GuestPortCapability.GUEST_PORT_CAPABILITY_I2C_IO:
|
|
1918
|
+
return "GUEST_PORT_CAPABILITY_I2C_IO";
|
|
1919
|
+
case GuestPortCapability.GUEST_PORT_CAPABILITY_I2C_IO_V2:
|
|
1920
|
+
return "GUEST_PORT_CAPABILITY_I2C_IO_V2";
|
|
1886
1921
|
case GuestPortCapability.UNRECOGNIZED:
|
|
1887
1922
|
default:
|
|
1888
1923
|
return "UNRECOGNIZED";
|
|
@@ -3857,6 +3892,7 @@ function createBaseLaserDetection() {
|
|
|
3857
3892
|
laserWidth: 0,
|
|
3858
3893
|
correctedPixelDistance: 0,
|
|
3859
3894
|
estimatedDistance: 0,
|
|
3895
|
+
frameId: 0,
|
|
3860
3896
|
};
|
|
3861
3897
|
}
|
|
3862
3898
|
export const LaserDetection = {
|
|
@@ -3891,6 +3927,9 @@ export const LaserDetection = {
|
|
|
3891
3927
|
if (message.estimatedDistance !== 0) {
|
|
3892
3928
|
writer.uint32(85).float(message.estimatedDistance);
|
|
3893
3929
|
}
|
|
3930
|
+
if (message.frameId !== 0) {
|
|
3931
|
+
writer.uint32(88).uint64(message.frameId);
|
|
3932
|
+
}
|
|
3894
3933
|
return writer;
|
|
3895
3934
|
},
|
|
3896
3935
|
decode(input, length) {
|
|
@@ -3970,6 +4009,13 @@ export const LaserDetection = {
|
|
|
3970
4009
|
message.estimatedDistance = reader.float();
|
|
3971
4010
|
continue;
|
|
3972
4011
|
}
|
|
4012
|
+
case 11: {
|
|
4013
|
+
if (tag !== 88) {
|
|
4014
|
+
break;
|
|
4015
|
+
}
|
|
4016
|
+
message.frameId = longToNumber(reader.uint64());
|
|
4017
|
+
continue;
|
|
4018
|
+
}
|
|
3973
4019
|
}
|
|
3974
4020
|
if ((tag & 7) === 4 || tag === 0) {
|
|
3975
4021
|
break;
|
|
@@ -3990,6 +4036,7 @@ export const LaserDetection = {
|
|
|
3990
4036
|
laserWidth: isSet(object.laserWidth) ? gt.Number(object.laserWidth) : 0,
|
|
3991
4037
|
correctedPixelDistance: isSet(object.correctedPixelDistance) ? gt.Number(object.correctedPixelDistance) : 0,
|
|
3992
4038
|
estimatedDistance: isSet(object.estimatedDistance) ? gt.Number(object.estimatedDistance) : 0,
|
|
4039
|
+
frameId: isSet(object.frameId) ? gt.Number(object.frameId) : 0,
|
|
3993
4040
|
};
|
|
3994
4041
|
},
|
|
3995
4042
|
toJSON(message) {
|
|
@@ -4024,6 +4071,9 @@ export const LaserDetection = {
|
|
|
4024
4071
|
if (message.estimatedDistance !== 0) {
|
|
4025
4072
|
obj.estimatedDistance = message.estimatedDistance;
|
|
4026
4073
|
}
|
|
4074
|
+
if (message.frameId !== 0) {
|
|
4075
|
+
obj.frameId = Math.round(message.frameId);
|
|
4076
|
+
}
|
|
4027
4077
|
return obj;
|
|
4028
4078
|
},
|
|
4029
4079
|
create(base) {
|
|
@@ -4041,6 +4091,7 @@ export const LaserDetection = {
|
|
|
4041
4091
|
message.laserWidth = object.laserWidth ?? 0;
|
|
4042
4092
|
message.correctedPixelDistance = object.correctedPixelDistance ?? 0;
|
|
4043
4093
|
message.estimatedDistance = object.estimatedDistance ?? 0;
|
|
4094
|
+
message.frameId = object.frameId ?? 0;
|
|
4044
4095
|
return message;
|
|
4045
4096
|
},
|
|
4046
4097
|
};
|
|
@@ -5409,14 +5460,831 @@ export const Gripper = {
|
|
|
5409
5460
|
if (tag !== 56) {
|
|
5410
5461
|
break;
|
|
5411
5462
|
}
|
|
5412
|
-
message.fault = reader.bool();
|
|
5463
|
+
message.fault = reader.bool();
|
|
5464
|
+
continue;
|
|
5465
|
+
}
|
|
5466
|
+
case 8: {
|
|
5467
|
+
if (tag !== 64) {
|
|
5468
|
+
break;
|
|
5469
|
+
}
|
|
5470
|
+
message.movingTo = reader.int32();
|
|
5471
|
+
continue;
|
|
5472
|
+
}
|
|
5473
|
+
}
|
|
5474
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
5475
|
+
break;
|
|
5476
|
+
}
|
|
5477
|
+
reader.skip(tag & 7);
|
|
5478
|
+
}
|
|
5479
|
+
return message;
|
|
5480
|
+
},
|
|
5481
|
+
fromJSON(object) {
|
|
5482
|
+
return {
|
|
5483
|
+
mode: isSet(object.mode) ? manipulatorControlModeFromJSON(object.mode) : 0,
|
|
5484
|
+
jointPositions: gt.Array.isArray(object?.jointPositions)
|
|
5485
|
+
? object.jointPositions.map((e) => gt.Number(e))
|
|
5486
|
+
: [],
|
|
5487
|
+
endPosition: isSet(object.endPosition) ? Vector3.fromJSON(object.endPosition) : undefined,
|
|
5488
|
+
atLimit: isSet(object.atLimit) ? gt.Boolean(object.atLimit) : false,
|
|
5489
|
+
collision: isSet(object.collision) ? gt.Boolean(object.collision) : false,
|
|
5490
|
+
holding: isSet(object.holding) ? gt.Boolean(object.holding) : false,
|
|
5491
|
+
fault: isSet(object.fault) ? gt.Boolean(object.fault) : false,
|
|
5492
|
+
movingTo: isSet(object.movingTo) ? manipulatorPoseFromJSON(object.movingTo) : 0,
|
|
5493
|
+
};
|
|
5494
|
+
},
|
|
5495
|
+
toJSON(message) {
|
|
5496
|
+
const obj = {};
|
|
5497
|
+
if (message.mode !== 0) {
|
|
5498
|
+
obj.mode = manipulatorControlModeToJSON(message.mode);
|
|
5499
|
+
}
|
|
5500
|
+
if (message.jointPositions?.length) {
|
|
5501
|
+
obj.jointPositions = message.jointPositions;
|
|
5502
|
+
}
|
|
5503
|
+
if (message.endPosition !== undefined) {
|
|
5504
|
+
obj.endPosition = Vector3.toJSON(message.endPosition);
|
|
5505
|
+
}
|
|
5506
|
+
if (message.atLimit !== false) {
|
|
5507
|
+
obj.atLimit = message.atLimit;
|
|
5508
|
+
}
|
|
5509
|
+
if (message.collision !== false) {
|
|
5510
|
+
obj.collision = message.collision;
|
|
5511
|
+
}
|
|
5512
|
+
if (message.holding !== false) {
|
|
5513
|
+
obj.holding = message.holding;
|
|
5514
|
+
}
|
|
5515
|
+
if (message.fault !== false) {
|
|
5516
|
+
obj.fault = message.fault;
|
|
5517
|
+
}
|
|
5518
|
+
if (message.movingTo !== 0) {
|
|
5519
|
+
obj.movingTo = manipulatorPoseToJSON(message.movingTo);
|
|
5520
|
+
}
|
|
5521
|
+
return obj;
|
|
5522
|
+
},
|
|
5523
|
+
create(base) {
|
|
5524
|
+
return Gripper.fromPartial(base ?? {});
|
|
5525
|
+
},
|
|
5526
|
+
fromPartial(object) {
|
|
5527
|
+
const message = createBaseGripper();
|
|
5528
|
+
message.mode = object.mode ?? 0;
|
|
5529
|
+
message.jointPositions = object.jointPositions?.map((e) => e) || [];
|
|
5530
|
+
message.endPosition = (object.endPosition !== undefined && object.endPosition !== null)
|
|
5531
|
+
? Vector3.fromPartial(object.endPosition)
|
|
5532
|
+
: undefined;
|
|
5533
|
+
message.atLimit = object.atLimit ?? false;
|
|
5534
|
+
message.collision = object.collision ?? false;
|
|
5535
|
+
message.holding = object.holding ?? false;
|
|
5536
|
+
message.fault = object.fault ?? false;
|
|
5537
|
+
message.movingTo = object.movingTo ?? 0;
|
|
5538
|
+
return message;
|
|
5539
|
+
},
|
|
5540
|
+
};
|
|
5541
|
+
function createBaseReachHardwareStatus() {
|
|
5542
|
+
return {
|
|
5543
|
+
flashFailedRead: false,
|
|
5544
|
+
overHumidity: false,
|
|
5545
|
+
overTemperature: false,
|
|
5546
|
+
commsSerialError: false,
|
|
5547
|
+
commsCrcError: false,
|
|
5548
|
+
motorDriverFault: false,
|
|
5549
|
+
encoderPositionError: false,
|
|
5550
|
+
encoderNotDetected: false,
|
|
5551
|
+
deviceAxisConflict: false,
|
|
5552
|
+
motorNotConnected: false,
|
|
5553
|
+
motorOverCurrent: false,
|
|
5554
|
+
inputEncoderPositionError: false,
|
|
5555
|
+
deviceIdConflict: false,
|
|
5556
|
+
overPressure: false,
|
|
5557
|
+
motorDriverOverCurrentAndUnderVoltage: false,
|
|
5558
|
+
motorDriverOverTemperature: false,
|
|
5559
|
+
jointServiceDue: false,
|
|
5560
|
+
encoderFault: false,
|
|
5561
|
+
lowSupplyVoltage: false,
|
|
5562
|
+
positionReportNotReceived: false,
|
|
5563
|
+
};
|
|
5564
|
+
}
|
|
5565
|
+
export const ReachHardwareStatus = {
|
|
5566
|
+
encode(message, writer = new BinaryWriter()) {
|
|
5567
|
+
if (message.flashFailedRead !== false) {
|
|
5568
|
+
writer.uint32(8).bool(message.flashFailedRead);
|
|
5569
|
+
}
|
|
5570
|
+
if (message.overHumidity !== false) {
|
|
5571
|
+
writer.uint32(16).bool(message.overHumidity);
|
|
5572
|
+
}
|
|
5573
|
+
if (message.overTemperature !== false) {
|
|
5574
|
+
writer.uint32(24).bool(message.overTemperature);
|
|
5575
|
+
}
|
|
5576
|
+
if (message.commsSerialError !== false) {
|
|
5577
|
+
writer.uint32(32).bool(message.commsSerialError);
|
|
5578
|
+
}
|
|
5579
|
+
if (message.commsCrcError !== false) {
|
|
5580
|
+
writer.uint32(40).bool(message.commsCrcError);
|
|
5581
|
+
}
|
|
5582
|
+
if (message.motorDriverFault !== false) {
|
|
5583
|
+
writer.uint32(48).bool(message.motorDriverFault);
|
|
5584
|
+
}
|
|
5585
|
+
if (message.encoderPositionError !== false) {
|
|
5586
|
+
writer.uint32(56).bool(message.encoderPositionError);
|
|
5587
|
+
}
|
|
5588
|
+
if (message.encoderNotDetected !== false) {
|
|
5589
|
+
writer.uint32(64).bool(message.encoderNotDetected);
|
|
5590
|
+
}
|
|
5591
|
+
if (message.deviceAxisConflict !== false) {
|
|
5592
|
+
writer.uint32(72).bool(message.deviceAxisConflict);
|
|
5593
|
+
}
|
|
5594
|
+
if (message.motorNotConnected !== false) {
|
|
5595
|
+
writer.uint32(80).bool(message.motorNotConnected);
|
|
5596
|
+
}
|
|
5597
|
+
if (message.motorOverCurrent !== false) {
|
|
5598
|
+
writer.uint32(88).bool(message.motorOverCurrent);
|
|
5599
|
+
}
|
|
5600
|
+
if (message.inputEncoderPositionError !== false) {
|
|
5601
|
+
writer.uint32(96).bool(message.inputEncoderPositionError);
|
|
5602
|
+
}
|
|
5603
|
+
if (message.deviceIdConflict !== false) {
|
|
5604
|
+
writer.uint32(104).bool(message.deviceIdConflict);
|
|
5605
|
+
}
|
|
5606
|
+
if (message.overPressure !== false) {
|
|
5607
|
+
writer.uint32(112).bool(message.overPressure);
|
|
5608
|
+
}
|
|
5609
|
+
if (message.motorDriverOverCurrentAndUnderVoltage !== false) {
|
|
5610
|
+
writer.uint32(120).bool(message.motorDriverOverCurrentAndUnderVoltage);
|
|
5611
|
+
}
|
|
5612
|
+
if (message.motorDriverOverTemperature !== false) {
|
|
5613
|
+
writer.uint32(128).bool(message.motorDriverOverTemperature);
|
|
5614
|
+
}
|
|
5615
|
+
if (message.jointServiceDue !== false) {
|
|
5616
|
+
writer.uint32(136).bool(message.jointServiceDue);
|
|
5617
|
+
}
|
|
5618
|
+
if (message.encoderFault !== false) {
|
|
5619
|
+
writer.uint32(144).bool(message.encoderFault);
|
|
5620
|
+
}
|
|
5621
|
+
if (message.lowSupplyVoltage !== false) {
|
|
5622
|
+
writer.uint32(152).bool(message.lowSupplyVoltage);
|
|
5623
|
+
}
|
|
5624
|
+
if (message.positionReportNotReceived !== false) {
|
|
5625
|
+
writer.uint32(160).bool(message.positionReportNotReceived);
|
|
5626
|
+
}
|
|
5627
|
+
return writer;
|
|
5628
|
+
},
|
|
5629
|
+
decode(input, length) {
|
|
5630
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
5631
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
5632
|
+
const message = createBaseReachHardwareStatus();
|
|
5633
|
+
while (reader.pos < end) {
|
|
5634
|
+
const tag = reader.uint32();
|
|
5635
|
+
switch (tag >>> 3) {
|
|
5636
|
+
case 1: {
|
|
5637
|
+
if (tag !== 8) {
|
|
5638
|
+
break;
|
|
5639
|
+
}
|
|
5640
|
+
message.flashFailedRead = reader.bool();
|
|
5641
|
+
continue;
|
|
5642
|
+
}
|
|
5643
|
+
case 2: {
|
|
5644
|
+
if (tag !== 16) {
|
|
5645
|
+
break;
|
|
5646
|
+
}
|
|
5647
|
+
message.overHumidity = reader.bool();
|
|
5648
|
+
continue;
|
|
5649
|
+
}
|
|
5650
|
+
case 3: {
|
|
5651
|
+
if (tag !== 24) {
|
|
5652
|
+
break;
|
|
5653
|
+
}
|
|
5654
|
+
message.overTemperature = reader.bool();
|
|
5655
|
+
continue;
|
|
5656
|
+
}
|
|
5657
|
+
case 4: {
|
|
5658
|
+
if (tag !== 32) {
|
|
5659
|
+
break;
|
|
5660
|
+
}
|
|
5661
|
+
message.commsSerialError = reader.bool();
|
|
5662
|
+
continue;
|
|
5663
|
+
}
|
|
5664
|
+
case 5: {
|
|
5665
|
+
if (tag !== 40) {
|
|
5666
|
+
break;
|
|
5667
|
+
}
|
|
5668
|
+
message.commsCrcError = reader.bool();
|
|
5669
|
+
continue;
|
|
5670
|
+
}
|
|
5671
|
+
case 6: {
|
|
5672
|
+
if (tag !== 48) {
|
|
5673
|
+
break;
|
|
5674
|
+
}
|
|
5675
|
+
message.motorDriverFault = reader.bool();
|
|
5676
|
+
continue;
|
|
5677
|
+
}
|
|
5678
|
+
case 7: {
|
|
5679
|
+
if (tag !== 56) {
|
|
5680
|
+
break;
|
|
5681
|
+
}
|
|
5682
|
+
message.encoderPositionError = reader.bool();
|
|
5683
|
+
continue;
|
|
5684
|
+
}
|
|
5685
|
+
case 8: {
|
|
5686
|
+
if (tag !== 64) {
|
|
5687
|
+
break;
|
|
5688
|
+
}
|
|
5689
|
+
message.encoderNotDetected = reader.bool();
|
|
5690
|
+
continue;
|
|
5691
|
+
}
|
|
5692
|
+
case 9: {
|
|
5693
|
+
if (tag !== 72) {
|
|
5694
|
+
break;
|
|
5695
|
+
}
|
|
5696
|
+
message.deviceAxisConflict = reader.bool();
|
|
5697
|
+
continue;
|
|
5698
|
+
}
|
|
5699
|
+
case 10: {
|
|
5700
|
+
if (tag !== 80) {
|
|
5701
|
+
break;
|
|
5702
|
+
}
|
|
5703
|
+
message.motorNotConnected = reader.bool();
|
|
5704
|
+
continue;
|
|
5705
|
+
}
|
|
5706
|
+
case 11: {
|
|
5707
|
+
if (tag !== 88) {
|
|
5708
|
+
break;
|
|
5709
|
+
}
|
|
5710
|
+
message.motorOverCurrent = reader.bool();
|
|
5711
|
+
continue;
|
|
5712
|
+
}
|
|
5713
|
+
case 12: {
|
|
5714
|
+
if (tag !== 96) {
|
|
5715
|
+
break;
|
|
5716
|
+
}
|
|
5717
|
+
message.inputEncoderPositionError = reader.bool();
|
|
5718
|
+
continue;
|
|
5719
|
+
}
|
|
5720
|
+
case 13: {
|
|
5721
|
+
if (tag !== 104) {
|
|
5722
|
+
break;
|
|
5723
|
+
}
|
|
5724
|
+
message.deviceIdConflict = reader.bool();
|
|
5725
|
+
continue;
|
|
5726
|
+
}
|
|
5727
|
+
case 14: {
|
|
5728
|
+
if (tag !== 112) {
|
|
5729
|
+
break;
|
|
5730
|
+
}
|
|
5731
|
+
message.overPressure = reader.bool();
|
|
5732
|
+
continue;
|
|
5733
|
+
}
|
|
5734
|
+
case 15: {
|
|
5735
|
+
if (tag !== 120) {
|
|
5736
|
+
break;
|
|
5737
|
+
}
|
|
5738
|
+
message.motorDriverOverCurrentAndUnderVoltage = reader.bool();
|
|
5739
|
+
continue;
|
|
5740
|
+
}
|
|
5741
|
+
case 16: {
|
|
5742
|
+
if (tag !== 128) {
|
|
5743
|
+
break;
|
|
5744
|
+
}
|
|
5745
|
+
message.motorDriverOverTemperature = reader.bool();
|
|
5746
|
+
continue;
|
|
5747
|
+
}
|
|
5748
|
+
case 17: {
|
|
5749
|
+
if (tag !== 136) {
|
|
5750
|
+
break;
|
|
5751
|
+
}
|
|
5752
|
+
message.jointServiceDue = reader.bool();
|
|
5753
|
+
continue;
|
|
5754
|
+
}
|
|
5755
|
+
case 18: {
|
|
5756
|
+
if (tag !== 144) {
|
|
5757
|
+
break;
|
|
5758
|
+
}
|
|
5759
|
+
message.encoderFault = reader.bool();
|
|
5760
|
+
continue;
|
|
5761
|
+
}
|
|
5762
|
+
case 19: {
|
|
5763
|
+
if (tag !== 152) {
|
|
5764
|
+
break;
|
|
5765
|
+
}
|
|
5766
|
+
message.lowSupplyVoltage = reader.bool();
|
|
5767
|
+
continue;
|
|
5768
|
+
}
|
|
5769
|
+
case 20: {
|
|
5770
|
+
if (tag !== 160) {
|
|
5771
|
+
break;
|
|
5772
|
+
}
|
|
5773
|
+
message.positionReportNotReceived = reader.bool();
|
|
5774
|
+
continue;
|
|
5775
|
+
}
|
|
5776
|
+
}
|
|
5777
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
5778
|
+
break;
|
|
5779
|
+
}
|
|
5780
|
+
reader.skip(tag & 7);
|
|
5781
|
+
}
|
|
5782
|
+
return message;
|
|
5783
|
+
},
|
|
5784
|
+
fromJSON(object) {
|
|
5785
|
+
return {
|
|
5786
|
+
flashFailedRead: isSet(object.flashFailedRead) ? gt.Boolean(object.flashFailedRead) : false,
|
|
5787
|
+
overHumidity: isSet(object.overHumidity) ? gt.Boolean(object.overHumidity) : false,
|
|
5788
|
+
overTemperature: isSet(object.overTemperature) ? gt.Boolean(object.overTemperature) : false,
|
|
5789
|
+
commsSerialError: isSet(object.commsSerialError) ? gt.Boolean(object.commsSerialError) : false,
|
|
5790
|
+
commsCrcError: isSet(object.commsCrcError) ? gt.Boolean(object.commsCrcError) : false,
|
|
5791
|
+
motorDriverFault: isSet(object.motorDriverFault) ? gt.Boolean(object.motorDriverFault) : false,
|
|
5792
|
+
encoderPositionError: isSet(object.encoderPositionError) ? gt.Boolean(object.encoderPositionError) : false,
|
|
5793
|
+
encoderNotDetected: isSet(object.encoderNotDetected) ? gt.Boolean(object.encoderNotDetected) : false,
|
|
5794
|
+
deviceAxisConflict: isSet(object.deviceAxisConflict) ? gt.Boolean(object.deviceAxisConflict) : false,
|
|
5795
|
+
motorNotConnected: isSet(object.motorNotConnected) ? gt.Boolean(object.motorNotConnected) : false,
|
|
5796
|
+
motorOverCurrent: isSet(object.motorOverCurrent) ? gt.Boolean(object.motorOverCurrent) : false,
|
|
5797
|
+
inputEncoderPositionError: isSet(object.inputEncoderPositionError)
|
|
5798
|
+
? gt.Boolean(object.inputEncoderPositionError)
|
|
5799
|
+
: false,
|
|
5800
|
+
deviceIdConflict: isSet(object.deviceIdConflict) ? gt.Boolean(object.deviceIdConflict) : false,
|
|
5801
|
+
overPressure: isSet(object.overPressure) ? gt.Boolean(object.overPressure) : false,
|
|
5802
|
+
motorDriverOverCurrentAndUnderVoltage: isSet(object.motorDriverOverCurrentAndUnderVoltage)
|
|
5803
|
+
? gt.Boolean(object.motorDriverOverCurrentAndUnderVoltage)
|
|
5804
|
+
: false,
|
|
5805
|
+
motorDriverOverTemperature: isSet(object.motorDriverOverTemperature)
|
|
5806
|
+
? gt.Boolean(object.motorDriverOverTemperature)
|
|
5807
|
+
: false,
|
|
5808
|
+
jointServiceDue: isSet(object.jointServiceDue) ? gt.Boolean(object.jointServiceDue) : false,
|
|
5809
|
+
encoderFault: isSet(object.encoderFault) ? gt.Boolean(object.encoderFault) : false,
|
|
5810
|
+
lowSupplyVoltage: isSet(object.lowSupplyVoltage) ? gt.Boolean(object.lowSupplyVoltage) : false,
|
|
5811
|
+
positionReportNotReceived: isSet(object.positionReportNotReceived)
|
|
5812
|
+
? gt.Boolean(object.positionReportNotReceived)
|
|
5813
|
+
: false,
|
|
5814
|
+
};
|
|
5815
|
+
},
|
|
5816
|
+
toJSON(message) {
|
|
5817
|
+
const obj = {};
|
|
5818
|
+
if (message.flashFailedRead !== false) {
|
|
5819
|
+
obj.flashFailedRead = message.flashFailedRead;
|
|
5820
|
+
}
|
|
5821
|
+
if (message.overHumidity !== false) {
|
|
5822
|
+
obj.overHumidity = message.overHumidity;
|
|
5823
|
+
}
|
|
5824
|
+
if (message.overTemperature !== false) {
|
|
5825
|
+
obj.overTemperature = message.overTemperature;
|
|
5826
|
+
}
|
|
5827
|
+
if (message.commsSerialError !== false) {
|
|
5828
|
+
obj.commsSerialError = message.commsSerialError;
|
|
5829
|
+
}
|
|
5830
|
+
if (message.commsCrcError !== false) {
|
|
5831
|
+
obj.commsCrcError = message.commsCrcError;
|
|
5832
|
+
}
|
|
5833
|
+
if (message.motorDriverFault !== false) {
|
|
5834
|
+
obj.motorDriverFault = message.motorDriverFault;
|
|
5835
|
+
}
|
|
5836
|
+
if (message.encoderPositionError !== false) {
|
|
5837
|
+
obj.encoderPositionError = message.encoderPositionError;
|
|
5838
|
+
}
|
|
5839
|
+
if (message.encoderNotDetected !== false) {
|
|
5840
|
+
obj.encoderNotDetected = message.encoderNotDetected;
|
|
5841
|
+
}
|
|
5842
|
+
if (message.deviceAxisConflict !== false) {
|
|
5843
|
+
obj.deviceAxisConflict = message.deviceAxisConflict;
|
|
5844
|
+
}
|
|
5845
|
+
if (message.motorNotConnected !== false) {
|
|
5846
|
+
obj.motorNotConnected = message.motorNotConnected;
|
|
5847
|
+
}
|
|
5848
|
+
if (message.motorOverCurrent !== false) {
|
|
5849
|
+
obj.motorOverCurrent = message.motorOverCurrent;
|
|
5850
|
+
}
|
|
5851
|
+
if (message.inputEncoderPositionError !== false) {
|
|
5852
|
+
obj.inputEncoderPositionError = message.inputEncoderPositionError;
|
|
5853
|
+
}
|
|
5854
|
+
if (message.deviceIdConflict !== false) {
|
|
5855
|
+
obj.deviceIdConflict = message.deviceIdConflict;
|
|
5856
|
+
}
|
|
5857
|
+
if (message.overPressure !== false) {
|
|
5858
|
+
obj.overPressure = message.overPressure;
|
|
5859
|
+
}
|
|
5860
|
+
if (message.motorDriverOverCurrentAndUnderVoltage !== false) {
|
|
5861
|
+
obj.motorDriverOverCurrentAndUnderVoltage = message.motorDriverOverCurrentAndUnderVoltage;
|
|
5862
|
+
}
|
|
5863
|
+
if (message.motorDriverOverTemperature !== false) {
|
|
5864
|
+
obj.motorDriverOverTemperature = message.motorDriverOverTemperature;
|
|
5865
|
+
}
|
|
5866
|
+
if (message.jointServiceDue !== false) {
|
|
5867
|
+
obj.jointServiceDue = message.jointServiceDue;
|
|
5868
|
+
}
|
|
5869
|
+
if (message.encoderFault !== false) {
|
|
5870
|
+
obj.encoderFault = message.encoderFault;
|
|
5871
|
+
}
|
|
5872
|
+
if (message.lowSupplyVoltage !== false) {
|
|
5873
|
+
obj.lowSupplyVoltage = message.lowSupplyVoltage;
|
|
5874
|
+
}
|
|
5875
|
+
if (message.positionReportNotReceived !== false) {
|
|
5876
|
+
obj.positionReportNotReceived = message.positionReportNotReceived;
|
|
5877
|
+
}
|
|
5878
|
+
return obj;
|
|
5879
|
+
},
|
|
5880
|
+
create(base) {
|
|
5881
|
+
return ReachHardwareStatus.fromPartial(base ?? {});
|
|
5882
|
+
},
|
|
5883
|
+
fromPartial(object) {
|
|
5884
|
+
const message = createBaseReachHardwareStatus();
|
|
5885
|
+
message.flashFailedRead = object.flashFailedRead ?? false;
|
|
5886
|
+
message.overHumidity = object.overHumidity ?? false;
|
|
5887
|
+
message.overTemperature = object.overTemperature ?? false;
|
|
5888
|
+
message.commsSerialError = object.commsSerialError ?? false;
|
|
5889
|
+
message.commsCrcError = object.commsCrcError ?? false;
|
|
5890
|
+
message.motorDriverFault = object.motorDriverFault ?? false;
|
|
5891
|
+
message.encoderPositionError = object.encoderPositionError ?? false;
|
|
5892
|
+
message.encoderNotDetected = object.encoderNotDetected ?? false;
|
|
5893
|
+
message.deviceAxisConflict = object.deviceAxisConflict ?? false;
|
|
5894
|
+
message.motorNotConnected = object.motorNotConnected ?? false;
|
|
5895
|
+
message.motorOverCurrent = object.motorOverCurrent ?? false;
|
|
5896
|
+
message.inputEncoderPositionError = object.inputEncoderPositionError ?? false;
|
|
5897
|
+
message.deviceIdConflict = object.deviceIdConflict ?? false;
|
|
5898
|
+
message.overPressure = object.overPressure ?? false;
|
|
5899
|
+
message.motorDriverOverCurrentAndUnderVoltage = object.motorDriverOverCurrentAndUnderVoltage ?? false;
|
|
5900
|
+
message.motorDriverOverTemperature = object.motorDriverOverTemperature ?? false;
|
|
5901
|
+
message.jointServiceDue = object.jointServiceDue ?? false;
|
|
5902
|
+
message.encoderFault = object.encoderFault ?? false;
|
|
5903
|
+
message.lowSupplyVoltage = object.lowSupplyVoltage ?? false;
|
|
5904
|
+
message.positionReportNotReceived = object.positionReportNotReceived ?? false;
|
|
5905
|
+
return message;
|
|
5906
|
+
},
|
|
5907
|
+
};
|
|
5908
|
+
function createBaseGripperDeviceDiagnostics() {
|
|
5909
|
+
return {
|
|
5910
|
+
address: 0,
|
|
5911
|
+
supplyVoltage: 0,
|
|
5912
|
+
isSupplyVoltageValid: false,
|
|
5913
|
+
temperature: 0,
|
|
5914
|
+
isTemperatureValid: false,
|
|
5915
|
+
humidity: 0,
|
|
5916
|
+
isHumidityValid: false,
|
|
5917
|
+
internalPressure: 0,
|
|
5918
|
+
isInternalPressureValid: false,
|
|
5919
|
+
current: 0,
|
|
5920
|
+
isCurrentValid: false,
|
|
5921
|
+
hardwareStatus: undefined,
|
|
5922
|
+
};
|
|
5923
|
+
}
|
|
5924
|
+
export const GripperDeviceDiagnostics = {
|
|
5925
|
+
encode(message, writer = new BinaryWriter()) {
|
|
5926
|
+
if (message.address !== 0) {
|
|
5927
|
+
writer.uint32(8).uint32(message.address);
|
|
5928
|
+
}
|
|
5929
|
+
if (message.supplyVoltage !== 0) {
|
|
5930
|
+
writer.uint32(21).float(message.supplyVoltage);
|
|
5931
|
+
}
|
|
5932
|
+
if (message.isSupplyVoltageValid !== false) {
|
|
5933
|
+
writer.uint32(64).bool(message.isSupplyVoltageValid);
|
|
5934
|
+
}
|
|
5935
|
+
if (message.temperature !== 0) {
|
|
5936
|
+
writer.uint32(29).float(message.temperature);
|
|
5937
|
+
}
|
|
5938
|
+
if (message.isTemperatureValid !== false) {
|
|
5939
|
+
writer.uint32(72).bool(message.isTemperatureValid);
|
|
5940
|
+
}
|
|
5941
|
+
if (message.humidity !== 0) {
|
|
5942
|
+
writer.uint32(37).float(message.humidity);
|
|
5943
|
+
}
|
|
5944
|
+
if (message.isHumidityValid !== false) {
|
|
5945
|
+
writer.uint32(80).bool(message.isHumidityValid);
|
|
5946
|
+
}
|
|
5947
|
+
if (message.internalPressure !== 0) {
|
|
5948
|
+
writer.uint32(45).float(message.internalPressure);
|
|
5949
|
+
}
|
|
5950
|
+
if (message.isInternalPressureValid !== false) {
|
|
5951
|
+
writer.uint32(88).bool(message.isInternalPressureValid);
|
|
5952
|
+
}
|
|
5953
|
+
if (message.current !== 0) {
|
|
5954
|
+
writer.uint32(53).float(message.current);
|
|
5955
|
+
}
|
|
5956
|
+
if (message.isCurrentValid !== false) {
|
|
5957
|
+
writer.uint32(96).bool(message.isCurrentValid);
|
|
5958
|
+
}
|
|
5959
|
+
if (message.hardwareStatus !== undefined) {
|
|
5960
|
+
ReachHardwareStatus.encode(message.hardwareStatus, writer.uint32(58).fork()).join();
|
|
5961
|
+
}
|
|
5962
|
+
return writer;
|
|
5963
|
+
},
|
|
5964
|
+
decode(input, length) {
|
|
5965
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
5966
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
5967
|
+
const message = createBaseGripperDeviceDiagnostics();
|
|
5968
|
+
while (reader.pos < end) {
|
|
5969
|
+
const tag = reader.uint32();
|
|
5970
|
+
switch (tag >>> 3) {
|
|
5971
|
+
case 1: {
|
|
5972
|
+
if (tag !== 8) {
|
|
5973
|
+
break;
|
|
5974
|
+
}
|
|
5975
|
+
message.address = reader.uint32();
|
|
5976
|
+
continue;
|
|
5977
|
+
}
|
|
5978
|
+
case 2: {
|
|
5979
|
+
if (tag !== 21) {
|
|
5980
|
+
break;
|
|
5981
|
+
}
|
|
5982
|
+
message.supplyVoltage = reader.float();
|
|
5983
|
+
continue;
|
|
5984
|
+
}
|
|
5985
|
+
case 8: {
|
|
5986
|
+
if (tag !== 64) {
|
|
5987
|
+
break;
|
|
5988
|
+
}
|
|
5989
|
+
message.isSupplyVoltageValid = reader.bool();
|
|
5990
|
+
continue;
|
|
5991
|
+
}
|
|
5992
|
+
case 3: {
|
|
5993
|
+
if (tag !== 29) {
|
|
5994
|
+
break;
|
|
5995
|
+
}
|
|
5996
|
+
message.temperature = reader.float();
|
|
5997
|
+
continue;
|
|
5998
|
+
}
|
|
5999
|
+
case 9: {
|
|
6000
|
+
if (tag !== 72) {
|
|
6001
|
+
break;
|
|
6002
|
+
}
|
|
6003
|
+
message.isTemperatureValid = reader.bool();
|
|
6004
|
+
continue;
|
|
6005
|
+
}
|
|
6006
|
+
case 4: {
|
|
6007
|
+
if (tag !== 37) {
|
|
6008
|
+
break;
|
|
6009
|
+
}
|
|
6010
|
+
message.humidity = reader.float();
|
|
6011
|
+
continue;
|
|
6012
|
+
}
|
|
6013
|
+
case 10: {
|
|
6014
|
+
if (tag !== 80) {
|
|
6015
|
+
break;
|
|
6016
|
+
}
|
|
6017
|
+
message.isHumidityValid = reader.bool();
|
|
6018
|
+
continue;
|
|
6019
|
+
}
|
|
6020
|
+
case 5: {
|
|
6021
|
+
if (tag !== 45) {
|
|
6022
|
+
break;
|
|
6023
|
+
}
|
|
6024
|
+
message.internalPressure = reader.float();
|
|
6025
|
+
continue;
|
|
6026
|
+
}
|
|
6027
|
+
case 11: {
|
|
6028
|
+
if (tag !== 88) {
|
|
6029
|
+
break;
|
|
6030
|
+
}
|
|
6031
|
+
message.isInternalPressureValid = reader.bool();
|
|
6032
|
+
continue;
|
|
6033
|
+
}
|
|
6034
|
+
case 6: {
|
|
6035
|
+
if (tag !== 53) {
|
|
6036
|
+
break;
|
|
6037
|
+
}
|
|
6038
|
+
message.current = reader.float();
|
|
6039
|
+
continue;
|
|
6040
|
+
}
|
|
6041
|
+
case 12: {
|
|
6042
|
+
if (tag !== 96) {
|
|
6043
|
+
break;
|
|
6044
|
+
}
|
|
6045
|
+
message.isCurrentValid = reader.bool();
|
|
6046
|
+
continue;
|
|
6047
|
+
}
|
|
6048
|
+
case 7: {
|
|
6049
|
+
if (tag !== 58) {
|
|
6050
|
+
break;
|
|
6051
|
+
}
|
|
6052
|
+
message.hardwareStatus = ReachHardwareStatus.decode(reader, reader.uint32());
|
|
6053
|
+
continue;
|
|
6054
|
+
}
|
|
6055
|
+
}
|
|
6056
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
6057
|
+
break;
|
|
6058
|
+
}
|
|
6059
|
+
reader.skip(tag & 7);
|
|
6060
|
+
}
|
|
6061
|
+
return message;
|
|
6062
|
+
},
|
|
6063
|
+
fromJSON(object) {
|
|
6064
|
+
return {
|
|
6065
|
+
address: isSet(object.address) ? gt.Number(object.address) : 0,
|
|
6066
|
+
supplyVoltage: isSet(object.supplyVoltage) ? gt.Number(object.supplyVoltage) : 0,
|
|
6067
|
+
isSupplyVoltageValid: isSet(object.isSupplyVoltageValid) ? gt.Boolean(object.isSupplyVoltageValid) : false,
|
|
6068
|
+
temperature: isSet(object.temperature) ? gt.Number(object.temperature) : 0,
|
|
6069
|
+
isTemperatureValid: isSet(object.isTemperatureValid) ? gt.Boolean(object.isTemperatureValid) : false,
|
|
6070
|
+
humidity: isSet(object.humidity) ? gt.Number(object.humidity) : 0,
|
|
6071
|
+
isHumidityValid: isSet(object.isHumidityValid) ? gt.Boolean(object.isHumidityValid) : false,
|
|
6072
|
+
internalPressure: isSet(object.internalPressure) ? gt.Number(object.internalPressure) : 0,
|
|
6073
|
+
isInternalPressureValid: isSet(object.isInternalPressureValid)
|
|
6074
|
+
? gt.Boolean(object.isInternalPressureValid)
|
|
6075
|
+
: false,
|
|
6076
|
+
current: isSet(object.current) ? gt.Number(object.current) : 0,
|
|
6077
|
+
isCurrentValid: isSet(object.isCurrentValid) ? gt.Boolean(object.isCurrentValid) : false,
|
|
6078
|
+
hardwareStatus: isSet(object.hardwareStatus) ? ReachHardwareStatus.fromJSON(object.hardwareStatus) : undefined,
|
|
6079
|
+
};
|
|
6080
|
+
},
|
|
6081
|
+
toJSON(message) {
|
|
6082
|
+
const obj = {};
|
|
6083
|
+
if (message.address !== 0) {
|
|
6084
|
+
obj.address = Math.round(message.address);
|
|
6085
|
+
}
|
|
6086
|
+
if (message.supplyVoltage !== 0) {
|
|
6087
|
+
obj.supplyVoltage = message.supplyVoltage;
|
|
6088
|
+
}
|
|
6089
|
+
if (message.isSupplyVoltageValid !== false) {
|
|
6090
|
+
obj.isSupplyVoltageValid = message.isSupplyVoltageValid;
|
|
6091
|
+
}
|
|
6092
|
+
if (message.temperature !== 0) {
|
|
6093
|
+
obj.temperature = message.temperature;
|
|
6094
|
+
}
|
|
6095
|
+
if (message.isTemperatureValid !== false) {
|
|
6096
|
+
obj.isTemperatureValid = message.isTemperatureValid;
|
|
6097
|
+
}
|
|
6098
|
+
if (message.humidity !== 0) {
|
|
6099
|
+
obj.humidity = message.humidity;
|
|
6100
|
+
}
|
|
6101
|
+
if (message.isHumidityValid !== false) {
|
|
6102
|
+
obj.isHumidityValid = message.isHumidityValid;
|
|
6103
|
+
}
|
|
6104
|
+
if (message.internalPressure !== 0) {
|
|
6105
|
+
obj.internalPressure = message.internalPressure;
|
|
6106
|
+
}
|
|
6107
|
+
if (message.isInternalPressureValid !== false) {
|
|
6108
|
+
obj.isInternalPressureValid = message.isInternalPressureValid;
|
|
6109
|
+
}
|
|
6110
|
+
if (message.current !== 0) {
|
|
6111
|
+
obj.current = message.current;
|
|
6112
|
+
}
|
|
6113
|
+
if (message.isCurrentValid !== false) {
|
|
6114
|
+
obj.isCurrentValid = message.isCurrentValid;
|
|
6115
|
+
}
|
|
6116
|
+
if (message.hardwareStatus !== undefined) {
|
|
6117
|
+
obj.hardwareStatus = ReachHardwareStatus.toJSON(message.hardwareStatus);
|
|
6118
|
+
}
|
|
6119
|
+
return obj;
|
|
6120
|
+
},
|
|
6121
|
+
create(base) {
|
|
6122
|
+
return GripperDeviceDiagnostics.fromPartial(base ?? {});
|
|
6123
|
+
},
|
|
6124
|
+
fromPartial(object) {
|
|
6125
|
+
const message = createBaseGripperDeviceDiagnostics();
|
|
6126
|
+
message.address = object.address ?? 0;
|
|
6127
|
+
message.supplyVoltage = object.supplyVoltage ?? 0;
|
|
6128
|
+
message.isSupplyVoltageValid = object.isSupplyVoltageValid ?? false;
|
|
6129
|
+
message.temperature = object.temperature ?? 0;
|
|
6130
|
+
message.isTemperatureValid = object.isTemperatureValid ?? false;
|
|
6131
|
+
message.humidity = object.humidity ?? 0;
|
|
6132
|
+
message.isHumidityValid = object.isHumidityValid ?? false;
|
|
6133
|
+
message.internalPressure = object.internalPressure ?? 0;
|
|
6134
|
+
message.isInternalPressureValid = object.isInternalPressureValid ?? false;
|
|
6135
|
+
message.current = object.current ?? 0;
|
|
6136
|
+
message.isCurrentValid = object.isCurrentValid ?? false;
|
|
6137
|
+
message.hardwareStatus = (object.hardwareStatus !== undefined && object.hardwareStatus !== null)
|
|
6138
|
+
? ReachHardwareStatus.fromPartial(object.hardwareStatus)
|
|
6139
|
+
: undefined;
|
|
6140
|
+
return message;
|
|
6141
|
+
},
|
|
6142
|
+
};
|
|
6143
|
+
function createBaseGripperInfo() {
|
|
6144
|
+
return { guestPortNumber: 0, deviceId: 0, serialNumber: "", modelNumber: "", firmwareVersion: "" };
|
|
6145
|
+
}
|
|
6146
|
+
export const GripperInfo = {
|
|
6147
|
+
encode(message, writer = new BinaryWriter()) {
|
|
6148
|
+
if (message.guestPortNumber !== 0) {
|
|
6149
|
+
writer.uint32(8).int32(message.guestPortNumber);
|
|
6150
|
+
}
|
|
6151
|
+
if (message.deviceId !== 0) {
|
|
6152
|
+
writer.uint32(16).int32(message.deviceId);
|
|
6153
|
+
}
|
|
6154
|
+
if (message.serialNumber !== "") {
|
|
6155
|
+
writer.uint32(26).string(message.serialNumber);
|
|
6156
|
+
}
|
|
6157
|
+
if (message.modelNumber !== "") {
|
|
6158
|
+
writer.uint32(34).string(message.modelNumber);
|
|
6159
|
+
}
|
|
6160
|
+
if (message.firmwareVersion !== "") {
|
|
6161
|
+
writer.uint32(42).string(message.firmwareVersion);
|
|
6162
|
+
}
|
|
6163
|
+
return writer;
|
|
6164
|
+
},
|
|
6165
|
+
decode(input, length) {
|
|
6166
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
6167
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
6168
|
+
const message = createBaseGripperInfo();
|
|
6169
|
+
while (reader.pos < end) {
|
|
6170
|
+
const tag = reader.uint32();
|
|
6171
|
+
switch (tag >>> 3) {
|
|
6172
|
+
case 1: {
|
|
6173
|
+
if (tag !== 8) {
|
|
6174
|
+
break;
|
|
6175
|
+
}
|
|
6176
|
+
message.guestPortNumber = reader.int32();
|
|
6177
|
+
continue;
|
|
6178
|
+
}
|
|
6179
|
+
case 2: {
|
|
6180
|
+
if (tag !== 16) {
|
|
6181
|
+
break;
|
|
6182
|
+
}
|
|
6183
|
+
message.deviceId = reader.int32();
|
|
6184
|
+
continue;
|
|
6185
|
+
}
|
|
6186
|
+
case 3: {
|
|
6187
|
+
if (tag !== 26) {
|
|
6188
|
+
break;
|
|
6189
|
+
}
|
|
6190
|
+
message.serialNumber = reader.string();
|
|
6191
|
+
continue;
|
|
6192
|
+
}
|
|
6193
|
+
case 4: {
|
|
6194
|
+
if (tag !== 34) {
|
|
6195
|
+
break;
|
|
6196
|
+
}
|
|
6197
|
+
message.modelNumber = reader.string();
|
|
6198
|
+
continue;
|
|
6199
|
+
}
|
|
6200
|
+
case 5: {
|
|
6201
|
+
if (tag !== 42) {
|
|
6202
|
+
break;
|
|
6203
|
+
}
|
|
6204
|
+
message.firmwareVersion = reader.string();
|
|
6205
|
+
continue;
|
|
6206
|
+
}
|
|
6207
|
+
}
|
|
6208
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
6209
|
+
break;
|
|
6210
|
+
}
|
|
6211
|
+
reader.skip(tag & 7);
|
|
6212
|
+
}
|
|
6213
|
+
return message;
|
|
6214
|
+
},
|
|
6215
|
+
fromJSON(object) {
|
|
6216
|
+
return {
|
|
6217
|
+
guestPortNumber: isSet(object.guestPortNumber) ? guestPortNumberFromJSON(object.guestPortNumber) : 0,
|
|
6218
|
+
deviceId: isSet(object.deviceId) ? guestPortDeviceIDFromJSON(object.deviceId) : 0,
|
|
6219
|
+
serialNumber: isSet(object.serialNumber) ? gt.String(object.serialNumber) : "",
|
|
6220
|
+
modelNumber: isSet(object.modelNumber) ? gt.String(object.modelNumber) : "",
|
|
6221
|
+
firmwareVersion: isSet(object.firmwareVersion) ? gt.String(object.firmwareVersion) : "",
|
|
6222
|
+
};
|
|
6223
|
+
},
|
|
6224
|
+
toJSON(message) {
|
|
6225
|
+
const obj = {};
|
|
6226
|
+
if (message.guestPortNumber !== 0) {
|
|
6227
|
+
obj.guestPortNumber = guestPortNumberToJSON(message.guestPortNumber);
|
|
6228
|
+
}
|
|
6229
|
+
if (message.deviceId !== 0) {
|
|
6230
|
+
obj.deviceId = guestPortDeviceIDToJSON(message.deviceId);
|
|
6231
|
+
}
|
|
6232
|
+
if (message.serialNumber !== "") {
|
|
6233
|
+
obj.serialNumber = message.serialNumber;
|
|
6234
|
+
}
|
|
6235
|
+
if (message.modelNumber !== "") {
|
|
6236
|
+
obj.modelNumber = message.modelNumber;
|
|
6237
|
+
}
|
|
6238
|
+
if (message.firmwareVersion !== "") {
|
|
6239
|
+
obj.firmwareVersion = message.firmwareVersion;
|
|
6240
|
+
}
|
|
6241
|
+
return obj;
|
|
6242
|
+
},
|
|
6243
|
+
create(base) {
|
|
6244
|
+
return GripperInfo.fromPartial(base ?? {});
|
|
6245
|
+
},
|
|
6246
|
+
fromPartial(object) {
|
|
6247
|
+
const message = createBaseGripperInfo();
|
|
6248
|
+
message.guestPortNumber = object.guestPortNumber ?? 0;
|
|
6249
|
+
message.deviceId = object.deviceId ?? 0;
|
|
6250
|
+
message.serialNumber = object.serialNumber ?? "";
|
|
6251
|
+
message.modelNumber = object.modelNumber ?? "";
|
|
6252
|
+
message.firmwareVersion = object.firmwareVersion ?? "";
|
|
6253
|
+
return message;
|
|
6254
|
+
},
|
|
6255
|
+
};
|
|
6256
|
+
function createBaseGripperDiagnostics() {
|
|
6257
|
+
return { devices: [], guestPortNumber: 0 };
|
|
6258
|
+
}
|
|
6259
|
+
export const GripperDiagnostics = {
|
|
6260
|
+
encode(message, writer = new BinaryWriter()) {
|
|
6261
|
+
for (const v of message.devices) {
|
|
6262
|
+
GripperDeviceDiagnostics.encode(v, writer.uint32(10).fork()).join();
|
|
6263
|
+
}
|
|
6264
|
+
if (message.guestPortNumber !== 0) {
|
|
6265
|
+
writer.uint32(16).int32(message.guestPortNumber);
|
|
6266
|
+
}
|
|
6267
|
+
return writer;
|
|
6268
|
+
},
|
|
6269
|
+
decode(input, length) {
|
|
6270
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
6271
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
6272
|
+
const message = createBaseGripperDiagnostics();
|
|
6273
|
+
while (reader.pos < end) {
|
|
6274
|
+
const tag = reader.uint32();
|
|
6275
|
+
switch (tag >>> 3) {
|
|
6276
|
+
case 1: {
|
|
6277
|
+
if (tag !== 10) {
|
|
6278
|
+
break;
|
|
6279
|
+
}
|
|
6280
|
+
message.devices.push(GripperDeviceDiagnostics.decode(reader, reader.uint32()));
|
|
5413
6281
|
continue;
|
|
5414
6282
|
}
|
|
5415
|
-
case
|
|
5416
|
-
if (tag !==
|
|
6283
|
+
case 2: {
|
|
6284
|
+
if (tag !== 16) {
|
|
5417
6285
|
break;
|
|
5418
6286
|
}
|
|
5419
|
-
message.
|
|
6287
|
+
message.guestPortNumber = reader.int32();
|
|
5420
6288
|
continue;
|
|
5421
6289
|
}
|
|
5422
6290
|
}
|
|
@@ -5429,61 +6297,29 @@ export const Gripper = {
|
|
|
5429
6297
|
},
|
|
5430
6298
|
fromJSON(object) {
|
|
5431
6299
|
return {
|
|
5432
|
-
|
|
5433
|
-
|
|
5434
|
-
? object.jointPositions.map((e) => gt.Number(e))
|
|
6300
|
+
devices: gt.Array.isArray(object?.devices)
|
|
6301
|
+
? object.devices.map((e) => GripperDeviceDiagnostics.fromJSON(e))
|
|
5435
6302
|
: [],
|
|
5436
|
-
|
|
5437
|
-
atLimit: isSet(object.atLimit) ? gt.Boolean(object.atLimit) : false,
|
|
5438
|
-
collision: isSet(object.collision) ? gt.Boolean(object.collision) : false,
|
|
5439
|
-
holding: isSet(object.holding) ? gt.Boolean(object.holding) : false,
|
|
5440
|
-
fault: isSet(object.fault) ? gt.Boolean(object.fault) : false,
|
|
5441
|
-
movingTo: isSet(object.movingTo) ? manipulatorPoseFromJSON(object.movingTo) : 0,
|
|
6303
|
+
guestPortNumber: isSet(object.guestPortNumber) ? guestPortNumberFromJSON(object.guestPortNumber) : 0,
|
|
5442
6304
|
};
|
|
5443
6305
|
},
|
|
5444
6306
|
toJSON(message) {
|
|
5445
6307
|
const obj = {};
|
|
5446
|
-
if (message.
|
|
5447
|
-
obj.
|
|
5448
|
-
}
|
|
5449
|
-
if (message.jointPositions?.length) {
|
|
5450
|
-
obj.jointPositions = message.jointPositions;
|
|
5451
|
-
}
|
|
5452
|
-
if (message.endPosition !== undefined) {
|
|
5453
|
-
obj.endPosition = Vector3.toJSON(message.endPosition);
|
|
5454
|
-
}
|
|
5455
|
-
if (message.atLimit !== false) {
|
|
5456
|
-
obj.atLimit = message.atLimit;
|
|
5457
|
-
}
|
|
5458
|
-
if (message.collision !== false) {
|
|
5459
|
-
obj.collision = message.collision;
|
|
5460
|
-
}
|
|
5461
|
-
if (message.holding !== false) {
|
|
5462
|
-
obj.holding = message.holding;
|
|
5463
|
-
}
|
|
5464
|
-
if (message.fault !== false) {
|
|
5465
|
-
obj.fault = message.fault;
|
|
6308
|
+
if (message.devices?.length) {
|
|
6309
|
+
obj.devices = message.devices.map((e) => GripperDeviceDiagnostics.toJSON(e));
|
|
5466
6310
|
}
|
|
5467
|
-
if (message.
|
|
5468
|
-
obj.
|
|
6311
|
+
if (message.guestPortNumber !== 0) {
|
|
6312
|
+
obj.guestPortNumber = guestPortNumberToJSON(message.guestPortNumber);
|
|
5469
6313
|
}
|
|
5470
6314
|
return obj;
|
|
5471
6315
|
},
|
|
5472
6316
|
create(base) {
|
|
5473
|
-
return
|
|
6317
|
+
return GripperDiagnostics.fromPartial(base ?? {});
|
|
5474
6318
|
},
|
|
5475
6319
|
fromPartial(object) {
|
|
5476
|
-
const message =
|
|
5477
|
-
message.
|
|
5478
|
-
message.
|
|
5479
|
-
message.endPosition = (object.endPosition !== undefined && object.endPosition !== null)
|
|
5480
|
-
? Vector3.fromPartial(object.endPosition)
|
|
5481
|
-
: undefined;
|
|
5482
|
-
message.atLimit = object.atLimit ?? false;
|
|
5483
|
-
message.collision = object.collision ?? false;
|
|
5484
|
-
message.holding = object.holding ?? false;
|
|
5485
|
-
message.fault = object.fault ?? false;
|
|
5486
|
-
message.movingTo = object.movingTo ?? 0;
|
|
6320
|
+
const message = createBaseGripperDiagnostics();
|
|
6321
|
+
message.devices = object.devices?.map((e) => GripperDeviceDiagnostics.fromPartial(e)) || [];
|
|
6322
|
+
message.guestPortNumber = object.guestPortNumber ?? 0;
|
|
5487
6323
|
return message;
|
|
5488
6324
|
},
|
|
5489
6325
|
};
|
|
@@ -11095,6 +11931,8 @@ function createBaseDroneInfo() {
|
|
|
11095
11931
|
cvModels: [],
|
|
11096
11932
|
powerSource: 0,
|
|
11097
11933
|
mainCameraCalibration: undefined,
|
|
11934
|
+
diveNumber: 0,
|
|
11935
|
+
logName: "",
|
|
11098
11936
|
};
|
|
11099
11937
|
}
|
|
11100
11938
|
export const DroneInfo = {
|
|
@@ -11141,6 +11979,12 @@ export const DroneInfo = {
|
|
|
11141
11979
|
if (message.mainCameraCalibration !== undefined) {
|
|
11142
11980
|
CameraCalibration.encode(message.mainCameraCalibration, writer.uint32(114).fork()).join();
|
|
11143
11981
|
}
|
|
11982
|
+
if (message.diveNumber !== 0) {
|
|
11983
|
+
writer.uint32(120).uint32(message.diveNumber);
|
|
11984
|
+
}
|
|
11985
|
+
if (message.logName !== "") {
|
|
11986
|
+
writer.uint32(130).string(message.logName);
|
|
11987
|
+
}
|
|
11144
11988
|
return writer;
|
|
11145
11989
|
},
|
|
11146
11990
|
decode(input, length) {
|
|
@@ -11248,6 +12092,20 @@ export const DroneInfo = {
|
|
|
11248
12092
|
message.mainCameraCalibration = CameraCalibration.decode(reader, reader.uint32());
|
|
11249
12093
|
continue;
|
|
11250
12094
|
}
|
|
12095
|
+
case 15: {
|
|
12096
|
+
if (tag !== 120) {
|
|
12097
|
+
break;
|
|
12098
|
+
}
|
|
12099
|
+
message.diveNumber = reader.uint32();
|
|
12100
|
+
continue;
|
|
12101
|
+
}
|
|
12102
|
+
case 16: {
|
|
12103
|
+
if (tag !== 130) {
|
|
12104
|
+
break;
|
|
12105
|
+
}
|
|
12106
|
+
message.logName = reader.string();
|
|
12107
|
+
continue;
|
|
12108
|
+
}
|
|
11251
12109
|
}
|
|
11252
12110
|
if ((tag & 7) === 4 || tag === 0) {
|
|
11253
12111
|
break;
|
|
@@ -11274,6 +12132,8 @@ export const DroneInfo = {
|
|
|
11274
12132
|
mainCameraCalibration: isSet(object.mainCameraCalibration)
|
|
11275
12133
|
? CameraCalibration.fromJSON(object.mainCameraCalibration)
|
|
11276
12134
|
: undefined,
|
|
12135
|
+
diveNumber: isSet(object.diveNumber) ? gt.Number(object.diveNumber) : 0,
|
|
12136
|
+
logName: isSet(object.logName) ? gt.String(object.logName) : "",
|
|
11277
12137
|
};
|
|
11278
12138
|
},
|
|
11279
12139
|
toJSON(message) {
|
|
@@ -11320,6 +12180,12 @@ export const DroneInfo = {
|
|
|
11320
12180
|
if (message.mainCameraCalibration !== undefined) {
|
|
11321
12181
|
obj.mainCameraCalibration = CameraCalibration.toJSON(message.mainCameraCalibration);
|
|
11322
12182
|
}
|
|
12183
|
+
if (message.diveNumber !== 0) {
|
|
12184
|
+
obj.diveNumber = Math.round(message.diveNumber);
|
|
12185
|
+
}
|
|
12186
|
+
if (message.logName !== "") {
|
|
12187
|
+
obj.logName = message.logName;
|
|
12188
|
+
}
|
|
11323
12189
|
return obj;
|
|
11324
12190
|
},
|
|
11325
12191
|
create(base) {
|
|
@@ -11344,6 +12210,8 @@ export const DroneInfo = {
|
|
|
11344
12210
|
(object.mainCameraCalibration !== undefined && object.mainCameraCalibration !== null)
|
|
11345
12211
|
? CameraCalibration.fromPartial(object.mainCameraCalibration)
|
|
11346
12212
|
: undefined;
|
|
12213
|
+
message.diveNumber = object.diveNumber ?? 0;
|
|
12214
|
+
message.logName = object.logName ?? "";
|
|
11347
12215
|
return message;
|
|
11348
12216
|
},
|
|
11349
12217
|
};
|
|
@@ -19150,7 +20018,7 @@ export const ObjectDetection = {
|
|
|
19150
20018
|
},
|
|
19151
20019
|
};
|
|
19152
20020
|
function createBaseModelDetections() {
|
|
19153
|
-
return { detections: [], camera: 0, imageWidth: 0, imageHeight: 0, modelName: "" };
|
|
20021
|
+
return { detections: [], camera: 0, imageWidth: 0, imageHeight: 0, modelName: "", frameId: 0 };
|
|
19154
20022
|
}
|
|
19155
20023
|
export const ModelDetections = {
|
|
19156
20024
|
encode(message, writer = new BinaryWriter()) {
|
|
@@ -19169,6 +20037,9 @@ export const ModelDetections = {
|
|
|
19169
20037
|
if (message.modelName !== "") {
|
|
19170
20038
|
writer.uint32(42).string(message.modelName);
|
|
19171
20039
|
}
|
|
20040
|
+
if (message.frameId !== 0) {
|
|
20041
|
+
writer.uint32(48).uint64(message.frameId);
|
|
20042
|
+
}
|
|
19172
20043
|
return writer;
|
|
19173
20044
|
},
|
|
19174
20045
|
decode(input, length) {
|
|
@@ -19213,6 +20084,13 @@ export const ModelDetections = {
|
|
|
19213
20084
|
message.modelName = reader.string();
|
|
19214
20085
|
continue;
|
|
19215
20086
|
}
|
|
20087
|
+
case 6: {
|
|
20088
|
+
if (tag !== 48) {
|
|
20089
|
+
break;
|
|
20090
|
+
}
|
|
20091
|
+
message.frameId = longToNumber(reader.uint64());
|
|
20092
|
+
continue;
|
|
20093
|
+
}
|
|
19216
20094
|
}
|
|
19217
20095
|
if ((tag & 7) === 4 || tag === 0) {
|
|
19218
20096
|
break;
|
|
@@ -19230,6 +20108,7 @@ export const ModelDetections = {
|
|
|
19230
20108
|
imageWidth: isSet(object.imageWidth) ? gt.Number(object.imageWidth) : 0,
|
|
19231
20109
|
imageHeight: isSet(object.imageHeight) ? gt.Number(object.imageHeight) : 0,
|
|
19232
20110
|
modelName: isSet(object.modelName) ? gt.String(object.modelName) : "",
|
|
20111
|
+
frameId: isSet(object.frameId) ? gt.Number(object.frameId) : 0,
|
|
19233
20112
|
};
|
|
19234
20113
|
},
|
|
19235
20114
|
toJSON(message) {
|
|
@@ -19249,6 +20128,9 @@ export const ModelDetections = {
|
|
|
19249
20128
|
if (message.modelName !== "") {
|
|
19250
20129
|
obj.modelName = message.modelName;
|
|
19251
20130
|
}
|
|
20131
|
+
if (message.frameId !== 0) {
|
|
20132
|
+
obj.frameId = Math.round(message.frameId);
|
|
20133
|
+
}
|
|
19252
20134
|
return obj;
|
|
19253
20135
|
},
|
|
19254
20136
|
create(base) {
|
|
@@ -19261,6 +20143,7 @@ export const ModelDetections = {
|
|
|
19261
20143
|
message.imageWidth = object.imageWidth ?? 0;
|
|
19262
20144
|
message.imageHeight = object.imageHeight ?? 0;
|
|
19263
20145
|
message.modelName = object.modelName ?? "";
|
|
20146
|
+
message.frameId = object.frameId ?? 0;
|
|
19264
20147
|
return message;
|
|
19265
20148
|
},
|
|
19266
20149
|
};
|
|
@@ -19552,7 +20435,18 @@ export const OperatorInfo = {
|
|
|
19552
20435
|
},
|
|
19553
20436
|
};
|
|
19554
20437
|
function createBaseSotState() {
|
|
19555
|
-
return {
|
|
20438
|
+
return {
|
|
20439
|
+
state: 0,
|
|
20440
|
+
boundingBox: undefined,
|
|
20441
|
+
imageWidth: 0,
|
|
20442
|
+
imageHeight: 0,
|
|
20443
|
+
confidence: 0,
|
|
20444
|
+
vx: 0,
|
|
20445
|
+
vy: 0,
|
|
20446
|
+
vs: 0,
|
|
20447
|
+
vr: 0,
|
|
20448
|
+
frameId: 0,
|
|
20449
|
+
};
|
|
19556
20450
|
}
|
|
19557
20451
|
export const SotState = {
|
|
19558
20452
|
encode(message, writer = new BinaryWriter()) {
|
|
@@ -19583,6 +20477,9 @@ export const SotState = {
|
|
|
19583
20477
|
if (message.vr !== 0) {
|
|
19584
20478
|
writer.uint32(77).float(message.vr);
|
|
19585
20479
|
}
|
|
20480
|
+
if (message.frameId !== 0) {
|
|
20481
|
+
writer.uint32(80).uint64(message.frameId);
|
|
20482
|
+
}
|
|
19586
20483
|
return writer;
|
|
19587
20484
|
},
|
|
19588
20485
|
decode(input, length) {
|
|
@@ -19655,6 +20552,13 @@ export const SotState = {
|
|
|
19655
20552
|
message.vr = reader.float();
|
|
19656
20553
|
continue;
|
|
19657
20554
|
}
|
|
20555
|
+
case 10: {
|
|
20556
|
+
if (tag !== 80) {
|
|
20557
|
+
break;
|
|
20558
|
+
}
|
|
20559
|
+
message.frameId = longToNumber(reader.uint64());
|
|
20560
|
+
continue;
|
|
20561
|
+
}
|
|
19658
20562
|
}
|
|
19659
20563
|
if ((tag & 7) === 4 || tag === 0) {
|
|
19660
20564
|
break;
|
|
@@ -19674,6 +20578,7 @@ export const SotState = {
|
|
|
19674
20578
|
vy: isSet(object.vy) ? gt.Number(object.vy) : 0,
|
|
19675
20579
|
vs: isSet(object.vs) ? gt.Number(object.vs) : 0,
|
|
19676
20580
|
vr: isSet(object.vr) ? gt.Number(object.vr) : 0,
|
|
20581
|
+
frameId: isSet(object.frameId) ? gt.Number(object.frameId) : 0,
|
|
19677
20582
|
};
|
|
19678
20583
|
},
|
|
19679
20584
|
toJSON(message) {
|
|
@@ -19705,6 +20610,9 @@ export const SotState = {
|
|
|
19705
20610
|
if (message.vr !== 0) {
|
|
19706
20611
|
obj.vr = message.vr;
|
|
19707
20612
|
}
|
|
20613
|
+
if (message.frameId !== 0) {
|
|
20614
|
+
obj.frameId = Math.round(message.frameId);
|
|
20615
|
+
}
|
|
19708
20616
|
return obj;
|
|
19709
20617
|
},
|
|
19710
20618
|
create(base) {
|
|
@@ -19723,6 +20631,7 @@ export const SotState = {
|
|
|
19723
20631
|
message.vy = object.vy ?? 0;
|
|
19724
20632
|
message.vs = object.vs ?? 0;
|
|
19725
20633
|
message.vr = object.vr ?? 0;
|
|
20634
|
+
message.frameId = object.frameId ?? 0;
|
|
19726
20635
|
return message;
|
|
19727
20636
|
},
|
|
19728
20637
|
};
|
|
@@ -19895,6 +20804,187 @@ export const Annotation = {
|
|
|
19895
20804
|
return message;
|
|
19896
20805
|
},
|
|
19897
20806
|
};
|
|
20807
|
+
function createBaseQuaternion() {
|
|
20808
|
+
return { x: 0, y: 0, z: 0, w: 0 };
|
|
20809
|
+
}
|
|
20810
|
+
export const Quaternion = {
|
|
20811
|
+
encode(message, writer = new BinaryWriter()) {
|
|
20812
|
+
if (message.x !== 0) {
|
|
20813
|
+
writer.uint32(9).double(message.x);
|
|
20814
|
+
}
|
|
20815
|
+
if (message.y !== 0) {
|
|
20816
|
+
writer.uint32(17).double(message.y);
|
|
20817
|
+
}
|
|
20818
|
+
if (message.z !== 0) {
|
|
20819
|
+
writer.uint32(25).double(message.z);
|
|
20820
|
+
}
|
|
20821
|
+
if (message.w !== 0) {
|
|
20822
|
+
writer.uint32(33).double(message.w);
|
|
20823
|
+
}
|
|
20824
|
+
return writer;
|
|
20825
|
+
},
|
|
20826
|
+
decode(input, length) {
|
|
20827
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
20828
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
20829
|
+
const message = createBaseQuaternion();
|
|
20830
|
+
while (reader.pos < end) {
|
|
20831
|
+
const tag = reader.uint32();
|
|
20832
|
+
switch (tag >>> 3) {
|
|
20833
|
+
case 1: {
|
|
20834
|
+
if (tag !== 9) {
|
|
20835
|
+
break;
|
|
20836
|
+
}
|
|
20837
|
+
message.x = reader.double();
|
|
20838
|
+
continue;
|
|
20839
|
+
}
|
|
20840
|
+
case 2: {
|
|
20841
|
+
if (tag !== 17) {
|
|
20842
|
+
break;
|
|
20843
|
+
}
|
|
20844
|
+
message.y = reader.double();
|
|
20845
|
+
continue;
|
|
20846
|
+
}
|
|
20847
|
+
case 3: {
|
|
20848
|
+
if (tag !== 25) {
|
|
20849
|
+
break;
|
|
20850
|
+
}
|
|
20851
|
+
message.z = reader.double();
|
|
20852
|
+
continue;
|
|
20853
|
+
}
|
|
20854
|
+
case 4: {
|
|
20855
|
+
if (tag !== 33) {
|
|
20856
|
+
break;
|
|
20857
|
+
}
|
|
20858
|
+
message.w = reader.double();
|
|
20859
|
+
continue;
|
|
20860
|
+
}
|
|
20861
|
+
}
|
|
20862
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
20863
|
+
break;
|
|
20864
|
+
}
|
|
20865
|
+
reader.skip(tag & 7);
|
|
20866
|
+
}
|
|
20867
|
+
return message;
|
|
20868
|
+
},
|
|
20869
|
+
fromJSON(object) {
|
|
20870
|
+
return {
|
|
20871
|
+
x: isSet(object.x) ? gt.Number(object.x) : 0,
|
|
20872
|
+
y: isSet(object.y) ? gt.Number(object.y) : 0,
|
|
20873
|
+
z: isSet(object.z) ? gt.Number(object.z) : 0,
|
|
20874
|
+
w: isSet(object.w) ? gt.Number(object.w) : 0,
|
|
20875
|
+
};
|
|
20876
|
+
},
|
|
20877
|
+
toJSON(message) {
|
|
20878
|
+
const obj = {};
|
|
20879
|
+
if (message.x !== 0) {
|
|
20880
|
+
obj.x = message.x;
|
|
20881
|
+
}
|
|
20882
|
+
if (message.y !== 0) {
|
|
20883
|
+
obj.y = message.y;
|
|
20884
|
+
}
|
|
20885
|
+
if (message.z !== 0) {
|
|
20886
|
+
obj.z = message.z;
|
|
20887
|
+
}
|
|
20888
|
+
if (message.w !== 0) {
|
|
20889
|
+
obj.w = message.w;
|
|
20890
|
+
}
|
|
20891
|
+
return obj;
|
|
20892
|
+
},
|
|
20893
|
+
create(base) {
|
|
20894
|
+
return Quaternion.fromPartial(base ?? {});
|
|
20895
|
+
},
|
|
20896
|
+
fromPartial(object) {
|
|
20897
|
+
const message = createBaseQuaternion();
|
|
20898
|
+
message.x = object.x ?? 0;
|
|
20899
|
+
message.y = object.y ?? 0;
|
|
20900
|
+
message.z = object.z ?? 0;
|
|
20901
|
+
message.w = object.w ?? 0;
|
|
20902
|
+
return message;
|
|
20903
|
+
},
|
|
20904
|
+
};
|
|
20905
|
+
function createBasePointCloud() {
|
|
20906
|
+
return { count: 0, positions: new Uint8Array(0), intensities: new Uint8Array(0) };
|
|
20907
|
+
}
|
|
20908
|
+
export const PointCloud = {
|
|
20909
|
+
encode(message, writer = new BinaryWriter()) {
|
|
20910
|
+
if (message.count !== 0) {
|
|
20911
|
+
writer.uint32(8).uint32(message.count);
|
|
20912
|
+
}
|
|
20913
|
+
if (message.positions.length !== 0) {
|
|
20914
|
+
writer.uint32(18).bytes(message.positions);
|
|
20915
|
+
}
|
|
20916
|
+
if (message.intensities.length !== 0) {
|
|
20917
|
+
writer.uint32(26).bytes(message.intensities);
|
|
20918
|
+
}
|
|
20919
|
+
return writer;
|
|
20920
|
+
},
|
|
20921
|
+
decode(input, length) {
|
|
20922
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
20923
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
20924
|
+
const message = createBasePointCloud();
|
|
20925
|
+
while (reader.pos < end) {
|
|
20926
|
+
const tag = reader.uint32();
|
|
20927
|
+
switch (tag >>> 3) {
|
|
20928
|
+
case 1: {
|
|
20929
|
+
if (tag !== 8) {
|
|
20930
|
+
break;
|
|
20931
|
+
}
|
|
20932
|
+
message.count = reader.uint32();
|
|
20933
|
+
continue;
|
|
20934
|
+
}
|
|
20935
|
+
case 2: {
|
|
20936
|
+
if (tag !== 18) {
|
|
20937
|
+
break;
|
|
20938
|
+
}
|
|
20939
|
+
message.positions = reader.bytes();
|
|
20940
|
+
continue;
|
|
20941
|
+
}
|
|
20942
|
+
case 3: {
|
|
20943
|
+
if (tag !== 26) {
|
|
20944
|
+
break;
|
|
20945
|
+
}
|
|
20946
|
+
message.intensities = reader.bytes();
|
|
20947
|
+
continue;
|
|
20948
|
+
}
|
|
20949
|
+
}
|
|
20950
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
20951
|
+
break;
|
|
20952
|
+
}
|
|
20953
|
+
reader.skip(tag & 7);
|
|
20954
|
+
}
|
|
20955
|
+
return message;
|
|
20956
|
+
},
|
|
20957
|
+
fromJSON(object) {
|
|
20958
|
+
return {
|
|
20959
|
+
count: isSet(object.count) ? gt.Number(object.count) : 0,
|
|
20960
|
+
positions: isSet(object.positions) ? bytesFromBase64(object.positions) : new Uint8Array(0),
|
|
20961
|
+
intensities: isSet(object.intensities) ? bytesFromBase64(object.intensities) : new Uint8Array(0),
|
|
20962
|
+
};
|
|
20963
|
+
},
|
|
20964
|
+
toJSON(message) {
|
|
20965
|
+
const obj = {};
|
|
20966
|
+
if (message.count !== 0) {
|
|
20967
|
+
obj.count = Math.round(message.count);
|
|
20968
|
+
}
|
|
20969
|
+
if (message.positions.length !== 0) {
|
|
20970
|
+
obj.positions = base64FromBytes(message.positions);
|
|
20971
|
+
}
|
|
20972
|
+
if (message.intensities.length !== 0) {
|
|
20973
|
+
obj.intensities = base64FromBytes(message.intensities);
|
|
20974
|
+
}
|
|
20975
|
+
return obj;
|
|
20976
|
+
},
|
|
20977
|
+
create(base) {
|
|
20978
|
+
return PointCloud.fromPartial(base ?? {});
|
|
20979
|
+
},
|
|
20980
|
+
fromPartial(object) {
|
|
20981
|
+
const message = createBasePointCloud();
|
|
20982
|
+
message.count = object.count ?? 0;
|
|
20983
|
+
message.positions = object.positions ?? new Uint8Array(0);
|
|
20984
|
+
message.intensities = object.intensities ?? new Uint8Array(0);
|
|
20985
|
+
return message;
|
|
20986
|
+
},
|
|
20987
|
+
};
|
|
19898
20988
|
const gt = (() => {
|
|
19899
20989
|
if (typeof globalThis !== "undefined") {
|
|
19900
20990
|
return globalThis;
|