ios/PinecilTime.xcodeproj/project.xcworkspace/xcuserdata/kierank.xcuserdatad/UserInterfaceState.xcuserstate

This is a binary file and will not be displayed.

+91 -57

ios/PinecilTime/BLEManager.swift

··· 29 29 private var discoveredCharacteristics: [CBUUID: CBCharacteristic] = [:] 30 30 private var pollTimer: Timer? 31 31 private var scanTimer: Timer? 32 32 + private let bleQueue = DispatchQueue(label: "com.pineciltime.ble", qos: .userInitiated) 32 33 33 34 // MARK: - Init 34 35 35 36 override init() { 36 37 super.init() 37 37 - centralManager = CBCentralManager(delegate: self, queue: .main) 38 38 + centralManager = CBCentralManager(delegate: self, queue: bleQueue) 38 39 } 39 40 40 41 // MARK: - Connection State ··· 48 49 49 50 var isConnected: Bool { 50 51 self == .connected 52 52 + } 53 53 + 54 54 + var isConnecting: Bool { 55 55 + self == .connecting 51 56 } 52 57 } 53 58 ··· 112 117 } 113 118 114 119 let value = UInt16(temp).data 115 115 - peripheral.writeValue(value, for: characteristic, type: .withResponse) 120 120 + peripheral.writeValue(value, for: characteristic, type: .withoutResponse) 121 121 + } 122 122 + 123 123 + func setSlowPolling() { 124 124 + pollTimer?.invalidate() 125 125 + pollTimer = Timer.scheduledTimer(withTimeInterval: 0.2, repeats: true) { [weak self] _ in 126 126 + self?.readBulkData() 127 127 + } 128 128 + } 129 129 + 130 130 + func setFastPolling() { 131 131 + guard connectionState == .connected else { return } 132 132 + pollTimer?.invalidate() 133 133 + pollTimer = Timer.scheduledTimer(withTimeInterval: 0.1, repeats: true) { [weak self] _ in 134 134 + self?.readBulkData() 135 135 + } 116 136 } 117 137 118 138 // MARK: - Polling ··· 157 177 private func handleCharacteristicValue(_ characteristic: CBCharacteristic) { 158 178 guard let value = characteristic.value else { return } 159 179 160 160 - switch characteristic.uuid { 161 161 - case IronOSUUIDs.bulkLiveData: 162 162 - liveData.updateFromBulkData(value) 163 163 - recordTemperature() 180 180 + DispatchQueue.main.async { [self] in 181 181 + switch characteristic.uuid { 182 182 + case IronOSUUIDs.bulkLiveData: 183 183 + liveData.updateFromBulkData(value) 184 184 + recordTemperature() 164 185 165 165 - case IronOSUUIDs.liveTemp: 166 166 - liveData.liveTemp = value.toUInt32() ?? 0 167 167 - case IronOSUUIDs.setpointRead: 168 168 - liveData.setpoint = value.toUInt32() ?? 0 169 169 - case IronOSUUIDs.dcInput: 170 170 - liveData.dcInput = value.toUInt32() ?? 0 171 171 - case IronOSUUIDs.handleTemp: 172 172 - liveData.handleTemp = value.toUInt32() ?? 0 173 173 - case IronOSUUIDs.powerLevel: 174 174 - liveData.powerLevel = value.toUInt32() ?? 0 175 175 - case IronOSUUIDs.powerSource: 176 176 - liveData.powerSource = value.toUInt32() ?? 0 177 177 - case IronOSUUIDs.operatingMode: 178 178 - liveData.operatingMode = value.toUInt32() ?? 0 179 179 - case IronOSUUIDs.estimatedWatts: 180 180 - liveData.estimatedWatts = value.toUInt32() ?? 0 181 181 - case IronOSUUIDs.maxTemp: 182 182 - liveData.maxTemp = value.toUInt32() ?? 450 186 186 + case IronOSUUIDs.liveTemp: 187 187 + liveData.liveTemp = value.toUInt32() ?? 0 188 188 + case IronOSUUIDs.setpointRead: 189 189 + liveData.setpoint = value.toUInt32() ?? 0 190 190 + case IronOSUUIDs.dcInput: 191 191 + liveData.dcInput = value.toUInt32() ?? 0 192 192 + case IronOSUUIDs.handleTemp: 193 193 + liveData.handleTemp = value.toUInt32() ?? 0 194 194 + case IronOSUUIDs.powerLevel: 195 195 + liveData.powerLevel = value.toUInt32() ?? 0 196 196 + case IronOSUUIDs.powerSource: 197 197 + liveData.powerSource = value.toUInt32() ?? 0 198 198 + case IronOSUUIDs.operatingMode: 199 199 + liveData.operatingMode = value.toUInt32() ?? 0 200 200 + case IronOSUUIDs.estimatedWatts: 201 201 + liveData.estimatedWatts = value.toUInt32() ?? 0 202 202 + case IronOSUUIDs.maxTemp: 203 203 + liveData.maxTemp = value.toUInt32() ?? 450 183 204 184 184 - case IronOSUUIDs.firmwareVersion: 185 185 - firmwareVersion = value.toString() ?? "" 205 205 + case IronOSUUIDs.firmwareVersion: 206 206 + firmwareVersion = value.toString() ?? "" 186 207 187 187 - default: 188 188 - break 208 208 + default: 209 209 + break 210 210 + } 189 211 } 190 212 } 191 213 } ··· 195 217 extension BLEManager: CBCentralManagerDelegate { 196 218 197 219 func centralManagerDidUpdateState(_ central: CBCentralManager) { 198 198 - switch central.state { 199 199 - case .poweredOn: 200 200 - startScanning() 201 201 - case .poweredOff: 202 202 - connectionState = .error("Bluetooth is off") 203 203 - case .unauthorized: 204 204 - connectionState = .error("Bluetooth access denied") 205 205 - case .unsupported: 206 206 - connectionState = .error("Bluetooth not supported") 207 207 - default: 208 208 - break 220 220 + DispatchQueue.main.async { [self] in 221 221 + switch central.state { 222 222 + case .poweredOn: 223 223 + startScanning() 224 224 + case .poweredOff: 225 225 + connectionState = .error("Bluetooth is off") 226 226 + case .unauthorized: 227 227 + connectionState = .error("Bluetooth access denied") 228 228 + case .unsupported: 229 229 + connectionState = .error("Bluetooth not supported") 230 230 + default: 231 231 + break 232 232 + } 209 233 } 210 234 } 211 235 ··· 213 237 didDiscover peripheral: CBPeripheral, 214 238 advertisementData: [String: Any], 215 239 rssi RSSI: NSNumber) { 216 216 - // Auto-connect to first discovered Pinecil 217 217 - if connectedPeripheral == nil { 218 218 - if peripheral.name?.hasPrefix("PrattlePin-") == true || 219 219 - advertisementData[CBAdvertisementDataServiceUUIDsKey] != nil { 220 220 - connect(to: peripheral) 221 221 - return 240 240 + DispatchQueue.main.async { [self] in 241 241 + // Auto-connect to first discovered Pinecil 242 242 + if connectedPeripheral == nil { 243 243 + if peripheral.name?.hasPrefix("PrattlePin-") == true || 244 244 + advertisementData[CBAdvertisementDataServiceUUIDsKey] != nil { 245 245 + connect(to: peripheral) 246 246 + return 247 247 + } 222 248 } 223 223 - } 224 249 225 225 - if !discoveredDevices.contains(where: { $0.identifier == peripheral.identifier }) { 226 226 - discoveredDevices.append(peripheral) 250 250 + if !discoveredDevices.contains(where: { $0.identifier == peripheral.identifier }) { 251 251 + discoveredDevices.append(peripheral) 252 252 + } 227 253 } 228 254 } 229 255 230 256 func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) { 231 231 - connectionState = .connected 232 232 - deviceName = peripheral.name ?? "Pinecil" 257 257 + DispatchQueue.main.async { [self] in 258 258 + connectionState = .connected 259 259 + deviceName = peripheral.name ?? "Pinecil" 260 260 + } 233 261 peripheral.discoverServices(nil) 234 262 } 235 263 236 264 func centralManager(_ central: CBCentralManager, 237 265 didFailToConnect peripheral: CBPeripheral, 238 266 error: Error?) { 239 239 - connectionState = .error(error?.localizedDescription ?? "Connection failed") 240 240 - connectedPeripheral = nil 267 267 + DispatchQueue.main.async { [self] in 268 268 + connectionState = .error(error?.localizedDescription ?? "Connection failed") 269 269 + connectedPeripheral = nil 270 270 + } 241 271 } 242 272 243 273 func centralManager(_ central: CBCentralManager, 244 274 didDisconnectPeripheral peripheral: CBPeripheral, 245 275 error: Error?) { 246 246 - stopPolling() 247 247 - connectionState = .disconnected 248 248 - connectedPeripheral = nil 249 249 - discoveredCharacteristics.removeAll() 276 276 + DispatchQueue.main.async { [self] in 277 277 + stopPolling() 278 278 + connectionState = .disconnected 279 279 + connectedPeripheral = nil 280 280 + discoveredCharacteristics.removeAll() 281 281 + } 250 282 } 251 283 } 252 284 ··· 284 316 285 317 // Start polling once we have the live data service 286 318 if service.uuid == IronOSUUIDs.liveDataService || service.uuid == IronOSUUIDs.bulkDataService { 287 287 - startPolling() 319 319 + DispatchQueue.main.async { [self] in 320 320 + startPolling() 321 321 + } 288 322 } 289 323 } 290 324

