Implement charge record workflow and stabilize charts · 4263f00

Implement charge record workflow and stabilize charts
Browse files

bogdan committed 2 weeks ago

deadend-backup-2026-03-26 main

1 parent 37d4a99

commit 4263f00

Showing 14 changed files with 533 additions and 89 deletions

+6 -0

USB Meter/Model/AppData.swift

@@ -40,6 +40,7 @@ final class AppData : ObservableObject {
     }
     
     @ICloudDefault(key: "MeterNames", defaultValue: [:]) var meterNames: [String:String]
+    @ICloudDefault(key: "TC66TemperatureUnits", defaultValue: [:]) var tc66TemperatureUnits: [String:String]
     func test(notification: NotificationCenter.Publisher.Output) -> Void {
         if let changedKeys = notification.userInfo?["NSUbiquitousKeyValueStoreChangedKeysKey"] as? [String] {
             var somethingChanged = false
@@ -54,6 +55,11 @@ final class AppData : ObservableObject {
                             }
                         }
                     }
+                case "TC66TemperatureUnits":
+                    for meter in self.meters.values where meter.supportsManualTemperatureUnitSelection {
+                        meter.reloadTemperatureUnitPreference()
+                        somethingChanged = true
+                    }
                 default:
                     track("Unknown key: '\(changedKey)' changed in iCloud)")
                 }


+27 -14

USB Meter/Model/ChartContext.swift

View

