meshtastic/Meshtastic-Apple
1
0
Fork 0
mirror of https://github.com/meshtastic/Meshtastic-Apple.git synced 2026-04-20 22:13:56 +00:00
Code Issues Projects Releases Packages Wiki Activity

Update protobufs

Browse source
This commit is contained in:
Garth Vander Houwen 2024-09-14 08:48:09 -07:00
parent 050a02712d
commit 37d652cb39
5 changed files with 161 additions and 38 deletions
Download patch file Download diff file Expand all files Collapse all files

5
MeshtasticProtobufs/Sources/meshtastic/admin.pb.swift
View file

@ -844,6 +844,7 @@ public struct AdminMessage {
///
/// TODO: REPLACE
case securityConfig // = 7
case sessionkeyConfig // = 8
case UNRECOGNIZED(Int)
public init() {
@ -860,6 +861,7 @@ public struct AdminMessage {
case 5: self = .loraConfig
case 6: self = .bluetoothConfig
case 7: self = .securityConfig
case 8: self = .sessionkeyConfig
default: self = .UNRECOGNIZED(rawValue)
}
}
@ -874,6 +876,7 @@ public struct AdminMessage {
case .loraConfig: return 5
case .bluetoothConfig: return 6
case .securityConfig: return 7
case .sessionkeyConfig: return 8
case .UNRECOGNIZED(let i): return i
}
}
@ -998,6 +1001,7 @@ extension AdminMessage.ConfigType: CaseIterable {
.loraConfig,
.bluetoothConfig,
.securityConfig,
.sessionkeyConfig,
]
}
@ -1755,6 +1759,7 @@ extension AdminMessage.ConfigType: SwiftProtobuf._ProtoNameProviding {
5: .same(proto: "LORA_CONFIG"),
6: .same(proto: "BLUETOOTH_CONFIG"),
7: .same(proto: "SECURITY_CONFIG"),
8: .same(proto: "SESSIONKEY_CONFIG"),
]
}

119
MeshtasticProtobufs/Sources/meshtastic/config.pb.swift
View file

