Add temperature metrics and reduce debug log noise · 49b9c2a

Add temperature metrics and reduce debug log noise
Browse files

bogdan committed 4 days ago

main

1 parent fdf3236

commit 49b9c2a

Showing 6 changed files with 632 additions and 26 deletions

+91 -0

USB Meter/AppDelegate.swift

+                     // MARK: Debug
+                     public func track(_ message: String = "", file: String = #file, function: String = #function, line: Int = #line ) {
+                    +    guard shouldEmitTrackMessage(message, file: file, function: function) else {
+                    +        return
+                    +    }
+                         let date = Date()
+                         let calendar = Calendar.current
+                         let hour = calendar.component(.hour, from: date)
+                         print("\(hour):\(minutes):\(seconds) - \(file):\(line) - \(function) \(message)")
+                    +private func shouldEmitTrackMessage(_ message: String, file: String, function: String) -> Bool {
+                    +    #if DEBUG
+                    +    if ProcessInfo.processInfo.environment["USB_METER_VERBOSE_LOGS"] == "1" {
+                    +        return true
+                    +    }
+                    +    #if targetEnvironment(macCatalyst)
+                    +    let importantMarkers = [
+                    +        "Error",
+                    +        "error",
+                    +        "Failed",
+                    +        "failed",
+                    +        "timeout",
+                    +        "Timeout",
+                    +        "Missing",
+                    +        "missing",
+                    +        "overflow",
+                    +        "Disconnect",
+                    +        "disconnect",
+                    +        "Disconnected",
+                    +        "unauthorized",
+                    +        "not authorized",
+                    +        "not supported",
+                    +        "Unexpected",
+                    +        "Invalid Context",
+                    +        "ignored",
+                    +        "Guard:",
+                    +        "Skip data request",
+                    +        "Dropping unsolicited data",
+                    +        "This is not possible!",
+                    +        "Inferred",
+                    +        "Clearing",
+                    +        "Reconnecting"
+                    +    ]
+                    +    if importantMarkers.contains(where: { message.contains($0) }) {
+                    +        return true
+                    +    }
+                    +    let noisyFunctions: Set<String> = [
+                    +        "logRuntimeICloudDiagnostics()",
+                    +        "refreshCloudAvailability(reason:)",
+                    +        "start()",
+                    +        "centralManagerDidUpdateState(_:)",
+                    +        "discoveredMeter(peripheral:advertising:rssi:)",
+                    +        "connect()",
+                    +        "connectionEstablished()",
+                    +        "peripheral(_:didDiscoverServices:)",
+                    +        "peripheral(_:didDiscoverCharacteristicsFor:error:)",
+                    +        "refreshOperationalStateIfReady()",
+                    +        "peripheral(_:didUpdateNotificationStateFor:error:)",
+                    +        "scheduleDataDumpRequest(after:reason:)"
+                    +    ]
+                    +    if noisyFunctions.contains(function) {
+                    +        return false
+                    +    }
+                    +    let noisyMarkers = [
+                    +        "Runtime iCloud diagnostics",
+                    +        "iCloud availability",
+                    +        "Starting Bluetooth manager",
+                    +        "Bluetooth is On... Start scanning...",
+                    +        "adding new USB Meter",
+                    +        "Connect called for",
+                    +        "Connection established for",
+                    +        "Optional([<CBService:",
+                    +        "Optional([<CBCharacteristic:",
+                    +        "Waiting for notifications on",
+                    +        "Notification state updated for",
+                    +        "Peripheral ready with notify",
+                    +        "Schedule data request in",
+                    +        "Operational state changed"
+                    +    ]
+                    +    if noisyMarkers.contains(where: { message.contains($0) }) {
+                    +        return false
+                    +    }
+                    +    #endif
+                    +    return true
+                    +    #else
+                    +    _ = file
+                    +    _ = function
+                    +    return false
+                    +    #endif
+                    +}
+                     @UIApplicationMain
+                     class AppDelegate: UIResponder, UIApplicationDelegate {

+54 -1

USB Meter/Model/Measurements.swift

View

@@ -99,6 +99,10 @@ class Measurements : ObservableObject {
     @Published var power = Measurement()
     @Published var voltage = Measurement()
     @Published var current = Measurement()
+    @Published var temperature = Measurement()
+    @Published var rssi = Measurement()
+
+    let averagePowerSampleOptions: [Int] = [5, 10, 20, 50, 100, 250]
 
     private var pendingBucketSecond: Int?
     private var pendingBucketTimestamp: Date?
@@ -107,6 +111,8 @@ class Measurements : ObservableObject {
     private var powerSum: Double = 0
     private var voltageSum: Double = 0
     private var currentSum: Double = 0
+    private var temperatureSum: Double = 0
+    private var rssiSum: Double = 0
 
     private func resetPendingAggregation() {
         pendingBucketSecond = nil
@@ -115,6 +121,8 @@ class Measurements : ObservableObject {
         powerSum = 0
         voltageSum = 0
         currentSum = 0
+        temperatureSum = 0
+        rssiSum = 0
     }
 
     private func flushPendingValues() {
@@ -122,6 +130,8 @@ class Measurements : ObservableObject {
         self.power.addPoint(timestamp: pendingBucketTimestamp, value: powerSum / itemsInSum)
         self.voltage.addPoint(timestamp: pendingBucketTimestamp, value: voltageSum / itemsInSum)
         self.current.addPoint(timestamp: pendingBucketTimestamp, value: currentSum / itemsInSum)
+        self.temperature.addPoint(timestamp: pendingBucketTimestamp, value: temperatureSum / itemsInSum)
+        self.rssi.addPoint(timestamp: pendingBucketTimestamp, value: rssiSum / itemsInSum)
         resetPendingAggregation()
         self.objectWillChange.send()
     }
@@ -130,6 +140,8 @@ class Measurements : ObservableObject {
         power.resetSeries()
         voltage.resetSeries()
         current.resetSeries()
+        temperature.resetSeries()
+        rssi.resetSeries()
         resetPendingAggregation()
         self.objectWillChange.send()
     }
@@ -142,6 +154,8 @@ class Measurements : ObservableObject {
         power.removeValue(index: idx)
         voltage.removeValue(index: idx)
         current.removeValue(index: idx)
+        temperature.removeValue(index: idx)
+        rssi.removeValue(index: idx)
         self.objectWillChange.send()
     }
 
@@ -150,10 +164,12 @@ class Measurements : ObservableObject {
         power.trim(before: cutoff)
         voltage.trim(before: cutoff)
         current.trim(before: cutoff)
+        temperature.trim(before: cutoff)
+        rssi.trim(before: cutoff)
         self.objectWillChange.send()
     }
 
-    func addValues(timestamp: Date, power: Double, voltage: Double, current: Double) {
+    func addValues(timestamp: Date, power: Double, voltage: Double, current: Double, temperature: Double, rssi: Double) {
         let valuesTimestamp = timestamp.timeIntervalSinceReferenceDate.intValue
 
         if pendingBucketSecond == valuesTimestamp {
@@ -162,6 +178,8 @@ class Measurements : ObservableObject {
             powerSum += power
             voltageSum += voltage
             currentSum += current
+            temperatureSum += temperature
+            rssiSum += rssi
             return
         }
 
@@ -173,6 +191,8 @@ class Measurements : ObservableObject {
         powerSum = power
         voltageSum = voltage
         currentSum = current
+        temperatureSum = temperature
+        rssiSum = rssi
     }
 
     func markDiscontinuity(at timestamp: Date) {
@@ -180,6 +200,39 @@ class Measurements : ObservableObject {
         power.addDiscontinuity(timestamp: timestamp)
         voltage.addDiscontinuity(timestamp: timestamp)
         current.addDiscontinuity(timestamp: timestamp)
+        temperature.addDiscontinuity(timestamp: timestamp)
+        rssi.addDiscontinuity(timestamp: timestamp)
         self.objectWillChange.send()
     }
+
+    func powerSampleCount(flushPendingValues shouldFlushPendingValues: Bool = true) -> Int {
+        if shouldFlushPendingValues {
+            flushPendingValues()
+        }
+        return power.samplePoints.count
+    }
+
+    func recentPowerPoints(limit: Int, flushPendingValues shouldFlushPendingValues: Bool = true) -> [Measurement.Point] {
+        if shouldFlushPendingValues {
+            flushPendingValues()
+        }
+
+        let samplePoints = power.samplePoints
+        guard limit > 0, samplePoints.count > limit else {
+            return samplePoints
+        }
+
+        return Array(samplePoints.suffix(limit))
+    }
+
+    func averagePower(forRecentSampleCount sampleCount: Int, flushPendingValues shouldFlushPendingValues: Bool = true) -> Double? {
+        let points = recentPowerPoints(limit: sampleCount, flushPendingValues: shouldFlushPendingValues)
+        guard !points.isEmpty else { return nil }
+
+        let sum = points.reduce(0) { partialResult, point in
+            partialResult + point.value
+        }
+
+        return sum / Double(points.count)
+    }
 }


+8 -1

USB Meter/Model/Meter.swift

View

@@ -743,7 +743,14 @@ class Meter : NSObject, ObservableObject, Identifiable {
             }
         }
         updateChargeRecord(at: dataDumpRequestTimestamp)
-        measurements.addValues(timestamp: dataDumpRequestTimestamp, power: power, voltage: voltage, current: current)
+        measurements.addValues(
+            timestamp: dataDumpRequestTimestamp,
+            power: power,
+            voltage: voltage,
+            current: current,
+            temperature: displayedTemperatureValue,
+            rssi: Double(btSerial.averageRSSI)
+        )
 //        DispatchQueue.global(qos: .userInitiated).asyncAfter( deadline: .now() + 0.33 ) {
 //            //track("\(name) - Scheduled new request.")
 //        }


+81 -5

USB Meter/Views/Meter/Components/MeasurementChartView.swift

View

@@ -13,12 +13,14 @@ struct MeasurementChartView: View {
         case power
         case voltage
         case current
+        case temperature
 
         var unit: String {
             switch self {
             case .power: return "W"
             case .voltage: return "V"
             case .current: return "A"
+            case .temperature: return ""
             }
         }
 
@@ -27,6 +29,7 @@ struct MeasurementChartView: View {
             case .power: return .red
             case .voltage: return .green
             case .current: return .blue
+            case .temperature: return .orange
             }
         }
     }
@@ -45,6 +48,7 @@ struct MeasurementChartView: View {
     private let minimumVoltageSpan = 0.5
     private let minimumCurrentSpan = 0.5
     private let minimumPowerSpan = 0.5
+    private let minimumTemperatureSpan = 1.0
     private let defaultEmptyChartTimeSpan: TimeInterval = 60
 
     let compactLayout: Bool
@@ -58,6 +62,7 @@ struct MeasurementChartView: View {
     @State var displayVoltage: Bool = false
     @State var displayCurrent: Bool = false
     @State var displayPower: Bool = true
+    @State var displayTemperature: Bool = false
     @State private var showResetConfirmation: Bool = false
     @State private var chartNow: Date = Date()
     @State private var pinOrigin: Bool = false
@@ -67,6 +72,7 @@ struct MeasurementChartView: View {
     @State private var powerAxisOrigin: Double = 0
     @State private var voltageAxisOrigin: Double = 0
     @State private var currentAxisOrigin: Double = 0
+    @State private var temperatureAxisOrigin: Double = 0
     let xLabels: Int = 4
     let yLabels: Int = 4
 
@@ -182,6 +188,7 @@ struct MeasurementChartView: View {
         let powerSeries = series(for: measurements.power, kind: .power, minimumYSpan: minimumPowerSpan)
         let voltageSeries = series(for: measurements.voltage, kind: .voltage, minimumYSpan: minimumVoltageSpan)
         let currentSeries = series(for: measurements.current, kind: .current, minimumYSpan: minimumCurrentSpan)
+        let temperatureSeries = series(for: measurements.temperature, kind: .temperature, minimumYSpan: minimumTemperatureSpan)
         let primarySeries = displayedPrimarySeries(
             powerSeries: powerSeries,
             voltageSeries: voltageSeries,
@@ -219,7 +226,8 @@ struct MeasurementChartView: View {
                                     renderedChart(
                                         powerSeries: powerSeries,
                                         voltageSeries: voltageSeries,
-                                        currentSeries: currentSeries
+                                        currentSeries: currentSeries,
+                                        temperatureSeries: temperatureSeries
                                     )
                                 }
                                 .clipShape(RoundedRectangle(cornerRadius: 18, style: .continuous))
@@ -230,7 +238,8 @@ struct MeasurementChartView: View {
                                     height: plotHeight,
                                     powerSeries: powerSeries,
                                     voltageSeries: voltageSeries,
-                                    currentSeries: currentSeries
+                                    currentSeries: currentSeries,
+                                    temperatureSeries: temperatureSeries
                                 )
                                 .frame(width: axisColumnWidth, height: plotHeight)
                             }
@@ -377,6 +386,9 @@ struct MeasurementChartView: View {
                 displayVoltage.toggle()
                 if displayVoltage {
                     displayPower = false
+                    if displayTemperature && displayCurrent {
+                        displayCurrent = false
+                    }
                 }
             }
 
@@ -384,6 +396,9 @@ struct MeasurementChartView: View {
                 displayCurrent.toggle()
                 if displayCurrent {
                     displayPower = false
+                    if displayTemperature && displayVoltage {
+                        displayVoltage = false
+                    }
                 }
             }
 
@@ -394,6 +409,13 @@ struct MeasurementChartView: View {
                     displayVoltage = false
                 }
             }
+
+            seriesToggleButton(title: "Temp", isOn: displayTemperature, condensedLayout: condensedLayout) {
+                displayTemperature.toggle()
+                if displayTemperature && displayVoltage && displayCurrent {
+                    displayCurrent = false
+                }
+            }
         }
     }
 
@@ -596,7 +618,8 @@ struct MeasurementChartView: View {
     private func renderedChart(
         powerSeries: SeriesData,
         voltageSeries: SeriesData,
-        currentSeries: SeriesData
+        currentSeries: SeriesData,
+        temperatureSeries: SeriesData
     ) -> some View {
         if self.displayPower {
             Chart(points: powerSeries.points, context: powerSeries.context, strokeColor: .red)
@@ -611,6 +634,11 @@ struct MeasurementChartView: View {
                     .opacity(0.78)
             }
         }
+
+        if displayTemperature {
+            Chart(points: temperatureSeries.points, context: temperatureSeries.context, strokeColor: .orange)
+                .opacity(0.86)
+        }
     }
 
     @ViewBuilder
@@ -618,9 +646,18 @@ struct MeasurementChartView: View {
         height: CGFloat,
         powerSeries: SeriesData,
         voltageSeries: SeriesData,
-        currentSeries: SeriesData
+        currentSeries: SeriesData,
+        temperatureSeries: SeriesData
     ) -> some View {
-        if displayVoltage && displayCurrent {
+        if displayTemperature {
+            yAxisLabelsView(
+                height: height,
+                context: temperatureSeries.context,
+                seriesKind: .temperature,
+                measurementUnit: measurementUnit(for: .temperature),
+                tint: temperatureSeries.kind.tint
+            )
+        } else if displayVoltage && displayCurrent {
             yAxisLabelsView(
                 height: height,
                 context: currentSeries.context,
@@ -785,6 +822,9 @@ struct MeasurementChartView: View {
             if displayCurrent {
                 currentAxisOrigin = 0
             }
+            if displayTemperature {
+                temperatureAxisOrigin = 0
+            }
         }
 
         pinOrigin = true
@@ -797,6 +837,7 @@ struct MeasurementChartView: View {
         powerAxisOrigin = displayedLowerBoundForSeries(.power)
         voltageAxisOrigin = voltageSeries.autoLowerBound
         currentAxisOrigin = currentSeries.autoLowerBound
+        temperatureAxisOrigin = displayedLowerBoundForSeries(.temperature)
         sharedAxisOrigin = min(voltageAxisOrigin, currentAxisOrigin)
         sharedAxisUpperBound = max(voltageSeries.autoUpperBound, currentSeries.autoUpperBound)
         ensureSharedScaleSpan()
@@ -816,6 +857,8 @@ struct MeasurementChartView: View {
                 return sharedAxisOrigin
             }
             return pinOrigin ? currentAxisOrigin : automaticYBounds(for: filteredSamplePoints(measurements.current), minimumYSpan: minimumCurrentSpan).lowerBound
+        case .temperature:
+            return pinOrigin ? temperatureAxisOrigin : automaticYBounds(for: filteredSamplePoints(measurements.temperature), minimumYSpan: minimumTemperatureSpan).lowerBound
         }
     }
 
@@ -893,6 +936,8 @@ struct MeasurementChartView: View {
             return voltageAxisOrigin
         case .current:
             return currentAxisOrigin
+        case .temperature:
+            return temperatureAxisOrigin
         }
     }
 
@@ -911,6 +956,10 @@ struct MeasurementChartView: View {
             return max(sharedAxisUpperBound, sharedAxisOrigin + minimumSharedScaleSpan)
         }
 
+        if kind == .temperature {
+            return autoUpperBound
+        }
+
         return max(
             maximumSampleValue ?? lowerBound,
             lowerBound + minimumYSpan,
@@ -935,6 +984,8 @@ struct MeasurementChartView: View {
                 voltageAxisOrigin = min(proposedOrigin, maximumVisibleOrigin(for: .voltage))
             case .current:
                 currentAxisOrigin = min(proposedOrigin, maximumVisibleOrigin(for: .current))
+            case .temperature:
+                temperatureAxisOrigin = min(proposedOrigin, maximumVisibleOrigin(for: .temperature))
             }
         }
 
@@ -957,6 +1008,8 @@ struct MeasurementChartView: View {
                 voltageAxisOrigin = 0
             case .current:
                 currentAxisOrigin = 0
+            case .temperature:
+                temperatureAxisOrigin = 0
             }
         }
 
@@ -984,6 +1037,8 @@ struct MeasurementChartView: View {
             return snappedOriginValue(filteredSamplePoints(measurements.voltage).map(\.value).min() ?? 0)
         case .current:
             return snappedOriginValue(filteredSamplePoints(measurements.current).map(\.value).min() ?? 0)
+        case .temperature:
+            return snappedOriginValue(filteredSamplePoints(measurements.temperature).map(\.value).min() ?? 0)
         }
     }
 
@@ -994,6 +1049,27 @@ struct MeasurementChartView: View {
         )
     }
 
+    private func measurementUnit(for kind: SeriesKind) -> String {
+        switch kind {
+        case .temperature:
+            let locale = Locale.autoupdatingCurrent
+            if #available(iOS 16.0, *) {
+                switch locale.measurementSystem {
+                case .us:
+                    return "°F"
+                default:
+                    return "°C"
+                }
+            }
+
+            let regionCode = locale.regionCode ?? ""
+            let fahrenheitRegions: Set<String> = ["US", "BS", "BZ", "KY", "PW", "LR", "FM", "MH"]
+            return fahrenheitRegions.contains(regionCode) ? "°F" : "°C"
+        default:
+            return kind.unit
+        }
+    }
+
     private func ensureSharedScaleSpan() {
         sharedAxisUpperBound = max(sharedAxisUpperBound, sharedAxisOrigin + minimumSharedScaleSpan)
     }


+8 -1

USB Meter/Views/Meter/Tabs/Home/Subviews/MeterConnectionActionView.swift

View

+                         private var systemImage: String {
+                    -        connected ? "link.badge.minus" : "bolt.horizontal.circle.fill"
+                    +        if connected {
+                    +            #if targetEnvironment(macCatalyst)
+                    +            return "bolt.slash.circle.fill"
+                    +            #else
+                    +            return "link.badge.minus"
+                    +            #endif
+                    +        }
+                    +        return "bolt.horizontal.circle.fill"
+                         var body: some View {

+390 -18

USB Meter/Views/Meter/Tabs/Live/Subviews/MeterLiveContentView.swift

View

+                     struct MeterLiveContentView: View {
+                         @EnvironmentObject private var meter: Meter
+                    +    @State private var powerAverageSheetVisibility = false
+                    +    @State private var rssiHistorySheetVisibility = false
+                         var compactLayout: Bool = false
+                         var availableSize: CGSize? = nil
+                                                 min: meter.measurements.power.context.minValue,
+                                                 max: meter.measurements.power.context.maxValue,
+                                                 unit: "W"
+                    -                        )
+                    +                        ),
+                    +                        action: {
+                    +                            powerAverageSheetVisibility = true
+                    +                        }
+                                             symbol: "thermometer.medium",
+                                             color: .orange,
+                                             value: meter.primaryTemperatureDescription,
+                    -                        range: temperatureRange()
+                    +                        range: temperatureRange(
+                    +                            min: meter.measurements.temperature.context.minValue,
+                    +                            max: meter.measurements.temperature.context.maxValue
+                    +                        )
+                                         symbol: "dot.radiowaves.left.and.right",
+                                         color: .mint,
+                                         value: "\(meter.btSerial.averageRSSI) dBm",
+                    -                    range: MeterLiveMetricRange(
+                    -                        minLabel: "Min",
+                    -                        maxLabel: "Max",
+                    -                        minValue: "\(meter.btSerial.minRSSI) dBm",
+                    -                        maxValue: "\(meter.btSerial.maxRSSI) dBm"
+                    +                    range: metricRange(
+                    +                        min: meter.measurements.rssi.context.minValue,
+                    +                        max: meter.measurements.rssi.context.maxValue,
+                    +                        unit: "dBm",
+                    +                        decimalDigits: 0
+                                         ),
+                    -                    valueFont: .system(compactLayout ? .subheadline : .headline, design: .rounded).weight(.bold)
+                    +                    valueFont: .system(compactLayout ? .subheadline : .headline, design: .rounded).weight(.bold),
+                    +                    action: {
+                    +                        rssiHistorySheetVisibility = true
+                    +                    }
+                                     if meter.supportsChargerDetection && hasLiveMetrics {
+                             .frame(maxWidth: .infinity, alignment: .topLeading)
+                    +        .sheet(isPresented: $powerAverageSheetVisibility) {
+                    +            PowerAverageSheetView(visibility: $powerAverageSheetVisibility)
+                    +                .environmentObject(meter.measurements)
+                    +        }
+                    +        .sheet(isPresented: $rssiHistorySheetVisibility) {
+                    +            RSSIHistorySheetView(visibility: $rssiHistorySheetVisibility)
+                    +                .environmentObject(meter.measurements)
+                    +        }
+                         private var hasLiveMetrics: Bool {
+                             valueFont: Font? = nil,
+                             valueLineLimit: Int = 1,
+                             valueMonospacedDigits: Bool = true,
+                    -        valueMinimumScaleFactor: CGFloat = 0.85
+                    +        valueMinimumScaleFactor: CGFloat = 0.85,
+                    +        action: (() -> Void)? = nil
+                         ) -> some View {
+                    -        VStack(alignment: .leading, spacing: 10) {
+                    +        let cardContent = VStack(alignment: .leading, spacing: 10) {
+                                 HStack(spacing: compactLayout ? 8 : 10) {
+                                     Group {
+                                         if let customSymbol {
+                             .padding(compactLayout ? 12 : 16)
+                             .meterCard(tint: color, fillOpacity: 0.10, strokeOpacity: 0.12)
+                    +        if let action {
+                    +            return AnyView(
+                    +                Button(action: action) {
+                    +                    cardContent
+                    +                }
+                    +                .buttonStyle(.plain)
+                    +            )
+                    +        }
+                    +        return AnyView(cardContent)
+                         private func metricRangeTable(_ range: MeterLiveMetricRange) -> some View {
+                    -    private func metricRange(min: Double, max: Double, unit: String) -> MeterLiveMetricRange? {
+                    +    private func metricRange(min: Double, max: Double, unit: String, decimalDigits: Int = 3) -> MeterLiveMetricRange? {
+                             guard min.isFinite, max.isFinite else { return nil }
+                             return MeterLiveMetricRange(
+                                 minLabel: "Min",
+                                 maxLabel: "Max",
+                    -            minValue: "\(min.format(decimalDigits: 3)) \(unit)",
+                    -            maxValue: "\(max.format(decimalDigits: 3)) \(unit)"
+                    +            minValue: "\(min.format(decimalDigits: decimalDigits)) \(unit)",
+                    +            maxValue: "\(max.format(decimalDigits: decimalDigits)) \(unit)"
+                    -    private func temperatureRange() -> MeterLiveMetricRange? {
+                    -        let value = meter.primaryTemperatureDescription
+                    -        guard !value.isEmpty else { return nil }
+                    +    private func temperatureRange(min: Double, max: Double) -> MeterLiveMetricRange? {
+                    +        guard min.isFinite, max.isFinite else { return nil }
+                    +        let unitSuffix = temperatureUnitSuffix()
+                             return MeterLiveMetricRange(
+                                 minLabel: "Min",
+                                 maxLabel: "Max",
+                    -            minValue: value,
+                    -            maxValue: value
+                    +            minValue: "\(min.format(decimalDigits: 0))\(unitSuffix)",
+                    +            maxValue: "\(max.format(decimalDigits: 0))\(unitSuffix)"
+                             return date.format(as: "yyyy-MM-dd HH:mm")
+                    +    private func temperatureUnitSuffix() -> String {
+                    +        if meter.supportsManualTemperatureUnitSelection {
+                    +            return "°"
+                    +        }
+                    +        let locale = Locale.autoupdatingCurrent
+                    +        if #available(iOS 16.0, *) {
+                    +            switch locale.measurementSystem {
+                    +            case .us:
+                    +                return "°F"
+                    +            default:
+                    +                return "°C"
+                    +            }
+                    +        }
+                    +        let regionCode = locale.regionCode ?? ""
+                    +        let fahrenheitRegions: Set<String> = ["US", "BS", "BZ", "KY", "PW", "LR", "FM", "MH"]
+                    +        return fahrenheitRegions.contains(regionCode) ? "°F" : "°C"
+                    +    }
+                    +}
+                    +private struct PowerAverageSheetView: View {
+                    +    @EnvironmentObject private var measurements: Measurements
+                    +    @Binding var visibility: Bool
+                    +    @State private var selectedSampleCount: Int = 20
+                    +    var body: some View {
+                    +        let bufferedSamples = measurements.powerSampleCount()
+                    +        NavigationView {
+                    +            ScrollView {
+                    +                VStack(alignment: .leading, spacing: 14) {
+                    +                    VStack(alignment: .leading, spacing: 8) {
+                    +                        Text("Power Average")
+                    +                            .font(.system(.title3, design: .rounded).weight(.bold))
+                    +                        Text("Inspect the recent power buffer, choose how many values to include, and compute the average power over that window.")
+                    +                            .font(.footnote)
+                    +                            .foregroundColor(.secondary)
+                    +                    }
+                    +                    .padding(18)
+                    +                    .meterCard(tint: .pink, fillOpacity: 0.18, strokeOpacity: 0.24)
+                    +                    MeterInfoCardView(title: "Average Calculator", tint: .pink) {
+                    +                        if bufferedSamples == 0 {
+                    +                            Text("No power samples are available yet.")
+                    +                                .font(.footnote)
+                    +                                .foregroundColor(.secondary)
+                    +                        } else {
+                    +                            VStack(alignment: .leading, spacing: 14) {
+                    +                                VStack(alignment: .leading, spacing: 8) {
+                    +                                    Text("Values used")
+                    +                                        .font(.subheadline.weight(.semibold))
+                    +                                    Picker("Values used", selection: selectedSampleCountBinding(bufferedSamples: bufferedSamples)) {
+                    +                                        ForEach(availableSampleOptions(bufferedSamples: bufferedSamples), id: \.self) { option in
+                    +                                            Text(sampleOptionTitle(option, bufferedSamples: bufferedSamples)).tag(option)
+                    +                                        }
+                    +                                    }
+                    +                                    .pickerStyle(.menu)
+                    +                                }
+                    +                                VStack(alignment: .leading, spacing: 6) {
+                    +                                    Text(averagePowerLabel(bufferedSamples: bufferedSamples))
+                    +                                        .font(.system(.title2, design: .rounded).weight(.bold))
+                    +                                        .monospacedDigit()
+                    +                                    Text("Buffered samples: \(bufferedSamples)")
+                    +                                        .font(.caption)
+                    +                                        .foregroundColor(.secondary)
+                    +                                }
+                    +                            }
+                    +                        }
+                    +                    }
+                    +                    MeterInfoCardView(title: "Buffer Actions", tint: .secondary) {
+                    +                        Text("Reset clears the captured live measurement buffer for power, voltage, current, temperature, and RSSI.")
+                    +                            .font(.footnote)
+                    +                            .foregroundColor(.secondary)
+                    +                        Button("Reset Buffer") {
+                    +                            measurements.resetSeries()
+                    +                            selectedSampleCount = defaultSampleCount(bufferedSamples: measurements.powerSampleCount(flushPendingValues: false))
+                    +                        }
+                    +                        .foregroundColor(.red)
+                    +                    }
+                    +                }
+                    +                .padding()
+                    +            }
+                    +            .background(
+                    +                LinearGradient(
+                    +                    colors: [.pink.opacity(0.14), Color.clear],
+                    +                    startPoint: .topLeading,
+                    +                    endPoint: .bottomTrailing
+                    +                )
+                    +                .ignoresSafeArea()
+                    +            )
+                    +            .navigationBarItems(
+                    +                leading: Button("Done") { visibility.toggle() }
+                    +            )
+                    +            .navigationBarTitle("Power", displayMode: .inline)
+                    +        }
+                    +        .navigationViewStyle(StackNavigationViewStyle())
+                    +        .onAppear {
+                    +            selectedSampleCount = defaultSampleCount(bufferedSamples: bufferedSamples)
+                    +        }
+                    +        .onChange(of: bufferedSamples) { newValue in
+                    +            selectedSampleCount = min(max(1, selectedSampleCount), max(1, newValue))
+                    +        }
+                    +    }
+                    +    private func availableSampleOptions(bufferedSamples: Int) -> [Int] {
+                    +        guard bufferedSamples > 0 else { return [] }
+                    +        let filtered = measurements.averagePowerSampleOptions.filter { $0 < bufferedSamples }
+                    +        return (filtered + [bufferedSamples]).sorted()
+                    +    }
+                    +    private func defaultSampleCount(bufferedSamples: Int) -> Int {
+                    +        guard bufferedSamples > 0 else { return 20 }
+                    +        return min(20, bufferedSamples)
+                    +    }
+                    +    private func selectedSampleCountBinding(bufferedSamples: Int) -> Binding<Int> {
+                    +        Binding(
+                    +            get: {
+                    +                let availableOptions = availableSampleOptions(bufferedSamples: bufferedSamples)
+                    +                guard !availableOptions.isEmpty else { return defaultSampleCount(bufferedSamples: bufferedSamples) }
+                    +                if availableOptions.contains(selectedSampleCount) {
+                    +                    return selectedSampleCount
+                    +                }
+                    +                return min(availableOptions.last ?? bufferedSamples, defaultSampleCount(bufferedSamples: bufferedSamples))
+                    +            },
+                    +            set: { newValue in
+                    +                selectedSampleCount = newValue
+                    +            }
+                    +        )
+                    +    }
+                    +    private func sampleOptionTitle(_ option: Int, bufferedSamples: Int) -> String {
+                    +        if option == bufferedSamples {
+                    +            return "All (\(option))"
+                    +        }
+                    +        return "\(option) values"
+                    +    }
+                    +    private func averagePowerLabel(bufferedSamples: Int) -> String {
+                    +        guard let average = measurements.averagePower(forRecentSampleCount: selectedSampleCount, flushPendingValues: false) else {
+                    +            return "No data"
+                    +        }
+                    +        let effectiveSampleCount = min(selectedSampleCount, bufferedSamples)
+                    +        return "\(average.format(decimalDigits: 3)) W avg (\(effectiveSampleCount))"
+                    +    }
+                    +}
+                    +private struct RSSIHistorySheetView: View {
+                    +    @EnvironmentObject private var measurements: Measurements
+                    +    @Binding var visibility: Bool
+                    +    private let xLabels: Int = 4
+                    +    private let yLabels: Int = 4
+                    +    var body: some View {
+                    +        let points = measurements.rssi.points
+                    +        let samplePoints = measurements.rssi.samplePoints
+                    +        let chartContext = buildChartContext(for: samplePoints)
+                    +        NavigationView {
+                    +            ScrollView {
+                    +                VStack(alignment: .leading, spacing: 14) {
+                    +                    VStack(alignment: .leading, spacing: 8) {
+                    +                        Text("RSSI History")
+                    +                            .font(.system(.title3, design: .rounded).weight(.bold))
+                    +                        Text("Signal strength captured over time while the meter stays connected.")
+                    +                            .font(.footnote)
+                    +                            .foregroundColor(.secondary)
+                    +                    }
+                    +                    .padding(18)
+                    +                    .meterCard(tint: .mint, fillOpacity: 0.18, strokeOpacity: 0.24)
+                    +                    if samplePoints.isEmpty {
+                    +                        Text("No RSSI samples have been captured yet.")
+                    +                            .font(.footnote)
+                    +                            .foregroundColor(.secondary)
+                    +                            .padding(18)
+                    +                            .meterCard(tint: .secondary, fillOpacity: 0.14, strokeOpacity: 0.20)
+                    +                    } else {
+                    +                        MeterInfoCardView(title: "Signal Chart", tint: .mint) {
+                    +                            VStack(alignment: .leading, spacing: 12) {
+                    +                                HStack(spacing: 12) {
+                    +                                    signalSummaryChip(title: "Current", value: "\(Int(samplePoints.last?.value ?? 0)) dBm")
+                    +                                    signalSummaryChip(title: "Min", value: "\(Int(samplePoints.map(\.value).min() ?? 0)) dBm")
+                    +                                    signalSummaryChip(title: "Max", value: "\(Int(samplePoints.map(\.value).max() ?? 0)) dBm")
+                    +                                }
+                    +                                HStack(spacing: 8) {
+                    +                                    rssiYAxisView(context: chartContext)
+                    +                                        .frame(width: 52, height: 220)
+                    +                                    ZStack {
+                    +                                        RoundedRectangle(cornerRadius: 18, style: .continuous)
+                    +                                            .fill(Color.primary.opacity(0.05))
+                    +                                        RoundedRectangle(cornerRadius: 18, style: .continuous)
+                    +                                            .stroke(Color.secondary.opacity(0.16), lineWidth: 1)
+                    +                                        rssiHorizontalGuides(context: chartContext)
+                    +                                        rssiVerticalGuides(context: chartContext)
+                    +                                        Chart(points: points, context: chartContext, strokeColor: .mint)
+                    +                                            .opacity(0.82)
+                    +                                    }
+                    +                                    .frame(maxWidth: .infinity)
+                    +                                    .frame(height: 220)
+                    +                                }
+                    +                                rssiXAxisLabelsView(context: chartContext)
+                    +                                    .frame(height: 28)
+                    +                            }
+                    +                        }
+                    +                    }
+                    +                }
+                    +                .padding()
+                    +            }
+                    +            .background(
+                    +                LinearGradient(
+                    +                    colors: [.mint.opacity(0.14), Color.clear],
+                    +                    startPoint: .topLeading,
+                    +                    endPoint: .bottomTrailing
+                    +                )
+                    +                .ignoresSafeArea()
+                    +            )
+                    +            .navigationBarItems(
+                    +                leading: Button("Done") { visibility.toggle() }
+                    +            )
+                    +            .navigationBarTitle("RSSI", displayMode: .inline)
+                    +        }
+                    +        .navigationViewStyle(StackNavigationViewStyle())
+                    +    }
+                    +    private func buildChartContext(for samplePoints: [Measurements.Measurement.Point]) -> ChartContext {
+                    +        let context = ChartContext()
+                    +        let upperBound = max(samplePoints.last?.timestamp ?? Date(), Date())
+                    +        let lowerBound = samplePoints.first?.timestamp ?? upperBound.addingTimeInterval(-60)
+                    +        let minimumValue = samplePoints.map(\.value).min() ?? -100
+                    +        let maximumValue = samplePoints.map(\.value).max() ?? -40
+                    +        let padding = max((maximumValue - minimumValue) * 0.12, 4)
+                    +        context.setBounds(
+                    +            xMin: CGFloat(lowerBound.timeIntervalSince1970),
+                    +            xMax: CGFloat(max(upperBound.timeIntervalSince1970, lowerBound.timeIntervalSince1970 + 1)),
+                    +            yMin: CGFloat(minimumValue - padding),
+                    +            yMax: CGFloat(maximumValue + padding)
+                    +        )
+                    +        return context
+                    +    }
+                    +    private func signalSummaryChip(title: String, value: String) -> some View {
+                    +        VStack(alignment: .leading, spacing: 4) {
+                    +            Text(title)
+                    +                .font(.caption.weight(.semibold))
+                    +                .foregroundColor(.secondary)
+                    +            Text(value)
+                    +                .font(.subheadline.weight(.bold))
+                    +                .monospacedDigit()
+                    +        }
+                    +        .padding(.horizontal, 12)
+                    +        .padding(.vertical, 10)
+                    +        .meterCard(tint: .mint, fillOpacity: 0.10, strokeOpacity: 0.14, cornerRadius: 14)
+                    +    }
+                    +    private func rssiXAxisLabelsView(context: ChartContext) -> some View {
+                    +        let labels = (1...xLabels).map {
+                    +            Date(timeIntervalSince1970: context.xAxisLabel(for: $0, of: xLabels)).format(as: "HH:mm:ss")
+                    +        }
+                    +        return HStack {
+                    +            ForEach(Array(labels.enumerated()), id: \.offset) { item in
+                    +                Text(item.element)
+                    +                    .font(.caption2.weight(.semibold))
+                    +                    .monospacedDigit()
+                    +                    .frame(maxWidth: .infinity)
+                    +            }
+                    +        }
+                    +        .foregroundColor(.secondary)
+                    +    }
+                    +    private func rssiYAxisView(context: ChartContext) -> some View {
+                    +        VStack(spacing: 0) {
+                    +            ForEach((1...yLabels).reversed(), id: \.self) { labelIndex in
+                    +                Spacer(minLength: 0)
+                    +                Text("\(context.yAxisLabel(for: labelIndex, of: yLabels).format(decimalDigits: 0))")
+                    +                    .font(.caption2.weight(.semibold))
+                    +                    .monospacedDigit()
+                    +                    .foregroundColor(.primary)
+                    +                Spacer(minLength: 0)
+                    +            }
+                    +        }
+                    +        .padding(.vertical, 12)
+                    +        .background(
+                    +            RoundedRectangle(cornerRadius: 16, style: .continuous)
+                    +                .fill(Color.mint.opacity(0.12))
+                    +        )
+                    +        .overlay(
+                    +            RoundedRectangle(cornerRadius: 16, style: .continuous)
+                    +                .stroke(Color.mint.opacity(0.20), lineWidth: 1)
+                    +        )
+                    +    }
+                    +    private func rssiHorizontalGuides(context: ChartContext) -> some View {
+                    +        GeometryReader { geometry in
+                    +            Path { path in
+                    +                for labelIndex in 1...yLabels {
+                    +                    let value = context.yAxisLabel(for: labelIndex, of: yLabels)
+                    +                    let anchorPoint = CGPoint(x: context.origin.x, y: CGFloat(value))
+                    +                    let y = context.placeInRect(point: anchorPoint).y * geometry.size.height
+                    +                    path.addLine(from: CGPoint(x: 0, y: y), to: CGPoint(x: geometry.size.width, y: y))
+                    +                }
+                    +            }
+                    +            .stroke(Color.secondary.opacity(0.30), lineWidth: 0.8)
+                    +        }
+                    +    }
+                    +    private func rssiVerticalGuides(context: ChartContext) -> some View {
+                    +        GeometryReader { geometry in
+                    +            Path { path in
+                    +                for labelIndex in 2..<xLabels {
+                    +                    let value = context.xAxisLabel(for: labelIndex, of: xLabels)
+                    +                    let anchorPoint = CGPoint(x: CGFloat(value), y: context.origin.y)
+                    +                    let x = context.placeInRect(point: anchorPoint).x * geometry.size.width
+                    +                    path.move(to: CGPoint(x: x, y: 0))
+                    +                    path.addLine(to: CGPoint(x: x, y: geometry.size.height))
+                    +                }
+                    +            }
+                    +            .stroke(Color.secondary.opacity(0.26), style: StrokeStyle(lineWidth: 0.8, dash: [4, 4]))
+                    +        }
+                    +    }

	@@ -743,7 +743,14 @@ class Meter : NSObject, ObservableObject, Identifiable {
743	743	}
744	744	}
745	745	updateChargeRecord(at: dataDumpRequestTimestamp)
746		- measurements.addValues(timestamp: dataDumpRequestTimestamp, power: power, voltage: voltage, current: current)
	746	+ measurements.addValues(
	747	+ timestamp: dataDumpRequestTimestamp,
	748	+ power: power,
	749	+ voltage: voltage,
	750	+ current: current,
	751	+ temperature: displayedTemperatureValue,
	752	+ rssi: Double(btSerial.averageRSSI)
	753	+ )
747	754	// DispatchQueue.global(qos: .userInitiated).asyncAfter( deadline: .now() + 0.33 ) {
748	755	// //track("\(name) - Scheduled new request.")
749	756	// }

	@@ -99,6 +99,10 @@ class Measurements : ObservableObject {
99	99	@Published var power = Measurement()
100	100	@Published var voltage = Measurement()
101	101	@Published var current = Measurement()
	102	+ @Published var temperature = Measurement()
	103	+ @Published var rssi = Measurement()
	104	+
	105	+ let averagePowerSampleOptions: [Int] = [5, 10, 20, 50, 100, 250]
102	106
103	107	private var pendingBucketSecond: Int?
104	108	private var pendingBucketTimestamp: Date?
	@@ -107,6 +111,8 @@ class Measurements : ObservableObject {
107	111	private var powerSum: Double = 0
108	112	private var voltageSum: Double = 0
109	113	private var currentSum: Double = 0
	114	+ private var temperatureSum: Double = 0
	115	+ private var rssiSum: Double = 0
110	116
111	117	private func resetPendingAggregation() {
112	118	pendingBucketSecond = nil
	@@ -115,6 +121,8 @@ class Measurements : ObservableObject {
115	121	powerSum = 0
116	122	voltageSum = 0
117	123	currentSum = 0
	124	+ temperatureSum = 0
	125	+ rssiSum = 0
118	126	}
119	127
120	128	private func flushPendingValues() {
	@@ -122,6 +130,8 @@ class Measurements : ObservableObject {
122	130	self.power.addPoint(timestamp: pendingBucketTimestamp, value: powerSum / itemsInSum)
123	131	self.voltage.addPoint(timestamp: pendingBucketTimestamp, value: voltageSum / itemsInSum)
124	132	self.current.addPoint(timestamp: pendingBucketTimestamp, value: currentSum / itemsInSum)
	133	+ self.temperature.addPoint(timestamp: pendingBucketTimestamp, value: temperatureSum / itemsInSum)
	134	+ self.rssi.addPoint(timestamp: pendingBucketTimestamp, value: rssiSum / itemsInSum)
125	135	resetPendingAggregation()
126	136	self.objectWillChange.send()
127	137	}
	@@ -130,6 +140,8 @@ class Measurements : ObservableObject {
130	140	power.resetSeries()
131	141	voltage.resetSeries()
132	142	current.resetSeries()
	143	+ temperature.resetSeries()
	144	+ rssi.resetSeries()
133	145	resetPendingAggregation()
134	146	self.objectWillChange.send()
135	147	}
	@@ -142,6 +154,8 @@ class Measurements : ObservableObject {
142	154	power.removeValue(index: idx)
143	155	voltage.removeValue(index: idx)
144	156	current.removeValue(index: idx)
	157	+ temperature.removeValue(index: idx)
	158	+ rssi.removeValue(index: idx)
145	159	self.objectWillChange.send()
146	160	}
147	161
	@@ -150,10 +164,12 @@ class Measurements : ObservableObject {
150	164	power.trim(before: cutoff)
151	165	voltage.trim(before: cutoff)
152	166	current.trim(before: cutoff)
	167	+ temperature.trim(before: cutoff)
	168	+ rssi.trim(before: cutoff)
153	169	self.objectWillChange.send()
154	170	}
155	171
156		- func addValues(timestamp: Date, power: Double, voltage: Double, current: Double) {
	172	+ func addValues(timestamp: Date, power: Double, voltage: Double, current: Double, temperature: Double, rssi: Double) {
157	173	let valuesTimestamp = timestamp.timeIntervalSinceReferenceDate.intValue
158	174
159	175	if pendingBucketSecond == valuesTimestamp {
	@@ -162,6 +178,8 @@ class Measurements : ObservableObject {
162	178	powerSum += power
163	179	voltageSum += voltage
164	180	currentSum += current
	181	+ temperatureSum += temperature
	182	+ rssiSum += rssi
165	183	return
166	184	}
167	185
	@@ -173,6 +191,8 @@ class Measurements : ObservableObject {
173	191	powerSum = power
174	192	voltageSum = voltage
175	193	currentSum = current
	194	+ temperatureSum = temperature
	195	+ rssiSum = rssi
176	196	}
177	197
178	198	func markDiscontinuity(at timestamp: Date) {
	@@ -180,6 +200,39 @@ class Measurements : ObservableObject {
180	200	power.addDiscontinuity(timestamp: timestamp)
181	201	voltage.addDiscontinuity(timestamp: timestamp)
182	202	current.addDiscontinuity(timestamp: timestamp)
	203	+ temperature.addDiscontinuity(timestamp: timestamp)
	204	+ rssi.addDiscontinuity(timestamp: timestamp)
183	205	self.objectWillChange.send()
184	206	}
	207	+
	208	+ func powerSampleCount(flushPendingValues shouldFlushPendingValues: Bool = true) -> Int {
	209	+ if shouldFlushPendingValues {
	210	+ flushPendingValues()
	211	+ }
	212	+ return power.samplePoints.count
	213	+ }
	214	+
	215	+ func recentPowerPoints(limit: Int, flushPendingValues shouldFlushPendingValues: Bool = true) -> [Measurement.Point] {
	216	+ if shouldFlushPendingValues {
	217	+ flushPendingValues()
	218	+ }
	219	+
	220	+ let samplePoints = power.samplePoints
	221	+ guard limit > 0, samplePoints.count > limit else {
	222	+ return samplePoints
	223	+ }
	224	+
	225	+ return Array(samplePoints.suffix(limit))
	226	+ }
	227	+
	228	+ func averagePower(forRecentSampleCount sampleCount: Int, flushPendingValues shouldFlushPendingValues: Bool = true) -> Double? {
	229	+ let points = recentPowerPoints(limit: sampleCount, flushPendingValues: shouldFlushPendingValues)
	230	+ guard !points.isEmpty else { return nil }
	231	+
	232	+ let sum = points.reduce(0) { partialResult, point in
	233	+ partialResult + point.value
	234	+ }
	235	+
	236	+ return sum / Double(points.count)
	237	+ }
185	238	}

	@@ -13,12 +13,14 @@ struct MeasurementChartView: View {
13	13	case power
14	14	case voltage
15	15	case current
	16	+ case temperature
16	17
17	18	var unit: String {
18	19	switch self {
19	20	case .power: return "W"
20	21	case .voltage: return "V"
21	22	case .current: return "A"
	23	+ case .temperature: return ""
22	24	}
23	25	}
24	26
	@@ -27,6 +29,7 @@ struct MeasurementChartView: View {
27	29	case .power: return .red
28	30	case .voltage: return .green
29	31	case .current: return .blue
	32	+ case .temperature: return .orange
30	33	}
31	34	}
32	35	}
	@@ -45,6 +48,7 @@ struct MeasurementChartView: View {
45	48	private let minimumVoltageSpan = 0.5
46	49	private let minimumCurrentSpan = 0.5
47	50	private let minimumPowerSpan = 0.5
	51	+ private let minimumTemperatureSpan = 1.0
48	52	private let defaultEmptyChartTimeSpan: TimeInterval = 60
49	53
50	54	let compactLayout: Bool
	@@ -58,6 +62,7 @@ struct MeasurementChartView: View {
58	62	@State var displayVoltage: Bool = false
59	63	@State var displayCurrent: Bool = false
60	64	@State var displayPower: Bool = true
	65	+ @State var displayTemperature: Bool = false
61	66	@State private var showResetConfirmation: Bool = false
62	67	@State private var chartNow: Date = Date()
63	68	@State private var pinOrigin: Bool = false
	@@ -67,6 +72,7 @@ struct MeasurementChartView: View {
67	72	@State private var powerAxisOrigin: Double = 0
68	73	@State private var voltageAxisOrigin: Double = 0
69	74	@State private var currentAxisOrigin: Double = 0
	75	+ @State private var temperatureAxisOrigin: Double = 0
70	76	let xLabels: Int = 4
71	77	let yLabels: Int = 4
72	78
	@@ -182,6 +188,7 @@ struct MeasurementChartView: View {
182	188	let powerSeries = series(for: measurements.power, kind: .power, minimumYSpan: minimumPowerSpan)
183	189	let voltageSeries = series(for: measurements.voltage, kind: .voltage, minimumYSpan: minimumVoltageSpan)
184	190	let currentSeries = series(for: measurements.current, kind: .current, minimumYSpan: minimumCurrentSpan)
	191	+ let temperatureSeries = series(for: measurements.temperature, kind: .temperature, minimumYSpan: minimumTemperatureSpan)
185	192	let primarySeries = displayedPrimarySeries(
186	193	powerSeries: powerSeries,
187	194	voltageSeries: voltageSeries,
	@@ -219,7 +226,8 @@ struct MeasurementChartView: View {
219	226	renderedChart(
220	227	powerSeries: powerSeries,
221	228	voltageSeries: voltageSeries,
222		- currentSeries: currentSeries
	229	+ currentSeries: currentSeries,
	230	+ temperatureSeries: temperatureSeries
223	231	)
224	232	}
225	233	.clipShape(RoundedRectangle(cornerRadius: 18, style: .continuous))
	@@ -230,7 +238,8 @@ struct MeasurementChartView: View {
230	238	height: plotHeight,
231	239	powerSeries: powerSeries,
232	240	voltageSeries: voltageSeries,
233		- currentSeries: currentSeries
	241	+ currentSeries: currentSeries,
	242	+ temperatureSeries: temperatureSeries
234	243	)
235	244	.frame(width: axisColumnWidth, height: plotHeight)
236	245	}
	@@ -377,6 +386,9 @@ struct MeasurementChartView: View {
377	386	displayVoltage.toggle()
378	387	if displayVoltage {
379	388	displayPower = false
	389	+ if displayTemperature && displayCurrent {
	390	+ displayCurrent = false
	391	+ }
380	392	}
381	393	}
382	394
	@@ -384,6 +396,9 @@ struct MeasurementChartView: View {
384	396	displayCurrent.toggle()
385	397	if displayCurrent {
386	398	displayPower = false
	399	+ if displayTemperature && displayVoltage {
	400	+ displayVoltage = false
	401	+ }
387	402	}
388	403	}
389	404
	@@ -394,6 +409,13 @@ struct MeasurementChartView: View {
394	409	displayVoltage = false
395	410	}
396	411	}
	412	+
	413	+ seriesToggleButton(title: "Temp", isOn: displayTemperature, condensedLayout: condensedLayout) {
	414	+ displayTemperature.toggle()
	415	+ if displayTemperature && displayVoltage && displayCurrent {
	416	+ displayCurrent = false
	417	+ }
	418	+ }
397	419	}
398	420	}
399	421
	@@ -596,7 +618,8 @@ struct MeasurementChartView: View {
596	618	private func renderedChart(
597	619	powerSeries: SeriesData,
598	620	voltageSeries: SeriesData,
599		- currentSeries: SeriesData
	621	+ currentSeries: SeriesData,
	622	+ temperatureSeries: SeriesData
600	623	) -> some View {
601	624	if self.displayPower {
602	625	Chart(points: powerSeries.points, context: powerSeries.context, strokeColor: .red)
	@@ -611,6 +634,11 @@ struct MeasurementChartView: View {
611	634	.opacity(0.78)
612	635	}
613	636	}
	637	+
	638	+ if displayTemperature {
	639	+ Chart(points: temperatureSeries.points, context: temperatureSeries.context, strokeColor: .orange)
	640	+ .opacity(0.86)
	641	+ }
614	642	}
615	643
616	644	@ViewBuilder
	@@ -618,9 +646,18 @@ struct MeasurementChartView: View {
618	646	height: CGFloat,
619	647	powerSeries: SeriesData,
620	648	voltageSeries: SeriesData,
621		- currentSeries: SeriesData
	649	+ currentSeries: SeriesData,
	650	+ temperatureSeries: SeriesData
622	651	) -> some View {
623		- if displayVoltage && displayCurrent {
	652	+ if displayTemperature {
	653	+ yAxisLabelsView(
	654	+ height: height,
	655	+ context: temperatureSeries.context,
	656	+ seriesKind: .temperature,
	657	+ measurementUnit: measurementUnit(for: .temperature),
	658	+ tint: temperatureSeries.kind.tint
	659	+ )
	660	+ } else if displayVoltage && displayCurrent {
624	661	yAxisLabelsView(
625	662	height: height,
626	663	context: currentSeries.context,
	@@ -785,6 +822,9 @@ struct MeasurementChartView: View {
785	822	if displayCurrent {
786	823	currentAxisOrigin = 0
787	824	}
	825	+ if displayTemperature {
	826	+ temperatureAxisOrigin = 0
	827	+ }
788	828	}
789	829
790	830	pinOrigin = true
	@@ -797,6 +837,7 @@ struct MeasurementChartView: View {
797	837	powerAxisOrigin = displayedLowerBoundForSeries(.power)
798	838	voltageAxisOrigin = voltageSeries.autoLowerBound
799	839	currentAxisOrigin = currentSeries.autoLowerBound
	840	+ temperatureAxisOrigin = displayedLowerBoundForSeries(.temperature)
800	841	sharedAxisOrigin = min(voltageAxisOrigin, currentAxisOrigin)
801	842	sharedAxisUpperBound = max(voltageSeries.autoUpperBound, currentSeries.autoUpperBound)
802	843	ensureSharedScaleSpan()
	@@ -816,6 +857,8 @@ struct MeasurementChartView: View {
816	857	return sharedAxisOrigin
817	858	}
818	859	return pinOrigin ? currentAxisOrigin : automaticYBounds(for: filteredSamplePoints(measurements.current), minimumYSpan: minimumCurrentSpan).lowerBound
	860	+ case .temperature:
	861	+ return pinOrigin ? temperatureAxisOrigin : automaticYBounds(for: filteredSamplePoints(measurements.temperature), minimumYSpan: minimumTemperatureSpan).lowerBound
819	862	}
820	863	}
821	864
	@@ -893,6 +936,8 @@ struct MeasurementChartView: View {
893	936	return voltageAxisOrigin
894	937	case .current:
895	938	return currentAxisOrigin
	939	+ case .temperature:
	940	+ return temperatureAxisOrigin
896	941	}
897	942	}
898	943
	@@ -911,6 +956,10 @@ struct MeasurementChartView: View {
911	956	return max(sharedAxisUpperBound, sharedAxisOrigin + minimumSharedScaleSpan)
912	957	}
913	958
	959	+ if kind == .temperature {
	960	+ return autoUpperBound
	961	+ }
	962	+
914	963	return max(
915	964	maximumSampleValue ?? lowerBound,
916	965	lowerBound + minimumYSpan,
	@@ -935,6 +984,8 @@ struct MeasurementChartView: View {
935	984	voltageAxisOrigin = min(proposedOrigin, maximumVisibleOrigin(for: .voltage))
936	985	case .current:
937	986	currentAxisOrigin = min(proposedOrigin, maximumVisibleOrigin(for: .current))
	987	+ case .temperature:
	988	+ temperatureAxisOrigin = min(proposedOrigin, maximumVisibleOrigin(for: .temperature))
938	989	}
939	990	}
940	991
	@@ -957,6 +1008,8 @@ struct MeasurementChartView: View {
957	1008	voltageAxisOrigin = 0
958	1009	case .current:
959	1010	currentAxisOrigin = 0
	1011	+ case .temperature:
	1012	+ temperatureAxisOrigin = 0
960	1013	}
961	1014	}
962	1015
	@@ -984,6 +1037,8 @@ struct MeasurementChartView: View {
984	1037	return snappedOriginValue(filteredSamplePoints(measurements.voltage).map(\.value).min() ?? 0)
985	1038	case .current:
986	1039	return snappedOriginValue(filteredSamplePoints(measurements.current).map(\.value).min() ?? 0)
	1040	+ case .temperature:
	1041	+ return snappedOriginValue(filteredSamplePoints(measurements.temperature).map(\.value).min() ?? 0)
987	1042	}
988	1043	}
989	1044
	@@ -994,6 +1049,27 @@ struct MeasurementChartView: View {
994	1049	)
995	1050	}
996	1051
	1052	+ private func measurementUnit(for kind: SeriesKind) -> String {
	1053	+ switch kind {
	1054	+ case .temperature:
	1055	+ let locale = Locale.autoupdatingCurrent
	1056	+ if #available(iOS 16.0, *) {
	1057	+ switch locale.measurementSystem {
	1058	+ case .us:
	1059	+ return "°F"
	1060	+ default:
	1061	+ return "°C"
	1062	+ }
	1063	+ }
	1064	+
	1065	+ let regionCode = locale.regionCode ?? ""
	1066	+ let fahrenheitRegions: Set<String> = ["US", "BS", "BZ", "KY", "PW", "LR", "FM", "MH"]
	1067	+ return fahrenheitRegions.contains(regionCode) ? "°F" : "°C"
	1068	+ default:
	1069	+ return kind.unit
	1070	+ }
	1071	+ }
	1072	+
997	1073	private func ensureSharedScaleSpan() {
998	1074	sharedAxisUpperBound = max(sharedAxisUpperBound, sharedAxisOrigin + minimumSharedScaleSpan)
999	1075	}