From 7fb914e6d3d05e6574eb93618b7c295d092dec0d Mon Sep 17 00:00:00 2001 From: loucass003 Date: Tue, 16 Dec 2025 14:20:32 +0100 Subject: [PATCH] Packet Loss data --- .../generated/all_generated.h | 34 ++++++++++++- .../hardware_info/HardwareStatus.java | 32 ++++++++++-- .../hardware_info/HardwareStatusT.java | 18 +++++++ .../datatypes/hardware_info/HardwareStatus.kt | 30 +++++++++-- .../hardware_status_generated.rs | 51 +++++++++++++++++++ .../hardware-info/hardware-status.ts | 48 +++++++++++++++-- schema/datatypes/hardware_info.fbs | 4 ++ 7 files changed, 205 insertions(+), 12 deletions(-) diff --git a/protocol/cpp/include/solarxr_protocol/generated/all_generated.h b/protocol/cpp/include/solarxr_protocol/generated/all_generated.h index d8c526ae..cde4f948 100644 --- a/protocol/cpp/include/solarxr_protocol/generated/all_generated.h +++ b/protocol/cpp/include/solarxr_protocol/generated/all_generated.h @@ -3626,7 +3626,10 @@ struct HardwareStatus FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VT_MCU_TEMP = 12, VT_BATTERY_VOLTAGE = 14, VT_BATTERY_PCT_ESTIMATE = 16, - VT_LOG_DATA = 18 + VT_LOG_DATA = 18, + VT_PACKET_LOSS = 20, + VT_PACKETS_LOST = 22, + VT_PACKETS_RECEIVED = 24 }; flatbuffers::Optional error_status() const { return GetOptional(VT_ERROR_STATUS); @@ -3651,6 +3654,15 @@ struct HardwareStatus FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { const solarxr_protocol::datatypes::LogData *log_data() const { return GetPointer(VT_LOG_DATA); } + flatbuffers::Optional packet_loss() const { + return GetOptional(VT_PACKET_LOSS); + } + flatbuffers::Optional packets_lost() const { + return GetOptional(VT_PACKETS_LOST); + } + flatbuffers::Optional packets_received() const { + return GetOptional(VT_PACKETS_RECEIVED); + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_ERROR_STATUS, 1) && @@ -3661,6 +3673,9 @@ struct HardwareStatus FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VerifyField(verifier, VT_BATTERY_PCT_ESTIMATE, 1) && VerifyOffset(verifier, VT_LOG_DATA) && verifier.VerifyTable(log_data()) && + VerifyField(verifier, VT_PACKET_LOSS, 4) && + VerifyField(verifier, VT_PACKETS_LOST, 4) && + VerifyField(verifier, VT_PACKETS_RECEIVED, 4) && verifier.EndTable(); } }; @@ -3690,6 +3705,15 @@ struct HardwareStatusBuilder { void add_log_data(flatbuffers::Offset log_data) { fbb_.AddOffset(HardwareStatus::VT_LOG_DATA, log_data); } + void add_packet_loss(float packet_loss) { + fbb_.AddElement(HardwareStatus::VT_PACKET_LOSS, packet_loss); + } + void add_packets_lost(int32_t packets_lost) { + fbb_.AddElement(HardwareStatus::VT_PACKETS_LOST, packets_lost); + } + void add_packets_received(int32_t packets_received) { + fbb_.AddElement(HardwareStatus::VT_PACKETS_RECEIVED, packets_received); + } explicit HardwareStatusBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); @@ -3709,8 +3733,14 @@ inline flatbuffers::Offset CreateHardwareStatus( flatbuffers::Optional mcu_temp = flatbuffers::nullopt, flatbuffers::Optional battery_voltage = flatbuffers::nullopt, flatbuffers::Optional battery_pct_estimate = flatbuffers::nullopt, - flatbuffers::Offset log_data = 0) { + flatbuffers::Offset log_data = 0, + flatbuffers::Optional packet_loss = flatbuffers::nullopt, + flatbuffers::Optional packets_lost = flatbuffers::nullopt, + flatbuffers::Optional packets_received = flatbuffers::nullopt) { HardwareStatusBuilder builder_(_fbb); + if(packets_received) { builder_.add_packets_received(*packets_received); } + if(packets_lost) { builder_.add_packets_lost(*packets_lost); } + if(packet_loss) { builder_.add_packet_loss(*packet_loss); } builder_.add_log_data(log_data); if(battery_voltage) { builder_.add_battery_voltage(*battery_voltage); } if(mcu_temp) { builder_.add_mcu_temp(*mcu_temp); } diff --git a/protocol/java/src/solarxr_protocol/datatypes/hardware_info/HardwareStatus.java b/protocol/java/src/solarxr_protocol/datatypes/hardware_info/HardwareStatus.java index 371c9734..e7f4fcd0 100644 --- a/protocol/java/src/solarxr_protocol/datatypes/hardware_info/HardwareStatus.java +++ b/protocol/java/src/solarxr_protocol/datatypes/hardware_info/HardwareStatus.java @@ -38,6 +38,12 @@ public final class HardwareStatus extends Table { public int batteryPctEstimate() { int o = __offset(16); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } public solarxr_protocol.datatypes.LogData logData() { return logData(new solarxr_protocol.datatypes.LogData()); } public solarxr_protocol.datatypes.LogData logData(solarxr_protocol.datatypes.LogData obj) { int o = __offset(18); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } + public boolean hasPacketLoss() { return 0 != __offset(20); } + public float packetLoss() { int o = __offset(20); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; } + public boolean hasPacketsLost() { return 0 != __offset(22); } + public int packetsLost() { int o = __offset(22); return o != 0 ? bb.getInt(o + bb_pos) : 0; } + public boolean hasPacketsReceived() { return 0 != __offset(24); } + public int packetsReceived() { int o = __offset(24); return o != 0 ? bb.getInt(o + bb_pos) : 0; } public static int createHardwareStatus(FlatBufferBuilder builder, int errorStatus, @@ -46,8 +52,14 @@ public static int createHardwareStatus(FlatBufferBuilder builder, float mcuTemp, float batteryVoltage, int batteryPctEstimate, - int logDataOffset) { - builder.startTable(8); + int logDataOffset, + float packetLoss, + int packetsLost, + int packetsReceived) { + builder.startTable(11); + HardwareStatus.addPacketsReceived(builder, packetsReceived); + HardwareStatus.addPacketsLost(builder, packetsLost); + HardwareStatus.addPacketLoss(builder, packetLoss); HardwareStatus.addLogData(builder, logDataOffset); HardwareStatus.addBatteryVoltage(builder, batteryVoltage); HardwareStatus.addMcuTemp(builder, mcuTemp); @@ -58,7 +70,7 @@ public static int createHardwareStatus(FlatBufferBuilder builder, return HardwareStatus.endHardwareStatus(builder); } - public static void startHardwareStatus(FlatBufferBuilder builder) { builder.startTable(8); } + public static void startHardwareStatus(FlatBufferBuilder builder) { builder.startTable(11); } public static void addErrorStatus(FlatBufferBuilder builder, int errorStatus) { builder.addByte(0, (byte) errorStatus, (byte) 0); } public static void addPing(FlatBufferBuilder builder, int ping) { builder.addShort(2, (short) ping, (short) 0); } public static void addRssi(FlatBufferBuilder builder, short rssi) { builder.addShort(3, rssi, 0); } @@ -66,6 +78,9 @@ public static int createHardwareStatus(FlatBufferBuilder builder, public static void addBatteryVoltage(FlatBufferBuilder builder, float batteryVoltage) { builder.addFloat(5, batteryVoltage, 0f); } public static void addBatteryPctEstimate(FlatBufferBuilder builder, int batteryPctEstimate) { builder.addByte(6, (byte) batteryPctEstimate, (byte) 0); } public static void addLogData(FlatBufferBuilder builder, int logDataOffset) { builder.addOffset(7, logDataOffset, 0); } + public static void addPacketLoss(FlatBufferBuilder builder, float packetLoss) { builder.addFloat(8, packetLoss, 0f); } + public static void addPacketsLost(FlatBufferBuilder builder, int packetsLost) { builder.addInt(9, packetsLost, 0); } + public static void addPacketsReceived(FlatBufferBuilder builder, int packetsReceived) { builder.addInt(10, packetsReceived, 0); } public static int endHardwareStatus(FlatBufferBuilder builder) { int o = builder.endTable(); return o; @@ -97,6 +112,12 @@ public void unpackTo(HardwareStatusT _o) { _o.setBatteryPctEstimate(_oBatteryPctEstimate); if (logData() != null) _o.setLogData(logData().unpack()); else _o.setLogData(null); + Float _oPacketLoss = hasPacketLoss() ? packetLoss() : null; + _o.setPacketLoss(_oPacketLoss); + Integer _oPacketsLost = hasPacketsLost() ? packetsLost() : null; + _o.setPacketsLost(_oPacketsLost); + Integer _oPacketsReceived = hasPacketsReceived() ? packetsReceived() : null; + _o.setPacketsReceived(_oPacketsReceived); } public static int pack(FlatBufferBuilder builder, HardwareStatusT _o) { if (_o == null) return 0; @@ -109,7 +130,10 @@ public static int pack(FlatBufferBuilder builder, HardwareStatusT _o) { _o.getMcuTemp(), _o.getBatteryVoltage(), _o.getBatteryPctEstimate(), - _logData); + _logData, + _o.getPacketLoss(), + _o.getPacketsLost(), + _o.getPacketsReceived()); } } diff --git a/protocol/java/src/solarxr_protocol/datatypes/hardware_info/HardwareStatusT.java b/protocol/java/src/solarxr_protocol/datatypes/hardware_info/HardwareStatusT.java index 9df8f160..e7316111 100644 --- a/protocol/java/src/solarxr_protocol/datatypes/hardware_info/HardwareStatusT.java +++ b/protocol/java/src/solarxr_protocol/datatypes/hardware_info/HardwareStatusT.java @@ -15,6 +15,9 @@ public class HardwareStatusT { private Float batteryVoltage; private Integer batteryPctEstimate; private solarxr_protocol.datatypes.LogDataT logData; + private Float packetLoss; + private Integer packetsLost; + private Integer packetsReceived; public Integer getErrorStatus() { return errorStatus; } @@ -44,6 +47,18 @@ public class HardwareStatusT { public void setLogData(solarxr_protocol.datatypes.LogDataT logData) { this.logData = logData; } + public Float getPacketLoss() { return packetLoss; } + + public void setPacketLoss(Float packetLoss) { this.packetLoss = packetLoss; } + + public Integer getPacketsLost() { return packetsLost; } + + public void setPacketsLost(Integer packetsLost) { this.packetsLost = packetsLost; } + + public Integer getPacketsReceived() { return packetsReceived; } + + public void setPacketsReceived(Integer packetsReceived) { this.packetsReceived = packetsReceived; } + public HardwareStatusT() { this.errorStatus = null; @@ -53,6 +68,9 @@ public HardwareStatusT() { this.batteryVoltage = null; this.batteryPctEstimate = null; this.logData = null; + this.packetLoss = null; + this.packetsLost = null; + this.packetsReceived = null; } } diff --git a/protocol/kotlin/src/solarxr_protocol/datatypes/hardware_info/HardwareStatus.kt b/protocol/kotlin/src/solarxr_protocol/datatypes/hardware_info/HardwareStatus.kt index 52bc7843..6d4dd3be 100644 --- a/protocol/kotlin/src/solarxr_protocol/datatypes/hardware_info/HardwareStatus.kt +++ b/protocol/kotlin/src/solarxr_protocol/datatypes/hardware_info/HardwareStatus.kt @@ -64,6 +64,21 @@ class HardwareStatus : Table() { null } } + val packetLoss : Float? + get() { + val o = __offset(20) + return if(o != 0) bb.getFloat(o + bb_pos) else null + } + val packetsLost : Int? + get() { + val o = __offset(22) + return if(o != 0) bb.getInt(o + bb_pos) else null + } + val packetsReceived : Int? + get() { + val o = __offset(24) + return if(o != 0) bb.getInt(o + bb_pos) else null + } companion object { @JvmStatic fun validateVersion() = Constants.FLATBUFFERS_22_10_26() @@ -75,8 +90,11 @@ class HardwareStatus : Table() { return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) } @JvmStatic - fun createHardwareStatus(builder: FlatBufferBuilder, errorStatus: UByte?, ping: UShort?, rssi: Short?, mcuTemp: Float?, batteryVoltage: Float?, batteryPctEstimate: UByte?, logDataOffset: Int) : Int { - builder.startTable(8) + fun createHardwareStatus(builder: FlatBufferBuilder, errorStatus: UByte?, ping: UShort?, rssi: Short?, mcuTemp: Float?, batteryVoltage: Float?, batteryPctEstimate: UByte?, logDataOffset: Int, packetLoss: Float?, packetsLost: Int?, packetsReceived: Int?) : Int { + builder.startTable(11) + packetsReceived?.run { addPacketsReceived(builder, packetsReceived) } + packetsLost?.run { addPacketsLost(builder, packetsLost) } + packetLoss?.run { addPacketLoss(builder, packetLoss) } addLogData(builder, logDataOffset) batteryVoltage?.run { addBatteryVoltage(builder, batteryVoltage) } mcuTemp?.run { addMcuTemp(builder, mcuTemp) } @@ -87,7 +105,7 @@ class HardwareStatus : Table() { return endHardwareStatus(builder) } @JvmStatic - fun startHardwareStatus(builder: FlatBufferBuilder) = builder.startTable(8) + fun startHardwareStatus(builder: FlatBufferBuilder) = builder.startTable(11) @JvmStatic fun addErrorStatus(builder: FlatBufferBuilder, errorStatus: UByte) = builder.addByte(0, errorStatus.toByte(), 0) @JvmStatic @@ -103,6 +121,12 @@ class HardwareStatus : Table() { @JvmStatic fun addLogData(builder: FlatBufferBuilder, logData: Int) = builder.addOffset(7, logData, 0) @JvmStatic + fun addPacketLoss(builder: FlatBufferBuilder, packetLoss: Float) = builder.addFloat(8, packetLoss, 0.0) + @JvmStatic + fun addPacketsLost(builder: FlatBufferBuilder, packetsLost: Int) = builder.addInt(9, packetsLost, 0) + @JvmStatic + fun addPacketsReceived(builder: FlatBufferBuilder, packetsReceived: Int) = builder.addInt(10, packetsReceived, 0) + @JvmStatic fun endHardwareStatus(builder: FlatBufferBuilder) : Int { val o = builder.endTable() return o diff --git a/protocol/rust/src/generated/solarxr_protocol/datatypes/hardware_info/hardware_status_generated.rs b/protocol/rust/src/generated/solarxr_protocol/datatypes/hardware_info/hardware_status_generated.rs index 5012668d..7852533f 100644 --- a/protocol/rust/src/generated/solarxr_protocol/datatypes/hardware_info/hardware_status_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/datatypes/hardware_info/hardware_status_generated.rs @@ -33,6 +33,9 @@ impl<'a> HardwareStatus<'a> { pub const VT_BATTERY_VOLTAGE: flatbuffers::VOffsetT = 14; pub const VT_BATTERY_PCT_ESTIMATE: flatbuffers::VOffsetT = 16; pub const VT_LOG_DATA: flatbuffers::VOffsetT = 18; + pub const VT_PACKET_LOSS: flatbuffers::VOffsetT = 20; + pub const VT_PACKETS_LOST: flatbuffers::VOffsetT = 22; + pub const VT_PACKETS_RECEIVED: flatbuffers::VOffsetT = 24; #[inline] pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { @@ -44,6 +47,9 @@ impl<'a> HardwareStatus<'a> { args: &'args HardwareStatusArgs<'args> ) -> flatbuffers::WIPOffset> { let mut builder = HardwareStatusBuilder::new(_fbb); + if let Some(x) = args.packets_received { builder.add_packets_received(x); } + if let Some(x) = args.packets_lost { builder.add_packets_lost(x); } + if let Some(x) = args.packet_loss { builder.add_packet_loss(x); } if let Some(x) = args.log_data { builder.add_log_data(x); } if let Some(x) = args.battery_voltage { builder.add_battery_voltage(x); } if let Some(x) = args.mcu_temp { builder.add_mcu_temp(x); } @@ -106,6 +112,27 @@ impl<'a> HardwareStatus<'a> { // which contains a valid value in this slot unsafe { self._tab.get::>(HardwareStatus::VT_LOG_DATA, None)} } + #[inline] + pub fn packet_loss(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(HardwareStatus::VT_PACKET_LOSS, None)} + } + #[inline] + pub fn packets_lost(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(HardwareStatus::VT_PACKETS_LOST, None)} + } + #[inline] + pub fn packets_received(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(HardwareStatus::VT_PACKETS_RECEIVED, None)} + } } impl flatbuffers::Verifiable for HardwareStatus<'_> { @@ -122,6 +149,9 @@ impl flatbuffers::Verifiable for HardwareStatus<'_> { .visit_field::("battery_voltage", Self::VT_BATTERY_VOLTAGE, false)? .visit_field::("battery_pct_estimate", Self::VT_BATTERY_PCT_ESTIMATE, false)? .visit_field::>("log_data", Self::VT_LOG_DATA, false)? + .visit_field::("packet_loss", Self::VT_PACKET_LOSS, false)? + .visit_field::("packets_lost", Self::VT_PACKETS_LOST, false)? + .visit_field::("packets_received", Self::VT_PACKETS_RECEIVED, false)? .finish(); Ok(()) } @@ -134,6 +164,9 @@ pub struct HardwareStatusArgs<'a> { pub battery_voltage: Option, pub battery_pct_estimate: Option, pub log_data: Option>>, + pub packet_loss: Option, + pub packets_lost: Option, + pub packets_received: Option, } impl<'a> Default for HardwareStatusArgs<'a> { #[inline] @@ -146,6 +179,9 @@ impl<'a> Default for HardwareStatusArgs<'a> { battery_voltage: None, battery_pct_estimate: None, log_data: None, + packet_loss: None, + packets_lost: None, + packets_received: None, } } } @@ -184,6 +220,18 @@ impl<'a: 'b, 'b> HardwareStatusBuilder<'a, 'b> { self.fbb_.push_slot_always::>(HardwareStatus::VT_LOG_DATA, log_data); } #[inline] + pub fn add_packet_loss(&mut self, packet_loss: f32) { + self.fbb_.push_slot_always::(HardwareStatus::VT_PACKET_LOSS, packet_loss); + } + #[inline] + pub fn add_packets_lost(&mut self, packets_lost: i32) { + self.fbb_.push_slot_always::(HardwareStatus::VT_PACKETS_LOST, packets_lost); + } + #[inline] + pub fn add_packets_received(&mut self, packets_received: i32) { + self.fbb_.push_slot_always::(HardwareStatus::VT_PACKETS_RECEIVED, packets_received); + } + #[inline] pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> HardwareStatusBuilder<'a, 'b> { let start = _fbb.start_table(); HardwareStatusBuilder { @@ -208,6 +256,9 @@ impl core::fmt::Debug for HardwareStatus<'_> { ds.field("battery_voltage", &self.battery_voltage()); ds.field("battery_pct_estimate", &self.battery_pct_estimate()); ds.field("log_data", &self.log_data()); + ds.field("packet_loss", &self.packet_loss()); + ds.field("packets_lost", &self.packets_lost()); + ds.field("packets_received", &self.packets_received()); ds.finish() } } diff --git a/protocol/typescript/src/solarxr-protocol/datatypes/hardware-info/hardware-status.ts b/protocol/typescript/src/solarxr-protocol/datatypes/hardware-info/hardware-status.ts index 0890b859..27599a14 100644 --- a/protocol/typescript/src/solarxr-protocol/datatypes/hardware-info/hardware-status.ts +++ b/protocol/typescript/src/solarxr-protocol/datatypes/hardware-info/hardware-status.ts @@ -68,8 +68,23 @@ logData(obj?:LogData):LogData|null { return offset ? (obj || new LogData()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; } +packetLoss():number|null { + const offset = this.bb!.__offset(this.bb_pos, 20); + return offset ? this.bb!.readFloat32(this.bb_pos + offset) : null; +} + +packetsLost():number|null { + const offset = this.bb!.__offset(this.bb_pos, 22); + return offset ? this.bb!.readInt32(this.bb_pos + offset) : null; +} + +packetsReceived():number|null { + const offset = this.bb!.__offset(this.bb_pos, 24); + return offset ? this.bb!.readInt32(this.bb_pos + offset) : null; +} + static startHardwareStatus(builder:flatbuffers.Builder) { - builder.startObject(8); + builder.startObject(11); } static addErrorStatus(builder:flatbuffers.Builder, errorStatus:FirmwareErrorCode) { @@ -100,6 +115,18 @@ static addLogData(builder:flatbuffers.Builder, logDataOffset:flatbuffers.Offset) builder.addFieldOffset(7, logDataOffset, 0); } +static addPacketLoss(builder:flatbuffers.Builder, packetLoss:number) { + builder.addFieldFloat32(8, packetLoss, 0); +} + +static addPacketsLost(builder:flatbuffers.Builder, packetsLost:number) { + builder.addFieldInt32(9, packetsLost, 0); +} + +static addPacketsReceived(builder:flatbuffers.Builder, packetsReceived:number) { + builder.addFieldInt32(10, packetsReceived, 0); +} + static endHardwareStatus(builder:flatbuffers.Builder):flatbuffers.Offset { const offset = builder.endObject(); return offset; @@ -114,7 +141,10 @@ unpack(): HardwareStatusT { this.mcuTemp(), this.batteryVoltage(), this.batteryPctEstimate(), - (this.logData() !== null ? this.logData()!.unpack() : null) + (this.logData() !== null ? this.logData()!.unpack() : null), + this.packetLoss(), + this.packetsLost(), + this.packetsReceived() ); } @@ -127,6 +157,9 @@ unpackTo(_o: HardwareStatusT): void { _o.batteryVoltage = this.batteryVoltage(); _o.batteryPctEstimate = this.batteryPctEstimate(); _o.logData = (this.logData() !== null ? this.logData()!.unpack() : null); + _o.packetLoss = this.packetLoss(); + _o.packetsLost = this.packetsLost(); + _o.packetsReceived = this.packetsReceived(); } } @@ -138,7 +171,10 @@ constructor( public mcuTemp: number|null = null, public batteryVoltage: number|null = null, public batteryPctEstimate: number|null = null, - public logData: LogDataT|null = null + public logData: LogDataT|null = null, + public packetLoss: number|null = null, + public packetsLost: number|null = null, + public packetsReceived: number|null = null ){} @@ -159,6 +195,12 @@ pack(builder:flatbuffers.Builder): flatbuffers.Offset { if (this.batteryPctEstimate !== null) HardwareStatus.addBatteryPctEstimate(builder, this.batteryPctEstimate); HardwareStatus.addLogData(builder, logData); + if (this.packetLoss !== null) + HardwareStatus.addPacketLoss(builder, this.packetLoss); + if (this.packetsLost !== null) + HardwareStatus.addPacketsLost(builder, this.packetsLost); + if (this.packetsReceived !== null) + HardwareStatus.addPacketsReceived(builder, this.packetsReceived); return HardwareStatus.endHardwareStatus(builder); } diff --git a/schema/datatypes/hardware_info.fbs b/schema/datatypes/hardware_info.fbs index b6dd6cee..6ee41136 100644 --- a/schema/datatypes/hardware_info.fbs +++ b/schema/datatypes/hardware_info.fbs @@ -134,6 +134,10 @@ table HardwareStatus { battery_voltage: float32 = null; battery_pct_estimate: uint8 = null; log_data: solarxr_protocol.datatypes.LogData; + + packet_loss: float32 = null; + packets_lost: int32 = null; + packets_received: int32 = null; } /// A mask of the data in `FirmwareStatus`