@ -93,6 +93,14 @@ public struct Config {
set {payloadVariant = .security(newValue)}
}
public var sessionkey: Config.SessionkeyConfig {
get {
if case .sessionkey(let v)? = payloadVariant {return v}
return Config.SessionkeyConfig()
}
set {payloadVariant = .sessionkey(newValue)}
}
public var unknownFields = SwiftProtobuf.UnknownStorage()
///
@ -106,6 +114,7 @@ public struct Config {
case lora(Config.LoRaConfig)
case bluetooth(Config.BluetoothConfig)
case security(Config.SecurityConfig)
case sessionkey(Config.SessionkeyConfig)
#if !swift(>=4.1)
public static func ==(lhs: Config.OneOf_PayloadVariant, rhs: Config.OneOf_PayloadVariant) -> Bool {
@ -145,6 +154,10 @@ public struct Config {
guard case .security(let l) = lhs, case .security(let r) = rhs else { preconditionFailure() }
return l == r
}()
case (.sessionkey, .sessionkey): return {
guard case .sessionkey(let l) = lhs, case .sessionkey(let r) = rhs else { preconditionFailure() }
return l == r
}()
default: return false
}
}
@ -167,12 +180,6 @@ public struct Config {
/// Moved to SecurityConfig
public var serialEnabled: Bool = false
///
/// By default we turn off logging as soon as an API client connects (to keep shared serial link quiet).
/// Set this to true to leave the debug log outputting even when API is active.
/// Moved to SecurityConfig
public var debugLogEnabled: Bool = false
///
/// For boards without a hard wired button, this is the pin number that will be used
/// Boards that have more than one button can swap the function with this one. defaults to BUTTON_PIN if defined.
@ -1250,6 +1257,13 @@ public struct Config {
set {_uniqueStorage()._ignoreMqtt = newValue}
}
///
/// Sets the ok_to_mqtt bit on outgoing packets
public var configOkToMqtt: Bool {
get {return _storage._configOkToMqtt}
set {_uniqueStorage()._configOkToMqtt = newValue}
}
public var unknownFields = SwiftProtobuf.UnknownStorage()
public enum RegionCode: SwiftProtobuf.Enum {
@ -1492,11 +1506,6 @@ public struct Config {
/// Specified PIN for PairingMode.FixedPin
public var fixedPin: UInt32 = 0
///
/// Enables device (serial style logs) over Bluetooth
/// Moved to SecurityConfig
public var deviceLoggingEnabled: Bool = false
public var unknownFields = SwiftProtobuf.UnknownStorage()
public enum PairingMode: SwiftProtobuf.Enum {
@ -1559,7 +1568,7 @@ public struct Config {
///
/// The public key authorized to send admin messages to this node.
public var adminKey: Data = Data()
public var adminKey: [Data] = []
///
/// If true, device is considered to be "managed" by a mesh administrator via admin messages
@ -1572,13 +1581,9 @@ public struct Config {
///
/// By default we turn off logging as soon as an API client connects (to keep shared serial link quiet).
/// Output live debug logging over serial.
/// Output live debug logging over serial or bluetooth is set to true.
public var debugLogApiEnabled: Bool = false
///
/// Enables device (serial style logs) over Bluetooth
public var bluetoothLoggingEnabled: Bool = false
///
/// Allow incoming device control over the insecure legacy admin channel.
public var adminChannelEnabled: Bool = false
@ -1588,6 +1593,18 @@ public struct Config {
public init() {}
}
///
/// Blank config request, strictly for getting the session key
public struct SessionkeyConfig {
// 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.
public var unknownFields = SwiftProtobuf.UnknownStorage()
public init() {}
}
public init() {}
}
@ -1784,6 +1801,7 @@ extension Config.LoRaConfig.ModemPreset: @unchecked Sendable {}
extension Config.BluetoothConfig: @unchecked Sendable {}
extension Config.BluetoothConfig.PairingMode: @unchecked Sendable {}
extension Config.SecurityConfig: @unchecked Sendable {}
extension Config.SessionkeyConfig: @unchecked Sendable {}
#endif // swift(>=5.5) && canImport(_Concurrency)
// MARK: - Code below here is support for the SwiftProtobuf runtime.
@ -1801,6 +1819,7 @@ extension Config: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBas
6: .same(proto: "lora"),
7: .same(proto: "bluetooth"),
8: .same(proto: "security"),
9: .same(proto: "sessionkey"),
]
public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
@ -1913,6 +1932,19 @@ extension Config: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBas
self.payloadVariant = .security(v)
}
}()
case 9: try {
var v: Config.SessionkeyConfig?
var hadOneofValue = false
if let current = self.payloadVariant {
hadOneofValue = true
if case .sessionkey(let m) = current {v = m}
}
try decoder.decodeSingularMessageField(value: &v)
if let v = v {
if hadOneofValue {try decoder.handleConflictingOneOf()}
self.payloadVariant = .sessionkey(v)
}
}()
default: break
}
}
@ -1956,6 +1988,10 @@ extension Config: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBas
guard case .security(let v)? = self.payloadVariant else { preconditionFailure() }
try visitor.visitSingularMessageField(value: v, fieldNumber: 8)
}()
case .sessionkey?: try {
guard case .sessionkey(let v)? = self.payloadVariant else { preconditionFailure() }
try visitor.visitSingularMessageField(value: v, fieldNumber: 9)
}()
case nil: break
}
try unknownFields.traverse(visitor: &visitor)
@ -1973,7 +2009,6 @@ extension Config.DeviceConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImpl
public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
1: .same(proto: "role"),
2: .standard(proto: "serial_enabled"),
3: .standard(proto: "debug_log_enabled"),
4: .standard(proto: "button_gpio"),
5: .standard(proto: "buzzer_gpio"),
6: .standard(proto: "rebroadcast_mode"),
@ -1993,7 +2028,6 @@ extension Config.DeviceConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImpl
switch fieldNumber {
case 1: try { try decoder.decodeSingularEnumField(value: &self.role) }()
case 2: try { try decoder.decodeSingularBoolField(value: &self.serialEnabled) }()
case 3: try { try decoder.decodeSingularBoolField(value: &self.debugLogEnabled) }()
case 4: try { try decoder.decodeSingularUInt32Field(value: &self.buttonGpio) }()
case 5: try { try decoder.decodeSingularUInt32Field(value: &self.buzzerGpio) }()
case 6: try { try decoder.decodeSingularEnumField(value: &self.rebroadcastMode) }()
@ -2015,9 +2049,6 @@ extension Config.DeviceConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImpl
if self.serialEnabled != false {
try visitor.visitSingularBoolField(value: self.serialEnabled, fieldNumber: 2)
}
if self.debugLogEnabled != false {
try visitor.visitSingularBoolField(value: self.debugLogEnabled, fieldNumber: 3)
}
if self.buttonGpio != 0 {
try visitor.visitSingularUInt32Field(value: self.buttonGpio, fieldNumber: 4)
}
@ -2051,7 +2082,6 @@ extension Config.DeviceConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImpl
public static func ==(lhs: Config.DeviceConfig, rhs: Config.DeviceConfig) -> Bool {
if lhs.role != rhs.role {return false}
if lhs.serialEnabled != rhs.serialEnabled {return false}
if lhs.debugLogEnabled != rhs.debugLogEnabled {return false}
if lhs.buttonGpio != rhs.buttonGpio {return false}
if lhs.buzzerGpio != rhs.buzzerGpio {return false}
if lhs.rebroadcastMode != rhs.rebroadcastMode {return false}
@ -2595,6 +2625,7 @@ extension Config.LoRaConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplem
15: .standard(proto: "pa_fan_disabled"),
103: .standard(proto: "ignore_incoming"),
104: .standard(proto: "ignore_mqtt"),
105: .standard(proto: "config_ok_to_mqtt"),
]
fileprivate class _StorageClass {
@ -2615,6 +2646,7 @@ extension Config.LoRaConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplem
var _paFanDisabled: Bool = false
var _ignoreIncoming: [UInt32] = []
var _ignoreMqtt: Bool = false
var _configOkToMqtt: Bool = false
#if swift(>=5.10)
// This property is used as the initial default value for new instances of the type.
@ -2646,6 +2678,7 @@ extension Config.LoRaConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplem
_paFanDisabled = source._paFanDisabled
_ignoreIncoming = source._ignoreIncoming
_ignoreMqtt = source._ignoreMqtt
_configOkToMqtt = source._configOkToMqtt
}
}
@ -2681,6 +2714,7 @@ extension Config.LoRaConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplem
case 15: try { try decoder.decodeSingularBoolField(value: &_storage._paFanDisabled) }()
case 103: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._ignoreIncoming) }()
case 104: try { try decoder.decodeSingularBoolField(value: &_storage._ignoreMqtt) }()
case 105: try { try decoder.decodeSingularBoolField(value: &_storage._configOkToMqtt) }()
default: break
}
}
@ -2740,6 +2774,9 @@ extension Config.LoRaConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplem
if _storage._ignoreMqtt != false {
try visitor.visitSingularBoolField(value: _storage._ignoreMqtt, fieldNumber: 104)
}
if _storage._configOkToMqtt != false {
try visitor.visitSingularBoolField(value: _storage._configOkToMqtt, fieldNumber: 105)
}
}
try unknownFields.traverse(visitor: &visitor)
}
@ -2766,6 +2803,7 @@ extension Config.LoRaConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplem
if _storage._paFanDisabled != rhs_storage._paFanDisabled {return false}
if _storage._ignoreIncoming != rhs_storage._ignoreIncoming {return false}
if _storage._ignoreMqtt != rhs_storage._ignoreMqtt {return false}
if _storage._configOkToMqtt != rhs_storage._configOkToMqtt {return false}
return true
}
if !storagesAreEqual {return false}
@ -2819,7 +2857,6 @@ extension Config.BluetoothConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageI
1: .same(proto: "enabled"),
2: .same(proto: "mode"),
3: .standard(proto: "fixed_pin"),
4: .standard(proto: "device_logging_enabled"),
]
public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
@ -2831,7 +2868,6 @@ extension Config.BluetoothConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageI
case 1: try { try decoder.decodeSingularBoolField(value: &self.enabled) }()
case 2: try { try decoder.decodeSingularEnumField(value: &self.mode) }()
case 3: try { try decoder.decodeSingularUInt32Field(value: &self.fixedPin) }()
case 4: try { try decoder.decodeSingularBoolField(value: &self.deviceLoggingEnabled) }()
default: break
}
}
@ -2847,9 +2883,6 @@ extension Config.BluetoothConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageI
if self.fixedPin != 0 {
try visitor.visitSingularUInt32Field(value: self.fixedPin, fieldNumber: 3)
}
if self.deviceLoggingEnabled != false {
try visitor.visitSingularBoolField(value: self.deviceLoggingEnabled, fieldNumber: 4)
}
try unknownFields.traverse(visitor: &visitor)
}
@ -2857,7 +2890,6 @@ extension Config.BluetoothConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageI
if lhs.enabled != rhs.enabled {return false}
if lhs.mode != rhs.mode {return false}
if lhs.fixedPin != rhs.fixedPin {return false}
if lhs.deviceLoggingEnabled != rhs.deviceLoggingEnabled {return false}
if lhs.unknownFields != rhs.unknownFields {return false}
return true
}
@ -2880,7 +2912,6 @@ extension Config.SecurityConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageIm
4: .standard(proto: "is_managed"),
5: .standard(proto: "serial_enabled"),
6: .standard(proto: "debug_log_api_enabled"),
7: .standard(proto: "bluetooth_logging_enabled"),
8: .standard(proto: "admin_channel_enabled"),
]
@ -2892,11 +2923,10 @@ extension Config.SecurityConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageIm
switch fieldNumber {
case 1: try { try decoder.decodeSingularBytesField(value: &self.publicKey) }()
case 2: try { try decoder.decodeSingularBytesField(value: &self.privateKey) }()
case 3: try { try decoder.decodeSingularBytesField(value: &self.adminKey) }()
case 3: try { try decoder.decodeRepeatedBytesField(value: &self.adminKey) }()
case 4: try { try decoder.decodeSingularBoolField(value: &self.isManaged) }()
case 5: try { try decoder.decodeSingularBoolField(value: &self.serialEnabled) }()
case 6: try { try decoder.decodeSingularBoolField(value: &self.debugLogApiEnabled) }()
case 7: try { try decoder.decodeSingularBoolField(value: &self.bluetoothLoggingEnabled) }()
case 8: try { try decoder.decodeSingularBoolField(value: &self.adminChannelEnabled) }()
default: break
}
@ -2911,7 +2941,7 @@ extension Config.SecurityConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageIm
try visitor.visitSingularBytesField(value: self.privateKey, fieldNumber: 2)
}
if !self.adminKey.isEmpty {
try visitor.visitSingularBytesField(value: self.adminKey, fieldNumber: 3)
try visitor.visitRepeatedBytesField(value: self.adminKey, fieldNumber: 3)
}
if self.isManaged != false {
try visitor.visitSingularBoolField(value: self.isManaged, fieldNumber: 4)
@ -2922,9 +2952,6 @@ extension Config.SecurityConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageIm
if self.debugLogApiEnabled != false {
try visitor.visitSingularBoolField(value: self.debugLogApiEnabled, fieldNumber: 6)
}
if self.bluetoothLoggingEnabled != false {
try visitor.visitSingularBoolField(value: self.bluetoothLoggingEnabled, fieldNumber: 7)
}
if self.adminChannelEnabled != false {
try visitor.visitSingularBoolField(value: self.adminChannelEnabled, fieldNumber: 8)
}
@ -2938,9 +2965,27 @@ extension Config.SecurityConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageIm
if lhs.isManaged != rhs.isManaged {return false}
if lhs.serialEnabled != rhs.serialEnabled {return false}
if lhs.debugLogApiEnabled != rhs.debugLogApiEnabled {return false}
if lhs.bluetoothLoggingEnabled != rhs.bluetoothLoggingEnabled {return false}
if lhs.adminChannelEnabled != rhs.adminChannelEnabled {return false}
if lhs.unknownFields != rhs.unknownFields {return false}
return true
}
}
extension Config.SessionkeyConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
public static let protoMessageName: String = Config.protoMessageName + ".SessionkeyConfig"
public static let _protobuf_nameMap = SwiftProtobuf._NameMap()
public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
while let _ = try decoder.nextFieldNumber() {
}
}
public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
try unknownFields.traverse(visitor: &visitor)
}
public static func ==(lhs: Config.SessionkeyConfig, rhs: Config.SessionkeyConfig) -> Bool {
if lhs.unknownFields != rhs.unknownFields {return false}
return true
}
}