+8 -5

ios/PinecilTime/ContentView.swift

··· 22 22 if !bleManager.temperatureHistory.isEmpty { 23 23 TemperatureGraph( 24 24 history: bleManager.temperatureHistory, 25 25 - maxTemp: bleManager.liveData.maxTemp 25 25 + currentSetpoint: Int(targetTemp) 26 26 ) 27 27 .padding(.horizontal, 20) 28 28 .padding(.vertical, 120) ··· 150 150 step: 5, 151 151 onEditingChanged: { editing in 152 152 isEditingSlider = editing 153 153 - if !editing { 153 153 + if editing { 154 154 + bleManager.setSlowPolling() 155 155 + } else { 154 156 bleManager.setTemperature(UInt32(targetTemp)) 155 157 lastSentTemp = targetTemp 158 158 + bleManager.setFastPolling() 156 159 } 157 160 } 158 161 ) ··· 160 163 .onChange(of: targetTemp) { _, newValue in 161 164 guard isEditingSlider else { return } 162 165 let now = Date() 163 163 - if now.timeIntervalSince(lastSendTime) > 0.15 && abs(newValue - lastSentTemp) >= 5 { 166 166 + if now.timeIntervalSince(lastSendTime) > 0.2 && abs(newValue - lastSentTemp) >= 5 { 164 167 bleManager.setTemperature(UInt32(newValue)) 165 168 lastSentTemp = newValue 166 169 lastSendTime = now ··· 220 223 .ignoresSafeArea() 221 224 222 225 VStack(spacing: 20) { 223 223 - if bleManager.isScanning || bleManager.connectionState == BLEManager.ConnectionState.connecting { 226 226 + if bleManager.isScanning || bleManager.connectionState.isConnecting { 224 227 ProgressView() 225 228 .scaleEffect(1.2) 226 229 .padding(.bottom, 4) 227 230 228 228 - Text(bleManager.connectionState == BLEManager.ConnectionState.connecting ? "Connecting..." : "Scanning...") 231 231 + Text(bleManager.connectionState.isConnecting ? "Connecting..." : "Scanning...") 229 232 .font(.headline) 230 233 231 234 Text("Looking for your Pinecil")

+91 -35

ios/PinecilTime/TemperatureGraph.swift

··· 6 6 import Charts 7 7 import SwiftUI 8 8 9 9 + private struct ChartDataPoint: Identifiable { 10 10 + let id: String 11 11 + let timestamp: Date 12 12 + let value: Int 13 13 + let series: String 14 14 + } 15 15 + 9 16 struct TemperatureGraph: View { 10 17 let history: [TemperaturePoint] 11 11 - let maxTemp: UInt32 18 18 + let currentSetpoint: Int 12 19 13 13 - var body: some View { 14 14 - Chart { 15 15 - setpointLine 16 16 - actualTempLine 20 20 + private var chartData: [ChartDataPoint] { 21 21 + var data: [ChartDataPoint] = [] 22 22 + for point in history { 23 23 + data.append(ChartDataPoint( 24 24 + id: "\(point.id)-setpoint", 25 25 + timestamp: point.timestamp, 26 26 + value: Int(point.setpoint), 27 27 + series: "Setpoint" 28 28 + )) 29 29 + data.append(ChartDataPoint( 30 30 + id: "\(point.id)-temp", 31 31 + timestamp: point.timestamp, 32 32 + value: Int(point.actualTemp), 33 33 + series: "Temp" 34 34 + )) 17 35 } 18 18 - .chartXAxis(.hidden) 19 19 - .chartYAxis(.hidden) 20 20 - .chartLegend(.hidden) 21 21 - .chartYScale(domain: 0...500) 22 22 - } 23 23 - 24 24 - @ChartContentBuilder 25 25 - private var setpointLine: some ChartContent { 26 26 - ForEach(history) { point in 27 27 - LineMark( 28 28 - x: .value("T", point.timestamp), 29 29 - y: .value("S", Int(point.setpoint)), 30 30 - series: .value("L", "S") 31 31 - ) 32 32 - .foregroundStyle(Color.gray.opacity(0.4)) 33 33 - .lineStyle(StrokeStyle(lineWidth: 1.5)) 34 34 - } 35 35 - } 36 36 - 37 37 - @ChartContentBuilder 38 38 - private var actualTempLine: some ChartContent { 39 39 - ForEach(history) { point in 40 40 - LineMark( 41 41 - x: .value("T", point.timestamp), 42 42 - y: .value("A", Int(point.actualTemp)), 43 43 - series: .value("L", "A") 44 44 - ) 45 45 - .foregroundStyle(lineColor) 46 46 - .lineStyle(StrokeStyle(lineWidth: 2.5, lineCap: .round)) 47 47 - } 36 36 + return data 48 37 } 49 38 50 39 private var lineColor: Color { ··· 53 42 if temp < 150 { return .blue } 54 43 if temp < 300 { return .orange } 55 44 return .red 45 45 + } 46 46 + 47 47 + private func chartDataWithEdge(now: Date, windowSeconds: TimeInterval) -> [ChartDataPoint] { 48 48 + var data: [ChartDataPoint] = [] 49 49 + 50 50 + // Add point slightly before first data point (only if data has scrolled to left edge) 51 51 + if let first = history.first { 52 52 + let windowStart = now.addingTimeInterval(-windowSeconds) 53 53 + if first.timestamp <= windowStart { 54 54 + let leftEdge = windowStart.addingTimeInterval(-1) 55 55 + data.append(ChartDataPoint( 56 56 + id: "left-setpoint", 57 57 + timestamp: leftEdge, 58 58 + value: Int(first.setpoint), 59 59 + series: "Setpoint" 60 60 + )) 61 61 + data.append(ChartDataPoint( 62 62 + id: "left-temp", 63 63 + timestamp: leftEdge, 64 64 + value: Int(first.actualTemp), 65 65 + series: "Temp" 66 66 + )) 67 67 + } 68 68 + } 69 69 + 70 70 + data.append(contentsOf: chartData) 71 71 + 72 72 + // Add point at right edge 73 73 + if let last = history.last { 74 74 + let rightEdge = now.addingTimeInterval(1) 75 75 + data.append(ChartDataPoint( 76 76 + id: "edge-setpoint", 77 77 + timestamp: rightEdge, 78 78 + value: currentSetpoint, 79 79 + series: "Setpoint" 80 80 + )) 81 81 + data.append(ChartDataPoint( 82 82 + id: "edge-temp", 83 83 + timestamp: rightEdge, 84 84 + value: Int(last.actualTemp), 85 85 + series: "Temp" 86 86 + )) 87 87 + } 88 88 + return data 89 89 + } 90 90 + 91 91 + var body: some View { 92 92 + TimelineView(.animation) { timeline in 93 93 + let now = timeline.date 94 94 + let windowSeconds: TimeInterval = 6 95 95 + let xDomain = now.addingTimeInterval(-windowSeconds)...now 96 96 + 97 97 + Chart(chartDataWithEdge(now: now, windowSeconds: windowSeconds)) { point in 98 98 + LineMark( 99 99 + x: .value("Time", point.timestamp), 100 100 + y: .value("Value", point.value), 101 101 + series: .value("Series", point.series) 102 102 + ) 103 103 + .foregroundStyle(point.series == "Setpoint" ? Color.gray.opacity(0.4) : lineColor) 104 104 + .lineStyle(StrokeStyle(lineWidth: point.series == "Setpoint" ? 1.5 : 2.5, lineCap: .round)) 105 105 + } 106 106 + .chartXAxis(.hidden) 107 107 + .chartYAxis(.hidden) 108 108 + .chartLegend(.hidden) 109 109 + .chartYScale(domain: 0...500) 110 110 + .chartXScale(domain: xDomain) 111 111 + } 56 112 } 57 113 }