@@ -23,7 +23,7 @@ class ChartContext {
         get {
             guard rect != nil else {
                 track("Invalid Context")
-                fatalError()
+                return .zero
             }
             return rect!.size
         }
@@ -33,7 +33,7 @@ class ChartContext {
         get {
             guard rect != nil else {
                 track("Invalid Context")
-                fatalError()
+                return .zero
             }
             return rect!.origin
         }
@@ -51,7 +51,7 @@ class ChartContext {
 
     func reset() {
         rect = nil
-        padding()
+        pad = 0
     }
     func include( point: CGPoint )  {
         if rect == nil {
@@ -67,10 +67,27 @@ class ChartContext {
         guard rect != nil else {
             track("Invalid Context")
             pad = 0
-            fatalError()
+            return
         }
         pad = rect!.size.height * Constants.chartUnderscan
     }
+
+    func ensureMinimumSize(width minimumWidth: CGFloat = 0, height minimumHeight: CGFloat = 0) {
+        guard var rect else { return }
+
+        if rect.width < minimumWidth {
+            let delta = (minimumWidth - rect.width) / 2
+            rect = rect.insetBy(dx: -delta, dy: 0)
+        }
+
+        if rect.height < minimumHeight {
+            let delta = (minimumHeight - rect.height) / 2
+            rect = rect.insetBy(dx: 0, dy: -delta)
+        }
+
+        self.rect = rect
+        padding()
+    }
     
     func yAxisLabel( for itemNo: Int, of items: Int ) -> Double {
         let labelSpace = Double(rect!.height) / Double(items - 1)
@@ -86,19 +103,15 @@ class ChartContext {
     }
     
     func placeInRect (point: CGPoint) -> CGPoint {
-        guard rect != nil else {
+        guard let rect else {
             track("Invalid Context")
-            fatalError()
-        }
-        guard rect!.width != 0 else {
-            fatalError()
-        }
-        guard rect!.height != 0 else {
-            fatalError()
+            return .zero
         }
 
-        let x = (point.x - rect!.origin.x)/rect!.width
-        let y = (pad + point.y - rect!.origin.y)/rect!.height
+        let width = max(rect.width, 1)
+        let height = max(rect.height, 0.1)
+        let x = (point.x - rect.origin.x)/width
+        let y = (pad + point.y - rect.origin.y)/height
         return CGPoint(x: x, y: 1 - y * Constants.chartOverscan)
     }
 }


+34 -1

USB Meter/Model/Measurements.swift

View

	@@ -45,6 +45,20 @@ class Measurements : ObservableObject {
45	45	context.reset()
46	46	self.objectWillChange.send()
47	47	}
	48	+
	49	+ func trim(before cutoff: Date) {
	50	+ points = points
	51	+ .filter { $0.timestamp >= cutoff }
	52	+ .enumerated()
	53	+ .map { index, point in
	54	+ Measurement.Point(id: index, timestamp: point.timestamp, value: point.value)
	55	+ }
	56	+ context.reset()
	57	+ for point in points {
	58	+ context.include(point: point.point())
	59	+ }
	60	+ self.objectWillChange.send()
	61	+ }
48	62	}
49	63
50	64	@Published var power = Measurement()
	@@ -57,6 +71,18 @@ class Measurements : ObservableObject {
57	71	private var powerSum: Double = 0
58	72	private var voltageSum: Double = 0
59	73	private var currentSum: Double = 0
	74	+
	75	+ func reset() {
	76	+ power.reset()
	77	+ voltage.reset()
	78	+ current.reset()
	79	+ lastPointTimestamp = 0
	80	+ itemsInSum = 0
	81	+ powerSum = 0
	82	+ voltageSum = 0
	83	+ currentSum = 0
	84	+ self.objectWillChange.send()
	85	+ }
60	86
61	87	func remove(at idx: Int) {
62	88	power.removeValue(index: idx)
	@@ -65,6 +91,13 @@ class Measurements : ObservableObject {
65	91	self.objectWillChange.send()
66	92	}
67	93
	94	+ func trim(before cutoff: Date) {
	95	+ power.trim(before: cutoff)
	96	+ voltage.trim(before: cutoff)
	97	+ current.trim(before: cutoff)
	98	+ self.objectWillChange.send()
	99	+ }
	100	+
68	101
69	102
70	103	func addValues(timestamp: Date, power: Double, voltage: Double, current: Double) {
	@@ -74,7 +107,7 @@ class Measurements : ObservableObject {
74	107	}
75	108	if lastPointTimestamp == valuesTimestamp {
76	109	itemsInSum += 1
77		- powerSum += voltage
	110	+ powerSum += power
78	111	voltageSum += voltage
79	112	currentSum += current
80	113	}

+235 -1

USB Meter/Model/Meter.swift

View

+                         case TC66C
+                    +enum TemperatureUnitPreference: String, CaseIterable, Identifiable {
+                    +    case celsius
+                    +    case fahrenheit
+                    +    var id: String { rawValue }
+                    +    var title: String {
+                    +        switch self {
+                    +        case .celsius:
+                    +            return "Celsius"
+                    +        case .fahrenheit:
+                    +            return "Fahrenheit"
+                    +        }
+                    +    }
+                    +    var symbol: String {
+                    +        switch self {
+                    +        case .celsius:
+                    +            return "℃"
+                    +        case .fahrenheit:
+                    +            return "℉"
+                    +        }
+                    +    }
+                    +}
+                    +enum ChargeRecordState {
+                    +    case waitingForStart
+                    +    case active
+                    +    case completed
+                    +}
+                     class Meter : NSObject, ObservableObject, Identifiable {
+                         enum OperationalState: Int, Comparable {
+                             capabilities.supportsRecordingThreshold
+                    +    var reportsCurrentScreenIndex: Bool {
+                    +        capabilities.reportsCurrentScreenIndex
+                    +    }
+                    +    var showsDataGroupEnergy: Bool {
+                    +        capabilities.showsDataGroupEnergy
+                    +    }
+                    +    var highlightsActiveDataGroup: Bool {
+                    +        if model == .TC66C {
+                    +            return hasObservedActiveDataGroup
+                    +        }
+                    +        return capabilities.highlightsActiveDataGroup
+                    +    }
+                         var supportsFahrenheit: Bool {
+                             capabilities.supportsFahrenheit
+                    +    var supportsManualTemperatureUnitSelection: Bool {
+                    +        model == .TC66C
+                    +    }
+                         var supportsChargerDetection: Bool {
+                             capabilities.supportsChargerDetection
+                    +    var dataGroupsTitle: String {
+                    +        capabilities.dataGroupsTitle
+                    +    }
+                         var chargerTypeDescription: String {
+                             capabilities.chargerTypeDescription(for: chargerTypeIndex)
+                    +    var temperatureUnitDescription: String {
+                    +        if supportsManualTemperatureUnitSelection {
+                    +            return tc66TemperatureUnitPreference.title
+                    +        }
+                    +        return supportsFahrenheit ? "Celsius / Fahrenheit" : "Celsius"
+                    +    }
+                    +    var primaryTemperatureDescription: String {
+                    +        let value = temperatureCelsius.format(decimalDigits: 0)
+                    +        if supportsManualTemperatureUnitSelection {
+                    +            return "\(value)\(tc66TemperatureUnitPreference.symbol)"
+                    +        }
+                    +        if let symbol = capabilities.primaryTemperatureUnitSymbol {
+                    +            return "\(value)\(symbol)"
+                    +        }
+                    +        return value
+                    +    }
+                    +    var secondaryTemperatureDescription: String? {
+                    +        guard supportsFahrenheit else { return nil }
+                    +        return "\(temperatureFahrenheit.format(decimalDigits: 0))℉"
+                    +    }
+                         var currentScreenDescription: String {
+                    +        guard reportsCurrentScreenIndex else {
+                    +            return "Page Controls"
+                    +        }
+                             if let label = capabilities.screenDescription(for: currentScreen) {
+                                 return "Screen \(currentScreen): \(label)"
+                             return String(format: "%02d:%02d", minutes, seconds)
+                    +    var chargeRecordDurationDescription: String {
+                    +        let totalSeconds = Int(chargeRecordDuration)
+                    +        let hours = totalSeconds / 3600
+                    +        let minutes = (totalSeconds % 3600) / 60
+                    +        let seconds = totalSeconds % 60
+                    +        if hours > 0 {
+                    +            return String(format: "%d:%02d:%02d", hours, minutes, seconds)
+                    +        }
+                    +        return String(format: "%02d:%02d", minutes, seconds)
+                    +    }
+                    +    var chargeRecordTimeRange: ClosedRange<Date>? {
+                    +        guard let start = chargeRecordStartTimestamp else { return nil }
+                    +        let end = chargeRecordEndTimestamp ?? chargeRecordLastTimestamp
+                    +        guard let end else { return nil }
+                    +        return start...end
+                    +    }
+                    +    var chargeRecordStatusText: String {
+                    +        switch chargeRecordState {
+                    +        case .waitingForStart:
+                    +            return "Waiting"
+                    +        case .active:
+                    +            return "Active"
+                    +        case .completed:
+                    +            return "Completed"
+                    +        }
+                    +    }
+                    +    var chargeRecordStatusColor: Color {
+                    +        switch chargeRecordState {
+                    +        case .waitingForStart:
+                    +            return .secondary
+                    +        case .active:
+                    +            return .red
+                    +        case .completed:
+                    +            return .green
+                    +        }
+                    +    }
+                         var dataGroupsHint: String? {
+                    -        capabilities.dataGroupsHint
+                    +        if model == .TC66C {
+                    +            if hasObservedActiveDataGroup {
+                    +                return "The active memory is inferred from the totals that are currently increasing."
+                    +            }
+                    +            return "The device exposes two read-only memories. The active memory is inferred once one total starts increasing."
+                    +        }
+                    +        return capabilities.dataGroupsHint
+                    +    }
+                    +    func dataGroupLabel(for id: UInt8) -> String {
+                    +        supportsDataGroupCommands ? "\(id)" : "M\(Int(id) + 1)"
+                         var recordingThresholdHint: String? {
+                         @Published var selectedDataGroup: UInt8 = 0
+                         @Published var dataGroupRecords: [Int : DataGroupRecord] = [:]
+                    +    @Published var chargeRecordAH: Double = 0
+                    +    @Published var chargeRecordWH: Double = 0
+                    +    @Published var chargeRecordDuration: TimeInterval = 0
+                    +    @Published var chargeRecordStopThreshold: Double = 0.05
+                    +    @Published var tc66TemperatureUnitPreference: TemperatureUnitPreference = .celsius {
+                    +        didSet {
+                    +            guard supportsManualTemperatureUnitSelection else { return }
+                    +            guard oldValue != tc66TemperatureUnitPreference else { return }
+                    +            var settings = appData.tc66TemperatureUnits
+                    +            settings[btSerial.macAddress.description] = tc66TemperatureUnitPreference.rawValue
+                    +            appData.tc66TemperatureUnits = settings
+                    +        }
+                    +    }
+                         @Published var screenBrightness: Int = -1 {
+                             didSet {
+                         private var recordingThresholdTimestamp = Date()
+                         private var recordingThresholdLoadedFromDevice = false
+                         private var isApplyingRecordingThresholdFromDevice = false
+                    +    @Published private(set) var chargeRecordState = ChargeRecordState.waitingForStart
+                    +    private var chargeRecordStartTimestamp: Date?
+                    +    private var chargeRecordEndTimestamp: Date?
+                    +    private var chargeRecordLastTimestamp: Date?
+                    +    private var chargeRecordLastCurrent: Double = 0
+                    +    private var chargeRecordLastPower: Double = 0
+                    +    private var hasObservedActiveDataGroup = false
+                    +    private var hasSeenTC66Snapshot = false
+                         init ( model: Model, with serialPort: BluetoothSerial ) {
+                             uuid = serialPort.peripheral.identifier
+                             name = appData.meterNames[serialPort.macAddress.description] ?? serialPort.macAddress.description
+                             super.init()
+                             btSerial.delegate = self
+                    +        reloadTemperatureUnitPreference()
+                             //name = dataStore.meterNames[macAddress.description] ?? peripheral.name!
+                             for index in stride(from: 0, through: 9, by: 1) {
+                                 dataGroupRecords[index] = DataGroupRecord(ah:0, wh: 0)
+                    +    func reloadTemperatureUnitPreference() {
+                    +        guard supportsManualTemperatureUnitSelection else { return }
+                    +        let rawValue = appData.tc66TemperatureUnits[btSerial.macAddress.description] ?? TemperatureUnitPreference.celsius.rawValue
+                    +        let persistedPreference = TemperatureUnitPreference(rawValue: rawValue) ?? .celsius
+                    +        if tc66TemperatureUnitPreference != persistedPreference {
+                    +            tc66TemperatureUnitPreference = persistedPreference
+                    +        }
+                    +    }
+                         func dataDumpRequest() {
+                             if commandQueue.isEmpty {
+                                     track("\(name) - Error: \(error)")
+                    +        updateChargeRecord(at: dataDumpRequestTimestamp)
+                             measurements.addValues(timestamp: dataDumpRequestTimestamp, power: power, voltage: voltage, current: current)
+                     //        DispatchQueue.global(qos: .userInitiated).asyncAfter( deadline: .now() + 0.33 ) {
+                     //            //track("\(name) - Scheduled new request.")
+                         private func apply(tc66Snapshot snapshot: TC66Snapshot) {
+                    +        if hasSeenTC66Snapshot {
+                    +            inferTC66ActiveDataGroup(from: snapshot)
+                    +        } else {
+                    +            hasSeenTC66Snapshot = true
+                    +        }
+                             reportedModelName = snapshot.modelName
+                             firmwareVersion = snapshot.firmwareVersion
+                             serialNumber = snapshot.serialNumber
+                             usbPlusVoltage = snapshot.usbPlusVoltage
+                             usbMinusVoltage = snapshot.usbMinusVoltage
+                    +    private func inferTC66ActiveDataGroup(from snapshot: TC66Snapshot) {
+                    +        let candidate = snapshot.dataGroupRecords.compactMap { entry -> (UInt8, Double)? in
+                    +            let index = entry.key
+                    +            let record = entry.value
+                    +            guard let previous = dataGroupRecords[index] else { return nil }
+                    +            let deltaAH = max(record.ah - previous.ah, 0)
+                    +            let deltaWH = max(record.wh - previous.wh, 0)
+                    +            let score = deltaAH + deltaWH
+                    +            guard score > 0 else { return nil }
+                    +            return (UInt8(index), score)
+                    +        }
+                    +        .max { lhs, rhs in lhs.1 < rhs.1 }
+                    +        if let candidate {
+                    +            selectedDataGroup = candidate.0
+                    +            hasObservedActiveDataGroup = true
+                    +        }
+                    +    }
+                    +    private func updateChargeRecord(at timestamp: Date) {
+                    +        switch chargeRecordState {
+                    +        case .waitingForStart:
+                    +            guard current > chargeRecordStopThreshold else { return }
+                    +            chargeRecordState = .active
+                    +            chargeRecordStartTimestamp = timestamp
+                    +            chargeRecordEndTimestamp = timestamp
+                    +            chargeRecordLastTimestamp = timestamp
+                    +            chargeRecordLastCurrent = current
+                    +            chargeRecordLastPower = power
+                    +        case .active:
+                    +            if let lastTimestamp = chargeRecordLastTimestamp {
+                    +                let deltaSeconds = max(timestamp.timeIntervalSince(lastTimestamp), 0)
+                    +                chargeRecordAH += chargeRecordLastCurrent * deltaSeconds / 3600
+                    +                chargeRecordWH += chargeRecordLastPower * deltaSeconds / 3600
+                    +                chargeRecordDuration += deltaSeconds
+                    +            }
+                    +            chargeRecordEndTimestamp = timestamp
+                    +            chargeRecordLastTimestamp = timestamp
+                    +            chargeRecordLastCurrent = current
+                    +            chargeRecordLastPower = power
+                    +            if current <= chargeRecordStopThreshold {
+                    +                chargeRecordState = .completed
+                    +            }
+                    +        case .completed:
+                    +            break
+                    +        }
+                    +    }
+                    +    func resetChargeRecord() {
+                    +        chargeRecordAH = 0
+                    +        chargeRecordWH = 0
+                    +        chargeRecordDuration = 0
+                    +        chargeRecordState = .waitingForStart
+                    +        chargeRecordStartTimestamp = nil
+                    +        chargeRecordEndTimestamp = nil
+                    +        chargeRecordLastTimestamp = nil
+                    +        chargeRecordLastCurrent = 0
+                    +        chargeRecordLastPower = 0
+                    +    }
+                    +    func resetChargeRecordGraph() {
+                    +        let cutoff = Date()
+                    +        resetChargeRecord()
+                    +        measurements.trim(before: cutoff)
+                    +    }
+                         func nextScreen() {
+                             switch model {

+19 -4

USB Meter/Model/MeterCapabilities.swift

View

@@ -13,8 +13,13 @@ struct MeterCapabilities {
     let supportsRecordingView: Bool
     let supportsScreenSettings: Bool
     let supportsRecordingThreshold: Bool
+    let reportsCurrentScreenIndex: Bool
+    let showsDataGroupEnergy: Bool
+    let highlightsActiveDataGroup: Bool
     let supportsFahrenheit: Bool
     let supportsChargerDetection: Bool
+    let primaryTemperatureUnitSymbol: String?
+    let dataGroupsTitle: String
     let chargerTypeDescriptions: [UInt16: String]
     let screenDescriptions: [UInt16: String]
     let dataGroupsHint: String?
@@ -40,8 +45,13 @@ extension MeterCapabilities {
         supportsRecordingView: true,
         supportsScreenSettings: true,
         supportsRecordingThreshold: true,
+        reportsCurrentScreenIndex: true,
+        showsDataGroupEnergy: true,
+        highlightsActiveDataGroup: true,
         supportsFahrenheit: true,
         supportsChargerDetection: true,
+        primaryTemperatureUnitSymbol: "℃",
+        dataGroupsTitle: "Data Groups",
         chargerTypeDescriptions: [
             1: "QC2",
             2: "QC3",
@@ -60,21 +70,26 @@ extension MeterCapabilities {
             4: "Graphing",
             5: "System Settings"
         ],
-        dataGroupsHint: "Group 0 is temporary. Groups 1-9 persist across power cycles.",
-        recordingThresholdHint: "Recording starts automatically when current rises above this threshold."
+        dataGroupsHint: "The active group is reported by the meter. Group 0 is temporary. Groups 1-9 persist across power cycles.",
+        recordingThresholdHint: "The meter starts its built-in charge record when current rises above this threshold."
     )
 
     static let tc66c = MeterCapabilities(
         availableDataGroupIDs: [0, 1],
         supportsDataGroupCommands: false,
-        supportsRecordingView: false,
+        supportsRecordingView: true,
         supportsScreenSettings: false,
         supportsRecordingThreshold: false,
+        reportsCurrentScreenIndex: false,
+        showsDataGroupEnergy: true,
+        highlightsActiveDataGroup: false,
         supportsFahrenheit: false,
         supportsChargerDetection: false,
+        primaryTemperatureUnitSymbol: nil,
+        dataGroupsTitle: "Memory Totals",
         chargerTypeDescriptions: [:],
         screenDescriptions: [:],
-        dataGroupsHint: nil,
+        dataGroupsHint: "The device exposes two read-only memories with charge and energy totals. The active memory is not reported.",
         recordingThresholdHint: nil
     )
 }


+2 -2

USB Meter/Model/TC66Protocol.swift

View

@@ -89,7 +89,7 @@ enum TC66Protocol {
             let offset = 8 + index * 8
             dataGroupRecords[index] = TC66DataGroupTotals(
                 ah: Double(UInt32(littleEndian: pac2.value(from: offset))) / 1000,
-                wh: Double(UInt32(littleEndian: pac2.value(from: offset + 40))) / 1000
+                wh: Double(UInt32(littleEndian: pac2.value(from: offset + 4))) / 1000
             )
         }
 
@@ -104,7 +104,7 @@ enum TC66Protocol {
             voltage: Double(UInt32(littleEndian: pac1.value(from: 48))) / 10000,
             current: Double(UInt32(littleEndian: pac1.value(from: 52))) / 100000,
             power: Double(UInt32(littleEndian: pac1.value(from: 56))) / 10000,
-            loadResistance: Double(UInt32(littleEndian: pac2.value(from: 4))) / 10,
+            loadResistance: Double(UInt32(littleEndian: pac2.value(from: 4))) / 100,
             dataGroupRecords: dataGroupRecords,
             temperatureCelsius: temperatureMagnitude * temperatureSign,
             usbPlusVoltage: Double(UInt32(littleEndian: pac2.value(from: 32))) / 100,


+6 -0

USB Meter/Views/Meter/ControlView.swift

View

@@ -23,6 +23,12 @@ struct ControlView: View {
                     Text(meter.currentScreenDescription)
                     Button(action: { self.meter.nextScreen() }, label: { Image(systemName: "arrowtriangle.right") })
                 }
+                if !meter.reportsCurrentScreenIndex {
+                    Text("This protocol supports page navigation, but not current-page reporting.")
+                        .font(.footnote)
+                        .foregroundColor(.secondary)
+                        .multilineTextAlignment(.center)
+                }
             }
         }
     }


+24 -12

USB Meter/Views/Meter/Data Groups/DataGroupRowView.swift

View

@@ -14,14 +14,20 @@ struct DataGroupRowView: View {
     var id: UInt8
     var width: CGFloat
     var opacity: Double
+    var showsCommands: Bool
+    var showsEnergy: Bool
+    var highlightsSelection: Bool
     
     @EnvironmentObject private var usbMeter: Meter
     
     var body: some View {
         HStack (spacing: 1) {
             ZStack {
-                Button(action: { self.usbMeter.selectDataGroup(id: self.id) }, label: { Image(systemName: "\(id).circle") })
-                    .disabled(!usbMeter.supportsDataGroupCommands)
+                if showsCommands {
+                    Button(action: { self.usbMeter.selectDataGroup(id: self.id) }, label: { Image(systemName: "\(id).circle") })
+                } else {
+                    Text(usbMeter.dataGroupLabel(for: id))
+                }
                 Rectangle().opacity( opacity )
             }.frame(width: width)
             
@@ -30,17 +36,23 @@ struct DataGroupRowView: View {
                 Rectangle().opacity( opacity )
             }.frame(width: width)
             
-            ZStack {
-                Text("\(usbMeter.dataGroupRecords[Int(id)]!.wh.format(decimalDigits: 3))")
-                Rectangle().opacity( opacity )
-            }.frame(width: width)
+            if showsEnergy {
+                ZStack {
+                    Text("\(usbMeter.dataGroupRecords[Int(id)]!.wh.format(decimalDigits: 3))")
+                    Rectangle().opacity( opacity )
+                }.frame(width: width)
+            }
             
-            ZStack {
-                Button(action: { self.usbMeter.clear(group: self.id) }, label: { Image(systemName: "bin.xmark") })
-                    .disabled(!usbMeter.supportsDataGroupCommands)
-                Rectangle().opacity( opacity )
-            }.frame(width: width)
+            if showsCommands {
+                ZStack {
+                    Button(action: { self.usbMeter.clear(group: self.id) }, label: { Image(systemName: "bin.xmark") })
+                    Rectangle().opacity( opacity )
+                }.frame(width: width)
+            }
         }
-        .background(BorderView(show: usbMeter.selectedDataGroup == id))
+        .overlay(
+            RoundedRectangle(cornerRadius: 10)
+                .stroke(highlightsSelection && usbMeter.selectedDataGroup == id ? Color.accentColor : Color.clear, lineWidth: 3)
+        )
     }
 }


+15 -4

USB Meter/Views/Meter/Data Groups/DataGroupsView.swift

View

@@ -16,13 +16,17 @@ struct DataGroupsView: View {
     
     var body: some View {
         GeometryReader { box in
+            let columnTitles = [usbMeter.supportsDataGroupCommands ? "Group" : "Memory", "Ah"]
+                + (usbMeter.showsDataGroupEnergy ? ["Wh"] : [])
+                + (usbMeter.supportsDataGroupCommands ? ["Clear"] : [])
+            let columnWidth = (box.size.width - 25) / CGFloat(columnTitles.count)
             let tableReservedHeight: CGFloat = usbMeter.dataGroupsHint == nil ? 100 : 140
             let rowCount = CGFloat(usbMeter.availableDataGroupIDs.count + 1)
             let rowHeight = (box.size.height - tableReservedHeight) / rowCount
 
             VStack (spacing: 1) {
                 HStack {
-                    Text("Data Groups")
+                    Text(usbMeter.dataGroupsTitle)
                         .bold()
                     Spacer()
                     Button(action: {self.visibility.toggle()}) {
@@ -43,13 +47,20 @@ struct DataGroupsView: View {
                 }
                 
                 HStack (spacing: 1) {
-                    ForEach (["Group", "Ah", "Wh", "Clear"], id: \.self ) { text in
-                        self.THView( text: text, width: (box.size.width-25)/4 )
+                    ForEach(columnTitles, id: \.self ) { text in
+                        self.THView(text: text, width: columnWidth)
                     }
                 }
                 .frame(height: rowHeight)
                 ForEach(usbMeter.availableDataGroupIDs, id: \.self) { groupId in
-                    DataGroupRowView(id: groupId, width: ((box.size.width-25) / 4), opacity: groupId.isMultiple(of: 2) ? 0.1 : 0.2)
+                    DataGroupRowView(
+                        id: groupId,
+                        width: columnWidth,
+                        opacity: groupId.isMultiple(of: 2) ? 0.1 : 0.2,
+                        showsCommands: usbMeter.supportsDataGroupCommands,
+                        showsEnergy: usbMeter.showsDataGroupEnergy,
+                        highlightsSelection: usbMeter.highlightsActiveDataGroup
+                    )
                 }
                 .frame(height: rowHeight)
             }


+4 -4

USB Meter/Views/Meter/LiveView.swift

View

@@ -23,7 +23,7 @@ struct LiveView: View {
                     Text("Power:")
                     Text("Load")
                     Text("Temperature:")
-                    if meter.supportsFahrenheit {
+                    if meter.secondaryTemperatureDescription != nil {
                         Text("")
                     }
                     Text("USB Data+:")
@@ -49,9 +49,9 @@ struct LiveView: View {
                         Text("\(meter.measurements.power.context.maxValue.format(decimalDigits: 3))W")
                     }
                     Text("\(meter.loadResistance.format(decimalDigits: 1))Ω")
-                    Text("\(meter.temperatureCelsius)℃")
-                    if meter.supportsFahrenheit {
-                        Text("\(meter.temperatureFahrenheit)℉")
+                    Text(meter.primaryTemperatureDescription)
+                    if let secondaryTemperatureDescription = meter.secondaryTemperatureDescription {
+                        Text(secondaryTemperatureDescription)
                     }
                     Text("\(meter.usbPlusVoltage.format(decimalDigits: 2))V")
                     Text("\(meter.usbMinusVoltage.format(decimalDigits: 2))V")


+68 -18

USB Meter/Views/Meter/Measurements/Chart/MeasurementChartView.swift

View

@@ -9,8 +9,13 @@
 import SwiftUI
 
 struct MeasurementChartView: View {
+    private let minimumTimeSpan: TimeInterval = 1
+    private let minimumVoltageSpan = 0.1
+    private let minimumCurrentSpan = 0.1
+    private let minimumPowerSpan = 0.1
     
     @EnvironmentObject private var measurements: Measurements
+    var timeRange: ClosedRange<Date>? = nil
     
     @State var displayVoltage: Bool = false
     @State var displayCurrent: Bool = false
@@ -19,8 +24,16 @@ struct MeasurementChartView: View {
     let yLabels: Int = 4
 
     var body: some View {
+        let powerSeries = series(for: measurements.power, minimumYSpan: minimumPowerSpan)
+        let voltageSeries = series(for: measurements.voltage, minimumYSpan: minimumVoltageSpan)
+        let currentSeries = series(for: measurements.current, minimumYSpan: minimumCurrentSpan)
+        let primarySeries = displayedPrimarySeries(
+            powerSeries: powerSeries,
+            voltageSeries: voltageSeries,
+            currentSeries: currentSeries
+        )
+
         Group {
-            //if measurements.power.points.count > 0 {
             VStack {
                 HStack {
                     Button( action: {
@@ -47,37 +60,34 @@ struct MeasurementChartView: View {
                         .asEnableFeatureButton(state: displayPower)
                 }
                 .padding(.bottom, 5)
-                if measurements.current.context.isValid {
+                if let primarySeries {
                     VStack {
                         GeometryReader { geometry in
                             HStack {
                                 Group { // MARK: Left Legend
                                     if self.displayPower {
-                                        self.yAxisLabelsView(geometry: geometry, context: self.measurements.power.context, measurementUnit: "W")
+                                        self.yAxisLabelsView(geometry: geometry, context: powerSeries.context, measurementUnit: "W")
                                             .withRoundedRectangleBackground(cornerRadius: 0, foregroundColor: .red, opacity: 0.5)
                                     } else if self.displayVoltage {
-                                        self.yAxisLabelsView(geometry: geometry, context: self.measurements.voltage.context, measurementUnit: "V")
+                                        self.yAxisLabelsView(geometry: geometry, context: voltageSeries.context, measurementUnit: "V")
                                             .withRoundedRectangleBackground(cornerRadius: 0, foregroundColor: .green, opacity: 0.5)
                                     }
                                     else if self.displayCurrent {
-                                        self.yAxisLabelsView(geometry: geometry, context: self.measurements.current.context, measurementUnit: "A")
+                                        self.yAxisLabelsView(geometry: geometry, context: currentSeries.context, measurementUnit: "A")
                                             .withRoundedRectangleBackground(cornerRadius: 0, foregroundColor: .blue, opacity: 0.5)
                                     }
                                 }
                                 ZStack { // MARK: Graph
                                     if self.displayPower {
-                                        Chart(strokeColor: .red)
-                                            .environmentObject(self.measurements.power)
+                                        Chart(points: powerSeries.points, context: powerSeries.context, strokeColor: .red)
                                             .opacity(0.5)
                                     } else {
                                         if self.displayVoltage{
-                                            Chart(strokeColor: .green)
-                                                .environmentObject(self.measurements.voltage)
+                                            Chart(points: voltageSeries.points, context: voltageSeries.context, strokeColor: .green)
                                                 .opacity(0.5)
                                         }
                                         if self.displayCurrent{
-                                            Chart(strokeColor: .blue)
-                                                .environmentObject(self.measurements.current)
+                                            Chart(points: currentSeries.points, context: currentSeries.context, strokeColor: .blue)
                                                 .opacity(0.5)
                                         }
                                     }
@@ -88,13 +98,13 @@ struct MeasurementChartView: View {
                                 }
                                 .withRoundedRectangleBackground( cornerRadius: 0, foregroundColor: .primary, opacity: 0.06 )
                                 Group { // MARK: Right Legend
-                                    self.yAxisLabelsView(geometry: geometry, context: self.measurements.current.context, measurementUnit: "A")
+                                    self.yAxisLabelsView(geometry: geometry, context: currentSeries.context, measurementUnit: "A")
                                         .foregroundColor(self.displayVoltage && self.displayCurrent ? .primary : .clear)
                                         .withRoundedRectangleBackground(cornerRadius: 0, foregroundColor: .blue, opacity: 0.5)
                                 }
                             }
                         }
-                        xAxisLabelsView(context: self.measurements.current.context)
+                        xAxisLabelsView(context: primarySeries.context)
                             .padding(.horizontal, 10)
                         
                     }
@@ -111,6 +121,44 @@ struct MeasurementChartView: View {
             .padding()
         }
     }
+
+    private func displayedPrimarySeries(
+        powerSeries: (points: [Measurements.Measurement.Point], context: ChartContext),
+        voltageSeries: (points: [Measurements.Measurement.Point], context: ChartContext),
+        currentSeries: (points: [Measurements.Measurement.Point], context: ChartContext)
+    ) -> (points: [Measurements.Measurement.Point], context: ChartContext)? {
+        if displayPower {
+            return powerSeries.points.isEmpty ? nil : powerSeries
+        }
+        if displayVoltage {
+            return voltageSeries.points.isEmpty ? nil : voltageSeries
+        }
+        if displayCurrent {
+            return currentSeries.points.isEmpty ? nil : currentSeries
+        }
+        return nil
+    }
+
+    private func series(
+        for measurement: Measurements.Measurement,
+        minimumYSpan: Double
+    ) -> (points: [Measurements.Measurement.Point], context: ChartContext) {
+        let points = measurement.points.filter { point in
+            guard let timeRange else { return true }
+            return timeRange.contains(point.timestamp)
+        }
+        let context = ChartContext()
+        for point in points {
+            context.include(point: point.point())
+        }
+        if !points.isEmpty {
+            context.ensureMinimumSize(
+                width: CGFloat(minimumTimeSpan),
+                height: CGFloat(minimumYSpan)
+            )
+        }
+        return (points, context)
+    }
     
     // MARK: Cu iteratie nu functioneaza deoarece view-ul din bucla nu este reimprospatat la modificare obiectului observat
     fileprivate func xAxisLabelsView(context: ChartContext) -> some View {
@@ -189,7 +237,8 @@ struct MeasurementChartView: View {
 
 struct Chart : View {
     
-    @EnvironmentObject private var measurement: Measurements.Measurement
+    let points: [Measurements.Measurement.Point]
+    let context: ChartContext
     var areaChart: Bool = false
     var strokeColor: Color = .black
     
@@ -207,14 +256,15 @@ struct Chart : View {
     
     fileprivate func path(geometry: GeometryProxy) -> Path {
         return Path { path in
-            let firstPoint = measurement.context.placeInRect(point: measurement.points.first!.point())
+            guard let first = points.first else { return }
+            let firstPoint = context.placeInRect(point: first.point())
             path.move(to: CGPoint(x: firstPoint.x * geometry.size.width, y: firstPoint.y * geometry.size.height ) )
-            for item in measurement.points.map({ measurement.context.placeInRect(point: $0.point()) }) {
+            for item in points.map({ context.placeInRect(point: $0.point()) }) {
                 path.addLine(to: CGPoint(x: item.x * geometry.size.width, y: item.y * geometry.size.height ) )
             }
             if self.areaChart {
-                let lastPointX = measurement.context.placeInRect(point: CGPoint(x: measurement.points.last!.point().x, y: measurement.context.origin.y ))
-                let firstPointX = measurement.context.placeInRect(point: CGPoint(x: measurement.points.first!.point().x, y: measurement.context.origin.y ))
+                let lastPointX = context.placeInRect(point: CGPoint(x: points.last!.point().x, y: context.origin.y ))
+                let firstPointX = context.placeInRect(point: CGPoint(x: points.first!.point().x, y: context.origin.y ))
                 path.addLine(to: CGPoint(x: lastPointX.x * geometry.size.width, y: lastPointX.y * geometry.size.height ) )
                 path.addLine(to: CGPoint(x: firstPointX.x * geometry.size.width, y: firstPointX.y * geometry.size.height ) )
                 // MARK: Nu e nevoie. Fill inchide automat calea


+17 -0

USB Meter/Views/Meter/MeterSettingsView.swift

View

@@ -40,6 +40,7 @@ struct MeterSettingsView: View {
                         Text("Device Info").fontWeight(.semibold)
                         DeviceInfoRow(label: "Advertised Model", value: meter.modelString)
                         DeviceInfoRow(label: "Displayed Model", value: meter.deviceModelSummary)
+                        DeviceInfoRow(label: "Temperature Unit", value: meter.temperatureUnitDescription)
                         if meter.modelNumber != 0 {
                             DeviceInfoRow(label: "Model Code", value: "\(meter.modelNumber)")
                         }
@@ -56,6 +57,22 @@ struct MeterSettingsView: View {
                     .padding()
                     .background(RoundedRectangle(cornerRadius: 15).foregroundColor(.secondary).opacity(0.1))
                 }
+                if meter.operationalState == .dataIsAvailable && meter.supportsManualTemperatureUnitSelection {
+                    VStack(alignment: .leading, spacing: 8) {
+                        Text("Temperature Unit").fontWeight(.semibold)
+                        Text("TC66 reports temperature using the unit selected on the device. Keep this setting matched to the meter.")
+                            .font(.footnote)
+                            .foregroundColor(.secondary)
+                        Picker("", selection: $meter.tc66TemperatureUnitPreference) {
+                            ForEach(TemperatureUnitPreference.allCases) { unit in
+                                Text(unit.title).tag(unit)
+                            }
+                        }
+                        .pickerStyle(SegmentedPickerStyle())
+                    }
+                    .padding()
+                    .background(RoundedRectangle(cornerRadius: 15).foregroundColor(.secondary).opacity(0.1))
+                }
                 if meter.operationalState == .dataIsAvailable && meter.supportsUMSettings {
                     // MARK: Screen Timeout
                     // Ar trebui separat enabled/disabled de valorile in minute eventual stocata valoarea in iCloud la dezactivare pentru restaurare


+2 -2

USB Meter/Views/Meter/MeterView.swift

View

@@ -45,7 +45,7 @@ struct MeterView: View {
             if ( meter.operationalState ==  .dataIsAvailable) {
                 Text("Model: \(meter.deviceModelSummary)")
                 HStack(spacing: 24) {
-                    meterSheetButton(icon: "map", title: "Data Groups") {
+                    meterSheetButton(icon: "map", title: meter.dataGroupsTitle) {
                         dataGroupsViewVisibility.toggle()
                     }
                     .sheet(isPresented: self.$dataGroupsViewVisibility) {
@@ -54,7 +54,7 @@ struct MeterView: View {
                     }
 
                     if meter.supportsRecordingView {
-                        meterSheetButton(icon: "record.circle", title: "Recording") {
+                        meterSheetButton(icon: "record.circle", title: "Charge Record") {
                             recordingViewVisibility.toggle()
                         }
                         .sheet(isPresented: self.$recordingViewVisibility) {


+74 -27

USB Meter/Views/Meter/RecordingView.swift

View

+                                 ScrollView {
+                                     VStack(spacing: 16) {
+                                         VStack(spacing: 6) {
+                    -                        Text("Device Recording")
+                    +                        Text("Charge Record")
+                                                 .font(.headline)
+                    -                        Text(usbMeter.recording ? "Active" : "Idle")
+                    -                            .foregroundColor(usbMeter.recording ? .red : .secondary)
+                    +                        Text(usbMeter.chargeRecordStatusText)
+                    +                            .foregroundColor(usbMeter.chargeRecordStatusColor)
+                                         .frame(maxWidth: .infinity)
+                                         .padding()
+                                                 Text("Capacity")
+                                                 Text("Energy")
+                                                 Text("Duration")
+                    -                            Text("Start Threshold")
+                    +                            Text("Stop Threshold")
+                                             Spacer()
+                                             VStack(alignment: .trailing, spacing: 10) {
+                    -                            Text("\(usbMeter.recordedAH.format(decimalDigits: 3)) Ah")
+                    -                            Text("\(usbMeter.recordedWH.format(decimalDigits: 3)) Wh")
+                    -                            Text(usbMeter.recordingDurationDescription)
+                    -                            if usbMeter.supportsRecordingThreshold {
+                    -                                Text("\(usbMeter.recordingTreshold.format(decimalDigits: 2)) A")
+                    -                            } else {
+                    -                                Text("Read-only")
+                    -                            }
+                    +                            Text("\(usbMeter.chargeRecordAH.format(decimalDigits: 3)) Ah")
+                    +                            Text("\(usbMeter.chargeRecordWH.format(decimalDigits: 3)) Wh")
+                    +                            Text(usbMeter.chargeRecordDurationDescription)
+                    +                            Text("\(usbMeter.chargeRecordStopThreshold.format(decimalDigits: 2)) A")
+                                         .padding()
+                                         .background(RoundedRectangle(cornerRadius: 16).foregroundColor(.secondary).opacity(0.1))
+                    -                    if usbMeter.supportsRecordingThreshold {
+                    -                        VStack(alignment: .leading, spacing: 10) {
+                    -                            Text("Start Threshold")
+                    -                                .fontWeight(.semibold)
+                    -                            Slider(value: $usbMeter.recordingTreshold, in: 0...0.30, step: 0.01)
+                    -                            if let hint = usbMeter.recordingThresholdHint {
+                    -                                Text(hint)
+                    -                                    .font(.footnote)
+                    -                                    .foregroundColor(.secondary)
+                    +                    if usbMeter.chargeRecordTimeRange != nil {
+                    +                        VStack(alignment: .leading, spacing: 12) {
+                    +                            HStack {
+                    +                                Text("Charge Curve")
+                    +                                    .fontWeight(.semibold)
+                    +                                Spacer()
+                    +                                Button("Reset Graph") {
+                    +                                    usbMeter.resetChargeRecordGraph()
+                    +                                }
+                    +                            MeasurementChartView(timeRange: usbMeter.chargeRecordTimeRange)
+                    +                                .environmentObject(usbMeter.measurements)
+                    +                                .frame(minHeight: 220)
+                    +                            Text("Reset Graph clears the current charge-record session and removes older shared samples that are no longer needed for this curve.")
+                    +                                .font(.footnote)
+                    +                                .foregroundColor(.secondary)
+                                             .padding()
+                                             .background(RoundedRectangle(cornerRadius: 16).foregroundColor(.secondary).opacity(0.1))
+                    -                    } else {
+                    -                        Text("This model reports recording totals, but the app does not expose remote threshold control for it.")
+                    +                    }
+                    +                    VStack(alignment: .leading, spacing: 12) {
+                    +                        Text("Stop Threshold")
+                    +                            .fontWeight(.semibold)
+                    +                        Slider(value: $usbMeter.chargeRecordStopThreshold, in: 0...0.30, step: 0.01)
+                    +                        Text("The app starts accumulating when current rises above this threshold and stops when it falls back to or below it.")
+                                                 .font(.footnote)
+                                                 .foregroundColor(.secondary)
+                    -                            .multilineTextAlignment(.center)
+                    -                            .padding()
+                    -                            .background(RoundedRectangle(cornerRadius: 16).foregroundColor(.secondary).opacity(0.1))
+                    +                        Button("Reset") {
+                    +                            usbMeter.resetChargeRecord()
+                    +                        }
+                    +                        .frame(maxWidth: .infinity)
+                    +                    }
+                    +                    .padding()
+                    +                    .background(RoundedRectangle(cornerRadius: 16).foregroundColor(.secondary).opacity(0.1))
+                    +                    if usbMeter.supportsDataGroupCommands || usbMeter.recordedAH > 0 || usbMeter.recordedWH > 0 || usbMeter.recordingDuration > 0 {
+                    +                        VStack(alignment: .leading, spacing: 12) {
+                    +                            Text("Meter Totals")
+                    +                                .fontWeight(.semibold)
+                    +                            HStack(alignment: .top) {
+                    +                                VStack(alignment: .leading, spacing: 10) {
+                    +                                    Text("Capacity")
+                    +                                    Text("Energy")
+                    +                                    Text("Duration")
+                    +                                    Text("Meter Threshold")
+                    +                                }
+                    +                                Spacer()
+                    +                                VStack(alignment: .trailing, spacing: 10) {
+                    +                                    Text("\(usbMeter.recordedAH.format(decimalDigits: 3)) Ah")
+                    +                                    Text("\(usbMeter.recordedWH.format(decimalDigits: 3)) Wh")
+                    +                                    Text(usbMeter.recordingDurationDescription)
+                    +                                    if usbMeter.supportsRecordingThreshold {
+                    +                                        Text("\(usbMeter.recordingTreshold.format(decimalDigits: 2)) A")
+                    +                                    } else {
+                    +                                        Text("Read-only")
+                    +                                    }
+                    +                                }
+                    +                            }
+                    +                            Text("These values are reported by the meter for the active data group.")
+                    +                                .font(.footnote)
+                    +                                .foregroundColor(.secondary)
+                    +                            if usbMeter.supportsDataGroupCommands {
+                    +                                Button("Reset Active Group") {
+                    +                                    usbMeter.clear()
+                    +                                }
+                    +                                .frame(maxWidth: .infinity)
+                    +                            }
+                    +                        }
+                    +                        .padding()
+                    +                        .background(RoundedRectangle(cornerRadius: 16).foregroundColor(.secondary).opacity(0.1))
+                                     .padding()
+                    -            .navigationBarTitle("Device Recording", displayMode: .inline)
+                    +            .navigationBarTitle("Charge Record", displayMode: .inline)
+                                 .navigationBarItems(trailing: Button("Done") { visibility.toggle() })
+                             .navigationViewStyle(StackNavigationViewStyle())

	@@ -40,6 +40,7 @@ final class AppData : ObservableObject {
40	40	}
41	41
42	42	@ICloudDefault(key: "MeterNames", defaultValue: [:]) var meterNames: [String:String]
	43	+ @ICloudDefault(key: "TC66TemperatureUnits", defaultValue: [:]) var tc66TemperatureUnits: [String:String]
43	44	func test(notification: NotificationCenter.Publisher.Output) -> Void {
44	45	if let changedKeys = notification.userInfo?["NSUbiquitousKeyValueStoreChangedKeysKey"] as? [String] {
45	46	var somethingChanged = false
	@@ -54,6 +55,11 @@ final class AppData : ObservableObject {
54	55	}
55	56	}
56	57	}
	58	+ case "TC66TemperatureUnits":
	59	+ for meter in self.meters.values where meter.supportsManualTemperatureUnitSelection {
	60	+ meter.reloadTemperatureUnitPreference()
	61	+ somethingChanged = true
	62	+ }
57	63	default:
58	64	track("Unknown key: '\(changedKey)' changed in iCloud)")
59	65	}

	@@ -23,7 +23,7 @@ class ChartContext {
23	23	get {
24	24	guard rect != nil else {
25	25	track("Invalid Context")
26		- fatalError()
	26	+ return .zero
27	27	}
28	28	return rect!.size
29	29	}
	@@ -33,7 +33,7 @@ class ChartContext {
33	33	get {
34	34	guard rect != nil else {
35	35	track("Invalid Context")
36		- fatalError()
	36	+ return .zero
37	37	}
38	38	return rect!.origin
39	39	}
	@@ -51,7 +51,7 @@ class ChartContext {
51	51
52	52	func reset() {
53	53	rect = nil
54		- padding()
	54	+ pad = 0
55	55	}
56	56	func include( point: CGPoint ) {
57	57	if rect == nil {
	@@ -67,10 +67,27 @@ class ChartContext {
67	67	guard rect != nil else {
68	68	track("Invalid Context")
69	69	pad = 0
70		- fatalError()
	70	+ return
71	71	}
72	72	pad = rect!.size.height * Constants.chartUnderscan
73	73	}
	74	+
	75	+ func ensureMinimumSize(width minimumWidth: CGFloat = 0, height minimumHeight: CGFloat = 0) {
	76	+ guard var rect else { return }
	77	+
	78	+ if rect.width < minimumWidth {
	79	+ let delta = (minimumWidth - rect.width) / 2
	80	+ rect = rect.insetBy(dx: -delta, dy: 0)
	81	+ }
	82	+
	83	+ if rect.height < minimumHeight {
	84	+ let delta = (minimumHeight - rect.height) / 2
	85	+ rect = rect.insetBy(dx: 0, dy: -delta)
	86	+ }
	87	+
	88	+ self.rect = rect
	89	+ padding()
	90	+ }
74	91
75	92	func yAxisLabel( for itemNo: Int, of items: Int ) -> Double {
76	93	let labelSpace = Double(rect!.height) / Double(items - 1)
	@@ -86,19 +103,15 @@ class ChartContext {
86	103	}
87	104
88	105	func placeInRect (point: CGPoint) -> CGPoint {
89		- guard rect != nil else {
	106	+ guard let rect else {
90	107	track("Invalid Context")
91		- fatalError()
92		- }
93		- guard rect!.width != 0 else {
94		- fatalError()
95		- }
96		- guard rect!.height != 0 else {
97		- fatalError()
	108	+ return .zero
98	109	}
99	110
100		- let x = (point.x - rect!.origin.x)/rect!.width
101		- let y = (pad + point.y - rect!.origin.y)/rect!.height
	111	+ let width = max(rect.width, 1)
	112	+ let height = max(rect.height, 0.1)
	113	+ let x = (point.x - rect.origin.x)/width
	114	+ let y = (pad + point.y - rect.origin.y)/height
102	115	return CGPoint(x: x, y: 1 - y * Constants.chartOverscan)
103	116	}
104	117	}

	@@ -13,8 +13,13 @@ struct MeterCapabilities {
13	13	let supportsRecordingView: Bool
14	14	let supportsScreenSettings: Bool
15	15	let supportsRecordingThreshold: Bool
	16	+ let reportsCurrentScreenIndex: Bool
	17	+ let showsDataGroupEnergy: Bool
	18	+ let highlightsActiveDataGroup: Bool
16	19	let supportsFahrenheit: Bool
17	20	let supportsChargerDetection: Bool
	21	+ let primaryTemperatureUnitSymbol: String?
	22	+ let dataGroupsTitle: String
18	23	let chargerTypeDescriptions: [UInt16: String]
19	24	let screenDescriptions: [UInt16: String]
20	25	let dataGroupsHint: String?
	@@ -40,8 +45,13 @@ extension MeterCapabilities {
40	45	supportsRecordingView: true,
41	46	supportsScreenSettings: true,
42	47	supportsRecordingThreshold: true,
	48	+ reportsCurrentScreenIndex: true,
	49	+ showsDataGroupEnergy: true,
	50	+ highlightsActiveDataGroup: true,
43	51	supportsFahrenheit: true,
44	52	supportsChargerDetection: true,
	53	+ primaryTemperatureUnitSymbol: "℃",
	54	+ dataGroupsTitle: "Data Groups",
45	55	chargerTypeDescriptions: [
46	56	1: "QC2",
47	57	2: "QC3",
	@@ -60,21 +70,26 @@ extension MeterCapabilities {
60	70	4: "Graphing",
61	71	5: "System Settings"
62	72	],
63		- dataGroupsHint: "Group 0 is temporary. Groups 1-9 persist across power cycles.",
64		- recordingThresholdHint: "Recording starts automatically when current rises above this threshold."
	73	+ dataGroupsHint: "The active group is reported by the meter. Group 0 is temporary. Groups 1-9 persist across power cycles.",
	74	+ recordingThresholdHint: "The meter starts its built-in charge record when current rises above this threshold."
65	75	)
66	76
67	77	static let tc66c = MeterCapabilities(
68	78	availableDataGroupIDs: [0, 1],
69	79	supportsDataGroupCommands: false,
70		- supportsRecordingView: false,
	80	+ supportsRecordingView: true,
71	81	supportsScreenSettings: false,
72	82	supportsRecordingThreshold: false,
	83	+ reportsCurrentScreenIndex: false,
	84	+ showsDataGroupEnergy: true,
	85	+ highlightsActiveDataGroup: false,
73	86	supportsFahrenheit: false,
74	87	supportsChargerDetection: false,
	88	+ primaryTemperatureUnitSymbol: nil,
	89	+ dataGroupsTitle: "Memory Totals",
75	90	chargerTypeDescriptions: [:],
76	91	screenDescriptions: [:],
77		- dataGroupsHint: nil,
	92	+ dataGroupsHint: "The device exposes two read-only memories with charge and energy totals. The active memory is not reported.",
78	93	recordingThresholdHint: nil
79	94	)
80	95	}

	@@ -89,7 +89,7 @@ enum TC66Protocol {
89	89	let offset = 8 + index * 8
90	90	dataGroupRecords[index] = TC66DataGroupTotals(
91	91	ah: Double(UInt32(littleEndian: pac2.value(from: offset))) / 1000,
92		- wh: Double(UInt32(littleEndian: pac2.value(from: offset + 40))) / 1000
	92	+ wh: Double(UInt32(littleEndian: pac2.value(from: offset + 4))) / 1000
93	93	)
94	94	}
95	95
	@@ -104,7 +104,7 @@ enum TC66Protocol {
104	104	voltage: Double(UInt32(littleEndian: pac1.value(from: 48))) / 10000,
105	105	current: Double(UInt32(littleEndian: pac1.value(from: 52))) / 100000,
106	106	power: Double(UInt32(littleEndian: pac1.value(from: 56))) / 10000,
107		- loadResistance: Double(UInt32(littleEndian: pac2.value(from: 4))) / 10,
	107	+ loadResistance: Double(UInt32(littleEndian: pac2.value(from: 4))) / 100,
108	108	dataGroupRecords: dataGroupRecords,
109	109	temperatureCelsius: temperatureMagnitude * temperatureSign,
110	110	usbPlusVoltage: Double(UInt32(littleEndian: pac2.value(from: 32))) / 100,

	@@ -23,6 +23,12 @@ struct ControlView: View {
23	23	Text(meter.currentScreenDescription)
24	24	Button(action: { self.meter.nextScreen() }, label: { Image(systemName: "arrowtriangle.right") })
25	25	}
	26	+ if !meter.reportsCurrentScreenIndex {
	27	+ Text("This protocol supports page navigation, but not current-page reporting.")
	28	+ .font(.footnote)
	29	+ .foregroundColor(.secondary)
	30	+ .multilineTextAlignment(.center)
	31	+ }
26	32	}
27	33	}
28	34	}

	@@ -14,14 +14,20 @@ struct DataGroupRowView: View {
14	14	var id: UInt8
15	15	var width: CGFloat
16	16	var opacity: Double
	17	+ var showsCommands: Bool
	18	+ var showsEnergy: Bool
	19	+ var highlightsSelection: Bool
17	20
18	21	@EnvironmentObject private var usbMeter: Meter
19	22
20	23	var body: some View {
21	24	HStack (spacing: 1) {
22	25	ZStack {
23		- Button(action: { self.usbMeter.selectDataGroup(id: self.id) }, label: { Image(systemName: "\(id).circle") })
24		- .disabled(!usbMeter.supportsDataGroupCommands)
	26	+ if showsCommands {
	27	+ Button(action: { self.usbMeter.selectDataGroup(id: self.id) }, label: { Image(systemName: "\(id).circle") })
	28	+ } else {
	29	+ Text(usbMeter.dataGroupLabel(for: id))
	30	+ }
25	31	Rectangle().opacity( opacity )
26	32	}.frame(width: width)
27	33
	@@ -30,17 +36,23 @@ struct DataGroupRowView: View {
30	36	Rectangle().opacity( opacity )
31	37	}.frame(width: width)
32	38
33		- ZStack {
34		- Text("\(usbMeter.dataGroupRecords[Int(id)]!.wh.format(decimalDigits: 3))")
35		- Rectangle().opacity( opacity )
36		- }.frame(width: width)
	39	+ if showsEnergy {
	40	+ ZStack {
	41	+ Text("\(usbMeter.dataGroupRecords[Int(id)]!.wh.format(decimalDigits: 3))")
	42	+ Rectangle().opacity( opacity )
	43	+ }.frame(width: width)
	44	+ }
37	45
38		- ZStack {
39		- Button(action: { self.usbMeter.clear(group: self.id) }, label: { Image(systemName: "bin.xmark") })
40		- .disabled(!usbMeter.supportsDataGroupCommands)
41		- Rectangle().opacity( opacity )
42		- }.frame(width: width)
	46	+ if showsCommands {
	47	+ ZStack {
	48	+ Button(action: { self.usbMeter.clear(group: self.id) }, label: { Image(systemName: "bin.xmark") })
	49	+ Rectangle().opacity( opacity )
	50	+ }.frame(width: width)
	51	+ }
43	52	}
44		- .background(BorderView(show: usbMeter.selectedDataGroup == id))
	53	+ .overlay(
	54	+ RoundedRectangle(cornerRadius: 10)
	55	+ .stroke(highlightsSelection && usbMeter.selectedDataGroup == id ? Color.accentColor : Color.clear, lineWidth: 3)
	56	+ )
45	57	}
46	58	}

	@@ -16,13 +16,17 @@ struct DataGroupsView: View {
16	16
17	17	var body: some View {
18	18	GeometryReader { box in
	19	+ let columnTitles = [usbMeter.supportsDataGroupCommands ? "Group" : "Memory", "Ah"]
	20	+ + (usbMeter.showsDataGroupEnergy ? ["Wh"] : [])
	21	+ + (usbMeter.supportsDataGroupCommands ? ["Clear"] : [])
	22	+ let columnWidth = (box.size.width - 25) / CGFloat(columnTitles.count)
19	23	let tableReservedHeight: CGFloat = usbMeter.dataGroupsHint == nil ? 100 : 140
20	24	let rowCount = CGFloat(usbMeter.availableDataGroupIDs.count + 1)
21	25	let rowHeight = (box.size.height - tableReservedHeight) / rowCount
22	26
23	27	VStack (spacing: 1) {
24	28	HStack {
25		- Text("Data Groups")
	29	+ Text(usbMeter.dataGroupsTitle)
26	30	.bold()
27	31	Spacer()
28	32	Button(action: {self.visibility.toggle()}) {
	@@ -43,13 +47,20 @@ struct DataGroupsView: View {
43	47	}
44	48
45	49	HStack (spacing: 1) {
46		- ForEach (["Group", "Ah", "Wh", "Clear"], id: \.self ) { text in
47		- self.THView( text: text, width: (box.size.width-25)/4 )
	50	+ ForEach(columnTitles, id: \.self ) { text in
	51	+ self.THView(text: text, width: columnWidth)
48	52	}
49	53	}
50	54	.frame(height: rowHeight)
51	55	ForEach(usbMeter.availableDataGroupIDs, id: \.self) { groupId in
52		- DataGroupRowView(id: groupId, width: ((box.size.width-25) / 4), opacity: groupId.isMultiple(of: 2) ? 0.1 : 0.2)
	56	+ DataGroupRowView(
	57	+ id: groupId,
	58	+ width: columnWidth,
	59	+ opacity: groupId.isMultiple(of: 2) ? 0.1 : 0.2,
	60	+ showsCommands: usbMeter.supportsDataGroupCommands,
	61	+ showsEnergy: usbMeter.showsDataGroupEnergy,
	62	+ highlightsSelection: usbMeter.highlightsActiveDataGroup
	63	+ )
53	64	}
54	65	.frame(height: rowHeight)
55	66	}

	@@ -23,7 +23,7 @@ struct LiveView: View {
23	23	Text("Power:")
24	24	Text("Load")
25	25	Text("Temperature:")
26		- if meter.supportsFahrenheit {
	26	+ if meter.secondaryTemperatureDescription != nil {
27	27	Text("")
28	28	}
29	29	Text("USB Data+:")
	@@ -49,9 +49,9 @@ struct LiveView: View {
49	49	Text("\(meter.measurements.power.context.maxValue.format(decimalDigits: 3))W")
50	50	}
51	51	Text("\(meter.loadResistance.format(decimalDigits: 1))Ω")
52		- Text("\(meter.temperatureCelsius)℃")
53		- if meter.supportsFahrenheit {
54		- Text("\(meter.temperatureFahrenheit)℉")
	52	+ Text(meter.primaryTemperatureDescription)
	53	+ if let secondaryTemperatureDescription = meter.secondaryTemperatureDescription {
	54	+ Text(secondaryTemperatureDescription)
55	55	}
56	56	Text("\(meter.usbPlusVoltage.format(decimalDigits: 2))V")
57	57	Text("\(meter.usbMinusVoltage.format(decimalDigits: 2))V")

	@@ -9,8 +9,13 @@
9	9	import SwiftUI
10	10
11	11	struct MeasurementChartView: View {
	12	+ private let minimumTimeSpan: TimeInterval = 1
	13	+ private let minimumVoltageSpan = 0.1
	14	+ private let minimumCurrentSpan = 0.1
	15	+ private let minimumPowerSpan = 0.1
12	16
13	17	@EnvironmentObject private var measurements: Measurements
	18	+ var timeRange: ClosedRange<Date>? = nil
14	19
15	20	@State var displayVoltage: Bool = false
16	21	@State var displayCurrent: Bool = false
	@@ -19,8 +24,16 @@ struct MeasurementChartView: View {
19	24	let yLabels: Int = 4
20	25
21	26	var body: some View {
	27	+ let powerSeries = series(for: measurements.power, minimumYSpan: minimumPowerSpan)
	28	+ let voltageSeries = series(for: measurements.voltage, minimumYSpan: minimumVoltageSpan)
	29	+ let currentSeries = series(for: measurements.current, minimumYSpan: minimumCurrentSpan)
	30	+ let primarySeries = displayedPrimarySeries(
	31	+ powerSeries: powerSeries,
	32	+ voltageSeries: voltageSeries,
	33	+ currentSeries: currentSeries
	34	+ )
	35	+
22	36	Group {
23		- //if measurements.power.points.count > 0 {
24	37	VStack {
25	38	HStack {
26	39	Button( action: {
	@@ -47,37 +60,34 @@ struct MeasurementChartView: View {
47	60	.asEnableFeatureButton(state: displayPower)
48	61	}
49	62	.padding(.bottom, 5)
50		- if measurements.current.context.isValid {
	63	+ if let primarySeries {
51	64	VStack {
52	65	GeometryReader { geometry in
53	66	HStack {
54	67	Group { // MARK: Left Legend
55	68	if self.displayPower {
56		- self.yAxisLabelsView(geometry: geometry, context: self.measurements.power.context, measurementUnit: "W")
	69	+ self.yAxisLabelsView(geometry: geometry, context: powerSeries.context, measurementUnit: "W")
57	70	.withRoundedRectangleBackground(cornerRadius: 0, foregroundColor: .red, opacity: 0.5)
58	71	} else if self.displayVoltage {
59		- self.yAxisLabelsView(geometry: geometry, context: self.measurements.voltage.context, measurementUnit: "V")
	72	+ self.yAxisLabelsView(geometry: geometry, context: voltageSeries.context, measurementUnit: "V")
60	73	.withRoundedRectangleBackground(cornerRadius: 0, foregroundColor: .green, opacity: 0.5)
61	74	}
62	75	else if self.displayCurrent {
63		- self.yAxisLabelsView(geometry: geometry, context: self.measurements.current.context, measurementUnit: "A")
	76	+ self.yAxisLabelsView(geometry: geometry, context: currentSeries.context, measurementUnit: "A")
64	77	.withRoundedRectangleBackground(cornerRadius: 0, foregroundColor: .blue, opacity: 0.5)
65	78	}
66	79	}
67	80	ZStack { // MARK: Graph
68	81	if self.displayPower {
69		- Chart(strokeColor: .red)
70		- .environmentObject(self.measurements.power)
	82	+ Chart(points: powerSeries.points, context: powerSeries.context, strokeColor: .red)
71	83	.opacity(0.5)
72	84	} else {
73	85	if self.displayVoltage{
74		- Chart(strokeColor: .green)
75		- .environmentObject(self.measurements.voltage)
	86	+ Chart(points: voltageSeries.points, context: voltageSeries.context, strokeColor: .green)
76	87	.opacity(0.5)
77	88	}
78	89	if self.displayCurrent{
79		- Chart(strokeColor: .blue)
80		- .environmentObject(self.measurements.current)
	90	+ Chart(points: currentSeries.points, context: currentSeries.context, strokeColor: .blue)
81	91	.opacity(0.5)
82	92	}
83	93	}
	@@ -88,13 +98,13 @@ struct MeasurementChartView: View {
88	98	}
89	99	.withRoundedRectangleBackground( cornerRadius: 0, foregroundColor: .primary, opacity: 0.06 )
90	100	Group { // MARK: Right Legend
91		- self.yAxisLabelsView(geometry: geometry, context: self.measurements.current.context, measurementUnit: "A")
	101	+ self.yAxisLabelsView(geometry: geometry, context: currentSeries.context, measurementUnit: "A")
92	102	.foregroundColor(self.displayVoltage && self.displayCurrent ? .primary : .clear)
93	103	.withRoundedRectangleBackground(cornerRadius: 0, foregroundColor: .blue, opacity: 0.5)
94	104	}
95	105	}
96	106	}
97		- xAxisLabelsView(context: self.measurements.current.context)
	107	+ xAxisLabelsView(context: primarySeries.context)
98	108	.padding(.horizontal, 10)
99	109
100	110	}
	@@ -111,6 +121,44 @@ struct MeasurementChartView: View {
111	121	.padding()
112	122	}
113	123	}
	124	+
	125	+ private func displayedPrimarySeries(
	126	+ powerSeries: (points: [Measurements.Measurement.Point], context: ChartContext),
	127	+ voltageSeries: (points: [Measurements.Measurement.Point], context: ChartContext),
	128	+ currentSeries: (points: [Measurements.Measurement.Point], context: ChartContext)
	129	+ ) -> (points: [Measurements.Measurement.Point], context: ChartContext)? {
	130	+ if displayPower {
	131	+ return powerSeries.points.isEmpty ? nil : powerSeries
	132	+ }
	133	+ if displayVoltage {
	134	+ return voltageSeries.points.isEmpty ? nil : voltageSeries
	135	+ }
	136	+ if displayCurrent {
	137	+ return currentSeries.points.isEmpty ? nil : currentSeries
	138	+ }
	139	+ return nil
	140	+ }
	141	+
	142	+ private func series(
	143	+ for measurement: Measurements.Measurement,
	144	+ minimumYSpan: Double
	145	+ ) -> (points: [Measurements.Measurement.Point], context: ChartContext) {
	146	+ let points = measurement.points.filter { point in
	147	+ guard let timeRange else { return true }
	148	+ return timeRange.contains(point.timestamp)
	149	+ }
	150	+ let context = ChartContext()
	151	+ for point in points {
	152	+ context.include(point: point.point())
	153	+ }
	154	+ if !points.isEmpty {
	155	+ context.ensureMinimumSize(
	156	+ width: CGFloat(minimumTimeSpan),
	157	+ height: CGFloat(minimumYSpan)
	158	+ )
	159	+ }
	160	+ return (points, context)
	161	+ }
114	162
115	163	// MARK: Cu iteratie nu functioneaza deoarece view-ul din bucla nu este reimprospatat la modificare obiectului observat
116	164	fileprivate func xAxisLabelsView(context: ChartContext) -> some View {
	@@ -189,7 +237,8 @@ struct MeasurementChartView: View {
189	237
190	238	struct Chart : View {
191	239
192		- @EnvironmentObject private var measurement: Measurements.Measurement
	240	+ let points: [Measurements.Measurement.Point]
	241	+ let context: ChartContext
193	242	var areaChart: Bool = false
194	243	var strokeColor: Color = .black
195	244
	@@ -207,14 +256,15 @@ struct Chart : View {
207	256
208	257	fileprivate func path(geometry: GeometryProxy) -> Path {
209	258	return Path { path in
210		- let firstPoint = measurement.context.placeInRect(point: measurement.points.first!.point())
	259	+ guard let first = points.first else { return }
	260	+ let firstPoint = context.placeInRect(point: first.point())
211	261	path.move(to: CGPoint(x: firstPoint.x * geometry.size.width, y: firstPoint.y * geometry.size.height ) )
212		- for item in measurement.points.map({ measurement.context.placeInRect(point: $0.point()) }) {
	262	+ for item in points.map({ context.placeInRect(point: $0.point()) }) {
213	263	path.addLine(to: CGPoint(x: item.x * geometry.size.width, y: item.y * geometry.size.height ) )
214	264	}
215	265	if self.areaChart {
216		- let lastPointX = measurement.context.placeInRect(point: CGPoint(x: measurement.points.last!.point().x, y: measurement.context.origin.y ))
217		- let firstPointX = measurement.context.placeInRect(point: CGPoint(x: measurement.points.first!.point().x, y: measurement.context.origin.y ))
	266	+ let lastPointX = context.placeInRect(point: CGPoint(x: points.last!.point().x, y: context.origin.y ))
	267	+ let firstPointX = context.placeInRect(point: CGPoint(x: points.first!.point().x, y: context.origin.y ))
218	268	path.addLine(to: CGPoint(x: lastPointX.x * geometry.size.width, y: lastPointX.y * geometry.size.height ) )
219	269	path.addLine(to: CGPoint(x: firstPointX.x * geometry.size.width, y: firstPointX.y * geometry.size.height ) )
220	270	// MARK: Nu e nevoie. Fill inchide automat calea

	@@ -40,6 +40,7 @@ struct MeterSettingsView: View {
40	40	Text("Device Info").fontWeight(.semibold)
41	41	DeviceInfoRow(label: "Advertised Model", value: meter.modelString)
42	42	DeviceInfoRow(label: "Displayed Model", value: meter.deviceModelSummary)
	43	+ DeviceInfoRow(label: "Temperature Unit", value: meter.temperatureUnitDescription)
43	44	if meter.modelNumber != 0 {
44	45	DeviceInfoRow(label: "Model Code", value: "\(meter.modelNumber)")
45	46	}
	@@ -56,6 +57,22 @@ struct MeterSettingsView: View {
56	57	.padding()
57	58	.background(RoundedRectangle(cornerRadius: 15).foregroundColor(.secondary).opacity(0.1))
58	59	}
	60	+ if meter.operationalState == .dataIsAvailable && meter.supportsManualTemperatureUnitSelection {
	61	+ VStack(alignment: .leading, spacing: 8) {
	62	+ Text("Temperature Unit").fontWeight(.semibold)
	63	+ Text("TC66 reports temperature using the unit selected on the device. Keep this setting matched to the meter.")
	64	+ .font(.footnote)
	65	+ .foregroundColor(.secondary)
	66	+ Picker("", selection: $meter.tc66TemperatureUnitPreference) {
	67	+ ForEach(TemperatureUnitPreference.allCases) { unit in
	68	+ Text(unit.title).tag(unit)
	69	+ }
	70	+ }
	71	+ .pickerStyle(SegmentedPickerStyle())
	72	+ }
	73	+ .padding()
	74	+ .background(RoundedRectangle(cornerRadius: 15).foregroundColor(.secondary).opacity(0.1))
	75	+ }
59	76	if meter.operationalState == .dataIsAvailable && meter.supportsUMSettings {
60	77	// MARK: Screen Timeout
61	78	// Ar trebui separat enabled/disabled de valorile in minute eventual stocata valoarea in iCloud la dezactivare pentru restaurare

	@@ -45,7 +45,7 @@ struct MeterView: View {
45	45	if ( meter.operationalState == .dataIsAvailable) {
46	46	Text("Model: \(meter.deviceModelSummary)")
47	47	HStack(spacing: 24) {
48		- meterSheetButton(icon: "map", title: "Data Groups") {
	48	+ meterSheetButton(icon: "map", title: meter.dataGroupsTitle) {
49	49	dataGroupsViewVisibility.toggle()
50	50	}
51	51	.sheet(isPresented: self.$dataGroupsViewVisibility) {
	@@ -54,7 +54,7 @@ struct MeterView: View {
54	54	}
55	55
56	56	if meter.supportsRecordingView {
57		- meterSheetButton(icon: "record.circle", title: "Recording") {
	57	+ meterSheetButton(icon: "record.circle", title: "Charge Record") {
58	58	recordingViewVisibility.toggle()
59	59	}
60	60	.sheet(isPresented: self.$recordingViewVisibility) {