65
MeshtasticProtobufs/Sources/meshtastic/mesh.pb.swift
View file

@ -346,6 +346,19 @@ public enum HardwareModel: SwiftProtobuf.Enum {
/// Minewsemi ME25LS01 (ME25LE01_V1.0). NRF52840 w/ LR1110 radio, buttons and leds and pins.
case me25Ls014Y10Td // = 75
///
/// RP2040_FEATHER_RFM95
/// Adafruit Feather RP2040 with RFM95 LoRa Radio RFM95 with SX1272, SSD1306 OLED
/// https://www.adafruit.com/product/5714
/// https://www.adafruit.com/product/326
/// https://www.adafruit.com/product/938
/// ^^^ short A0 to switch to I2C address 0x3C
case rp2040FeatherRfm95 // = 76
/// M5 esp32 based MCU modules with enclosure, TFT and LORA Shields. All Variants (Basic, Core, Fire, Core2, Paper) https://m5stack.com/
case m5StackCorebasic // = 77
case m5StackCore2 // = 78
///
/// ------------------------------------------------------------------------------------------------------------------------------------------
/// Reserved ID For developing private Ports. These will show up in live traffic sparsely, so we can use a high number. Keep it within 8 bits.
@ -434,6 +447,9 @@ public enum HardwareModel: SwiftProtobuf.Enum {
case 73: self = .wioE5
case 74: self = .radiomaster900Bandit
case 75: self = .me25Ls014Y10Td
case 76: self = .rp2040FeatherRfm95
case 77: self = .m5StackCorebasic
case 78: self = .m5StackCore2
case 255: self = .privateHw
default: self = .UNRECOGNIZED(rawValue)
}
@ -516,6 +532,9 @@ public enum HardwareModel: SwiftProtobuf.Enum {
case .wioE5: return 73
case .radiomaster900Bandit: return 74
case .me25Ls014Y10Td: return 75
case .rp2040FeatherRfm95: return 76
case .m5StackCorebasic: return 77
case .m5StackCore2: return 78
case .privateHw: return 255
case .UNRECOGNIZED(let i): return i
}
@ -603,6 +622,9 @@ extension HardwareModel: CaseIterable {
.wioE5,
.radiomaster900Bandit,
.me25Ls014Y10Td,
.rp2040FeatherRfm95,
.m5StackCorebasic,
.m5StackCore2,
.privateHw,
]
}
@ -1520,9 +1542,22 @@ public struct DataMessage {
/// a message a heart or poop emoji.
public var emoji: UInt32 = 0
///
/// Bitfield for extra flags. First use is to indicate that user approves the packet being uploaded to MQTT.
public var bitfield: UInt32 {
get {return _bitfield ?? 0}
set {_bitfield = newValue}
}
/// Returns true if `bitfield` has been explicitly set.
public var hasBitfield: Bool {return self._bitfield != nil}
/// Clears the value of `bitfield`. Subsequent reads from it will return its default value.
public mutating func clearBitfield() {self._bitfield = nil}
public var unknownFields = SwiftProtobuf.UnknownStorage()
public init() {}
fileprivate var _bitfield: UInt32? = nil
}
///
@ -1907,6 +1942,15 @@ public struct MeshPacket {
/// assume it is important and use a slightly higher priority
case reliable // = 70
///
/// If priority is unset but the packet is a response to a request, we want it to get there relatively quickly.
/// Furthermore, responses stop relaying packets directed to a node early.
case response // = 80
///
/// Higher priority for specific message types (portnums) to distinguish between other reliable packets.
case high // = 100
///
/// Ack/naks are sent with very high priority to ensure that retransmission
/// stops as soon as possible
@ -1928,6 +1972,8 @@ public struct MeshPacket {
case 10: self = .background
case 64: self = .default
case 70: self = .reliable
case 80: self = .response
case 100: self = .high
case 120: self = .ack
case 127: self = .max
default: self = .UNRECOGNIZED(rawValue)
@ -1941,6 +1987,8 @@ public struct MeshPacket {
case .background: return 10
case .default: return 64
case .reliable: return 70
case .response: return 80
case .high: return 100
case .ack: return 120
case .max: return 127
case .UNRECOGNIZED(let i): return i
@ -2006,6 +2054,8 @@ extension MeshPacket.Priority: CaseIterable {
.background,
.default,
.reliable,
.response,
.high,
.ack,
.max,
]
@ -3241,6 +3291,9 @@ extension HardwareModel: SwiftProtobuf._ProtoNameProviding {
73: .same(proto: "WIO_E5"),
74: .same(proto: "RADIOMASTER_900_BANDIT"),
75: .same(proto: "ME25LS01_4Y10TD"),
76: .same(proto: "RP2040_FEATHER_RFM95"),
77: .same(proto: "M5STACK_COREBASIC"),
78: .same(proto: "M5STACK_CORE2"),
255: .same(proto: "PRIVATE_HW"),
]
}
@ -3779,6 +3832,7 @@ extension DataMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementati
6: .standard(proto: "request_id"),
7: .standard(proto: "reply_id"),
8: .same(proto: "emoji"),
9: .same(proto: "bitfield"),
]
public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
@ -3795,12 +3849,17 @@ extension DataMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementati
case 6: try { try decoder.decodeSingularFixed32Field(value: &self.requestID) }()
case 7: try { try decoder.decodeSingularFixed32Field(value: &self.replyID) }()
case 8: try { try decoder.decodeSingularFixed32Field(value: &self.emoji) }()
case 9: try { try decoder.decodeSingularUInt32Field(value: &self._bitfield) }()
default: break
}
}
}
public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
// The use of inline closures is to circumvent an issue where the compiler
// allocates stack space for every if/case branch local when no optimizations
// are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
// https://github.com/apple/swift-protobuf/issues/1182
if self.portnum != .unknownApp {
try visitor.visitSingularEnumField(value: self.portnum, fieldNumber: 1)
}
@ -3825,6 +3884,9 @@ extension DataMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementati
if self.emoji != 0 {
try visitor.visitSingularFixed32Field(value: self.emoji, fieldNumber: 8)
}
try { if let v = self._bitfield {
try visitor.visitSingularUInt32Field(value: v, fieldNumber: 9)
} }()
try unknownFields.traverse(visitor: &visitor)
}
@ -3837,6 +3899,7 @@ extension DataMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementati
if lhs.requestID != rhs.requestID {return false}
if lhs.replyID != rhs.replyID {return false}
if lhs.emoji != rhs.emoji {return false}
if lhs._bitfield != rhs._bitfield {return false}
if lhs.unknownFields != rhs.unknownFields {return false}
return true
}
@ -4224,6 +4287,8 @@ extension MeshPacket.Priority: SwiftProtobuf._ProtoNameProviding {
10: .same(proto: "BACKGROUND"),
64: .same(proto: "DEFAULT"),
70: .same(proto: "RELIABLE"),
80: .same(proto: "RESPONSE"),
100: .same(proto: "HIGH"),
120: .same(proto: "ACK"),
127: .same(proto: "MAX"),
]

