From 2a25a889fb732bfe61cbc721be5ae75a59923020 Mon Sep 17 00:00:00 2001 From: Garth Vander Houwen Date: Wed, 15 Nov 2023 11:24:42 -0800 Subject: [PATCH] Update protos --- .../Protobufs/meshtastic/admin.pb.swift | 30 ++++ .../meshtastic/module_config.pb.swift | 44 ++++++ .../Protobufs/meshtastic/telemetry.pb.swift | 146 +++++++++++++++++- 3 files changed, 218 insertions(+), 2 deletions(-) diff --git a/Meshtastic/Protobufs/meshtastic/admin.pb.swift b/Meshtastic/Protobufs/meshtastic/admin.pb.swift index 50934353..75591fee 100644 --- a/Meshtastic/Protobufs/meshtastic/admin.pb.swift +++ b/Meshtastic/Protobufs/meshtastic/admin.pb.swift @@ -288,6 +288,16 @@ struct AdminMessage { set {payloadVariant = .setRingtoneMessage(newValue)} } + /// + /// Remove the node by the specified node-num from the NodeDB on the device + var removeByNodenum: UInt32 { + get { + if case .removeByNodenum(let v)? = payloadVariant {return v} + return 0 + } + set {payloadVariant = .removeByNodenum(newValue)} + } + /// /// Begins an edit transaction for config, module config, owner, and channel settings changes /// This will delay the standard *implicit* save to the file system and subsequent reboot behavior until committed (commit_edit_settings) @@ -457,6 +467,9 @@ struct AdminMessage { /// Set the ringtone for ExternalNotification. case setRingtoneMessage(String) /// + /// Remove the node by the specified node-num from the NodeDB on the device + case removeByNodenum(UInt32) + /// /// Begins an edit transaction for config, module config, owner, and channel settings changes /// This will delay the standard *implicit* save to the file system and subsequent reboot behavior until committed (commit_edit_settings) case beginEditSettings(Bool) @@ -590,6 +603,10 @@ struct AdminMessage { guard case .setRingtoneMessage(let l) = lhs, case .setRingtoneMessage(let r) = rhs else { preconditionFailure() } return l == r }() + case (.removeByNodenum, .removeByNodenum): return { + guard case .removeByNodenum(let l) = lhs, case .removeByNodenum(let r) = rhs else { preconditionFailure() } + return l == r + }() case (.beginEditSettings, .beginEditSettings): return { guard case .beginEditSettings(let l) = lhs, case .beginEditSettings(let r) = rhs else { preconditionFailure() } return l == r @@ -915,6 +932,7 @@ extension AdminMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementat 35: .standard(proto: "set_module_config"), 36: .standard(proto: "set_canned_message_module_messages"), 37: .standard(proto: "set_ringtone_message"), + 38: .standard(proto: "remove_by_nodenum"), 64: .standard(proto: "begin_edit_settings"), 65: .standard(proto: "commit_edit_settings"), 95: .standard(proto: "reboot_ota_seconds"), @@ -1191,6 +1209,14 @@ extension AdminMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementat self.payloadVariant = .setRingtoneMessage(v) } }() + case 38: try { + var v: UInt32? + try decoder.decodeSingularUInt32Field(value: &v) + if let v = v { + if self.payloadVariant != nil {try decoder.handleConflictingOneOf()} + self.payloadVariant = .removeByNodenum(v) + } + }() case 64: try { var v: Bool? try decoder.decodeSingularBoolField(value: &v) @@ -1366,6 +1392,10 @@ extension AdminMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementat guard case .setRingtoneMessage(let v)? = self.payloadVariant else { preconditionFailure() } try visitor.visitSingularStringField(value: v, fieldNumber: 37) }() + case .removeByNodenum?: try { + guard case .removeByNodenum(let v)? = self.payloadVariant else { preconditionFailure() } + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 38) + }() case .beginEditSettings?: try { guard case .beginEditSettings(let v)? = self.payloadVariant else { preconditionFailure() } try visitor.visitSingularBoolField(value: v, fieldNumber: 64) diff --git a/Meshtastic/Protobufs/meshtastic/module_config.pb.swift b/Meshtastic/Protobufs/meshtastic/module_config.pb.swift index a1e60223..b1720e41 100644 --- a/Meshtastic/Protobufs/meshtastic/module_config.pb.swift +++ b/Meshtastic/Protobufs/meshtastic/module_config.pb.swift @@ -786,6 +786,11 @@ struct ModuleConfig { /// and/or beep for 60 seconds var nagTimeout: UInt32 = 0 + /// + /// When true, enables devices with native I2S audio output to use the RTTTL over speaker like a buzzer + /// T-Watch S3 and T-Deck for example have this capability + var useI2SAsBuzzer: Bool = false + var unknownFields = SwiftProtobuf.UnknownStorage() init() {} @@ -885,6 +890,21 @@ struct ModuleConfig { /// air quality metrics to the mesh var airQualityInterval: UInt32 = 0 + /// + /// Interval in seconds of how often we should try to send our + /// air quality metrics to the mesh + var powerMeasurementEnabled: Bool = false + + /// + /// Interval in seconds of how often we should try to send our + /// air quality metrics to the mesh + var powerUpdateInterval: UInt32 = 0 + + /// + /// Interval in seconds of how often we should try to send our + /// air quality metrics to the mesh + var powerScreenEnabled: Bool = false + var unknownFields = SwiftProtobuf.UnknownStorage() init() {} @@ -1873,6 +1893,7 @@ extension ModuleConfig.ExternalNotificationConfig: SwiftProtobuf.Message, SwiftP 13: .standard(proto: "alert_bell_buzzer"), 7: .standard(proto: "use_pwm"), 14: .standard(proto: "nag_timeout"), + 15: .standard(proto: "use_i2s_as_buzzer"), ] mutating func decodeMessage(decoder: inout D) throws { @@ -1895,6 +1916,7 @@ extension ModuleConfig.ExternalNotificationConfig: SwiftProtobuf.Message, SwiftP case 12: try { try decoder.decodeSingularBoolField(value: &self.alertBellVibra) }() case 13: try { try decoder.decodeSingularBoolField(value: &self.alertBellBuzzer) }() case 14: try { try decoder.decodeSingularUInt32Field(value: &self.nagTimeout) }() + case 15: try { try decoder.decodeSingularBoolField(value: &self.useI2SAsBuzzer) }() default: break } } @@ -1943,6 +1965,9 @@ extension ModuleConfig.ExternalNotificationConfig: SwiftProtobuf.Message, SwiftP if self.nagTimeout != 0 { try visitor.visitSingularUInt32Field(value: self.nagTimeout, fieldNumber: 14) } + if self.useI2SAsBuzzer != false { + try visitor.visitSingularBoolField(value: self.useI2SAsBuzzer, fieldNumber: 15) + } try unknownFields.traverse(visitor: &visitor) } @@ -1961,6 +1986,7 @@ extension ModuleConfig.ExternalNotificationConfig: SwiftProtobuf.Message, SwiftP if lhs.alertBellBuzzer != rhs.alertBellBuzzer {return false} if lhs.usePwm != rhs.usePwm {return false} if lhs.nagTimeout != rhs.nagTimeout {return false} + if lhs.useI2SAsBuzzer != rhs.useI2SAsBuzzer {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } @@ -2076,6 +2102,9 @@ extension ModuleConfig.TelemetryConfig: SwiftProtobuf.Message, SwiftProtobuf._Me 5: .standard(proto: "environment_display_fahrenheit"), 6: .standard(proto: "air_quality_enabled"), 7: .standard(proto: "air_quality_interval"), + 8: .standard(proto: "power_measurement_enabled"), + 9: .standard(proto: "power_update_interval"), + 10: .standard(proto: "power_screen_enabled"), ] mutating func decodeMessage(decoder: inout D) throws { @@ -2091,6 +2120,9 @@ extension ModuleConfig.TelemetryConfig: SwiftProtobuf.Message, SwiftProtobuf._Me case 5: try { try decoder.decodeSingularBoolField(value: &self.environmentDisplayFahrenheit) }() case 6: try { try decoder.decodeSingularBoolField(value: &self.airQualityEnabled) }() case 7: try { try decoder.decodeSingularUInt32Field(value: &self.airQualityInterval) }() + case 8: try { try decoder.decodeSingularBoolField(value: &self.powerMeasurementEnabled) }() + case 9: try { try decoder.decodeSingularUInt32Field(value: &self.powerUpdateInterval) }() + case 10: try { try decoder.decodeSingularBoolField(value: &self.powerScreenEnabled) }() default: break } } @@ -2118,6 +2150,15 @@ extension ModuleConfig.TelemetryConfig: SwiftProtobuf.Message, SwiftProtobuf._Me if self.airQualityInterval != 0 { try visitor.visitSingularUInt32Field(value: self.airQualityInterval, fieldNumber: 7) } + if self.powerMeasurementEnabled != false { + try visitor.visitSingularBoolField(value: self.powerMeasurementEnabled, fieldNumber: 8) + } + if self.powerUpdateInterval != 0 { + try visitor.visitSingularUInt32Field(value: self.powerUpdateInterval, fieldNumber: 9) + } + if self.powerScreenEnabled != false { + try visitor.visitSingularBoolField(value: self.powerScreenEnabled, fieldNumber: 10) + } try unknownFields.traverse(visitor: &visitor) } @@ -2129,6 +2170,9 @@ extension ModuleConfig.TelemetryConfig: SwiftProtobuf.Message, SwiftProtobuf._Me if lhs.environmentDisplayFahrenheit != rhs.environmentDisplayFahrenheit {return false} if lhs.airQualityEnabled != rhs.airQualityEnabled {return false} if lhs.airQualityInterval != rhs.airQualityInterval {return false} + if lhs.powerMeasurementEnabled != rhs.powerMeasurementEnabled {return false} + if lhs.powerUpdateInterval != rhs.powerUpdateInterval {return false} + if lhs.powerScreenEnabled != rhs.powerScreenEnabled {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } diff --git a/Meshtastic/Protobufs/meshtastic/telemetry.pb.swift b/Meshtastic/Protobufs/meshtastic/telemetry.pb.swift index dc365499..debcff60 100644 --- a/Meshtastic/Protobufs/meshtastic/telemetry.pb.swift +++ b/Meshtastic/Protobufs/meshtastic/telemetry.pb.swift @@ -80,6 +80,10 @@ enum TelemetrySensorType: SwiftProtobuf.Enum { /// /// PM2.5 air quality sensor case pmsa003I // = 13 + + /// + /// INA3221 3 Channel Voltage / Current Sensor + case ina3221 // = 14 case UNRECOGNIZED(Int) init() { @@ -102,6 +106,7 @@ enum TelemetrySensorType: SwiftProtobuf.Enum { case 11: self = .qmc5883L case 12: self = .sht31 case 13: self = .pmsa003I + case 14: self = .ina3221 default: self = .UNRECOGNIZED(rawValue) } } @@ -122,6 +127,7 @@ enum TelemetrySensorType: SwiftProtobuf.Enum { case .qmc5883L: return 11 case .sht31: return 12 case .pmsa003I: return 13 + case .ina3221: return 14 case .UNRECOGNIZED(let i): return i } } @@ -147,6 +153,7 @@ extension TelemetrySensorType: CaseIterable { .qmc5883L, .sht31, .pmsa003I, + .ina3221, ] } @@ -204,11 +211,11 @@ struct EnvironmentMetrics { var gasResistance: Float = 0 /// - /// Voltage measured + /// Voltage measured (To be depreciated in favor of PowerMetrics in Meshtastic 3.x) var voltage: Float = 0 /// - /// Current measured + /// Current measured (To be depreciated in favor of PowerMetrics in Meshtastic 3.x) var current: Float = 0 var unknownFields = SwiftProtobuf.UnknownStorage() @@ -216,6 +223,42 @@ struct EnvironmentMetrics { init() {} } +/// +/// Power Metrics (voltage / current / etc) +struct PowerMetrics { + // SwiftProtobuf.Message conformance is added in an extension below. See the + // `Message` and `Message+*Additions` files in the SwiftProtobuf library for + // methods supported on all messages. + + /// + /// Voltage (Ch1) + var ch1Voltage: Float = 0 + + /// + /// Current (Ch1) + var ch1Current: Float = 0 + + /// + /// Voltage (Ch2) + var ch2Voltage: Float = 0 + + /// + /// Current (Ch2) + var ch2Current: Float = 0 + + /// + /// Voltage (Ch3) + var ch3Voltage: Float = 0 + + /// + /// Current (Ch3) + var ch3Current: Float = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + /// /// Air quality metrics struct AirQualityMetrics { @@ -319,6 +362,16 @@ struct Telemetry { set {variant = .airQualityMetrics(newValue)} } + /// + /// Power Metrics + var powerMetrics: PowerMetrics { + get { + if case .powerMetrics(let v)? = variant {return v} + return PowerMetrics() + } + set {variant = .powerMetrics(newValue)} + } + var unknownFields = SwiftProtobuf.UnknownStorage() enum OneOf_Variant: Equatable { @@ -331,6 +384,9 @@ struct Telemetry { /// /// Air quality metrics case airQualityMetrics(AirQualityMetrics) + /// + /// Power Metrics + case powerMetrics(PowerMetrics) #if !swift(>=4.1) static func ==(lhs: Telemetry.OneOf_Variant, rhs: Telemetry.OneOf_Variant) -> Bool { @@ -350,6 +406,10 @@ struct Telemetry { guard case .airQualityMetrics(let l) = lhs, case .airQualityMetrics(let r) = rhs else { preconditionFailure() } return l == r }() + case (.powerMetrics, .powerMetrics): return { + guard case .powerMetrics(let l) = lhs, case .powerMetrics(let r) = rhs else { preconditionFailure() } + return l == r + }() default: return false } } @@ -363,6 +423,7 @@ struct Telemetry { extension TelemetrySensorType: @unchecked Sendable {} extension DeviceMetrics: @unchecked Sendable {} extension EnvironmentMetrics: @unchecked Sendable {} +extension PowerMetrics: @unchecked Sendable {} extension AirQualityMetrics: @unchecked Sendable {} extension Telemetry: @unchecked Sendable {} extension Telemetry.OneOf_Variant: @unchecked Sendable {} @@ -388,6 +449,7 @@ extension TelemetrySensorType: SwiftProtobuf._ProtoNameProviding { 11: .same(proto: "QMC5883L"), 12: .same(proto: "SHT31"), 13: .same(proto: "PMSA003I"), + 14: .same(proto: "INA3221"), ] } @@ -503,6 +565,68 @@ extension EnvironmentMetrics: SwiftProtobuf.Message, SwiftProtobuf._MessageImple } } +extension PowerMetrics: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".PowerMetrics" + static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ + 1: .standard(proto: "ch1_voltage"), + 2: .standard(proto: "ch1_current"), + 3: .standard(proto: "ch2_voltage"), + 4: .standard(proto: "ch2_current"), + 5: .standard(proto: "ch3_voltage"), + 6: .standard(proto: "ch3_current"), + ] + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + // The use of inline closures is to circumvent an issue where the compiler + // allocates stack space for every case branch when no optimizations are + // enabled. https://github.com/apple/swift-protobuf/issues/1034 + switch fieldNumber { + case 1: try { try decoder.decodeSingularFloatField(value: &self.ch1Voltage) }() + case 2: try { try decoder.decodeSingularFloatField(value: &self.ch1Current) }() + case 3: try { try decoder.decodeSingularFloatField(value: &self.ch2Voltage) }() + case 4: try { try decoder.decodeSingularFloatField(value: &self.ch2Current) }() + case 5: try { try decoder.decodeSingularFloatField(value: &self.ch3Voltage) }() + case 6: try { try decoder.decodeSingularFloatField(value: &self.ch3Current) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.ch1Voltage != 0 { + try visitor.visitSingularFloatField(value: self.ch1Voltage, fieldNumber: 1) + } + if self.ch1Current != 0 { + try visitor.visitSingularFloatField(value: self.ch1Current, fieldNumber: 2) + } + if self.ch2Voltage != 0 { + try visitor.visitSingularFloatField(value: self.ch2Voltage, fieldNumber: 3) + } + if self.ch2Current != 0 { + try visitor.visitSingularFloatField(value: self.ch2Current, fieldNumber: 4) + } + if self.ch3Voltage != 0 { + try visitor.visitSingularFloatField(value: self.ch3Voltage, fieldNumber: 5) + } + if self.ch3Current != 0 { + try visitor.visitSingularFloatField(value: self.ch3Current, fieldNumber: 6) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: PowerMetrics, rhs: PowerMetrics) -> Bool { + if lhs.ch1Voltage != rhs.ch1Voltage {return false} + if lhs.ch1Current != rhs.ch1Current {return false} + if lhs.ch2Voltage != rhs.ch2Voltage {return false} + if lhs.ch2Current != rhs.ch2Current {return false} + if lhs.ch3Voltage != rhs.ch3Voltage {return false} + if lhs.ch3Current != rhs.ch3Current {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + extension AirQualityMetrics: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".AirQualityMetrics" static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ @@ -608,6 +732,7 @@ extension Telemetry: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementation 2: .standard(proto: "device_metrics"), 3: .standard(proto: "environment_metrics"), 4: .standard(proto: "air_quality_metrics"), + 5: .standard(proto: "power_metrics"), ] mutating func decodeMessage(decoder: inout D) throws { @@ -656,6 +781,19 @@ extension Telemetry: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementation self.variant = .airQualityMetrics(v) } }() + case 5: try { + var v: PowerMetrics? + var hadOneofValue = false + if let current = self.variant { + hadOneofValue = true + if case .powerMetrics(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.variant = .powerMetrics(v) + } + }() default: break } } @@ -682,6 +820,10 @@ extension Telemetry: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementation guard case .airQualityMetrics(let v)? = self.variant else { preconditionFailure() } try visitor.visitSingularMessageField(value: v, fieldNumber: 4) }() + case .powerMetrics?: try { + guard case .powerMetrics(let v)? = self.variant else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 5) + }() case nil: break } try unknownFields.traverse(visitor: &visitor)