8
MeshtasticProtobufs/Sources/meshtastic/telemetry.pb.swift
View file

@ -140,6 +140,10 @@ public enum TelemetrySensorType: SwiftProtobuf.Enum {
///
/// MAX17048 1S lipo battery sensor (voltage, state of charge, time to go)
case max17048 // = 28
///
/// Custom I2C sensor implementation based on https://github.com/meshtastic/i2c-sensor
case customSensor // = 29
case UNRECOGNIZED(Int)
public init() {
@ -177,6 +181,7 @@ public enum TelemetrySensorType: SwiftProtobuf.Enum {
case 26: self = .bmp3Xx
case 27: self = .icm20948
case 28: self = .max17048
case 29: self = .customSensor
default: self = .UNRECOGNIZED(rawValue)
}
}
@ -212,6 +217,7 @@ public enum TelemetrySensorType: SwiftProtobuf.Enum {
case .bmp3Xx: return 26
case .icm20948: return 27
case .max17048: return 28
case .customSensor: return 29
case .UNRECOGNIZED(let i): return i
}
}
@ -252,6 +258,7 @@ extension TelemetrySensorType: CaseIterable {
.bmp3Xx,
.icm20948,
.max17048,
.customSensor,
]
}
@ -1003,6 +1010,7 @@ extension TelemetrySensorType: SwiftProtobuf._ProtoNameProviding {
26: .same(proto: "BMP3XX"),
27: .same(proto: "ICM20948"),
28: .same(proto: "MAX17048"),
29: .same(proto: "CUSTOM_SENSOR"),
]
}

2
protobufs

@ -1 +1 @@
Subproject commit 4da558d0f73c46ef91b74431facee73c09affbfc
Subproject commit 0acaec6eff00e748beeae89148093221f131cd9c