263 lines
9.4 KiB
Swift
263 lines
9.4 KiB
Swift
import SwiftUI
|
|
|
|
struct CalibrateView: View {
|
|
@Bindable var state: AppState
|
|
|
|
private var volumeGal: Double { state.calVolumeGal }
|
|
private var naclPpm: Double { Double(state.calNaclPpm) ?? 0 }
|
|
private var clPpm: Double { Double(state.calClPpm) ?? 0 }
|
|
private var bleachPct: Double { Double(state.calBleachPct) ?? 0 }
|
|
private var tempC: Double { Double(state.calTempC) ?? 25 }
|
|
|
|
var body: some View {
|
|
Form {
|
|
inputSection
|
|
resultsSection
|
|
cellConstantSection
|
|
chlorineCalSection
|
|
phCalibrationSection
|
|
}
|
|
.navigationTitle("Calibrate")
|
|
}
|
|
|
|
// MARK: - Inputs
|
|
|
|
private var inputSection: some View {
|
|
Section("Solution Parameters") {
|
|
Stepper("Volume: \(Int(state.calVolumeGal)) gal",
|
|
value: $state.calVolumeGal, in: 5...30, step: 5)
|
|
|
|
HStack {
|
|
Text("NaCl ppm")
|
|
Spacer()
|
|
TextField("ppm", text: $state.calNaclPpm)
|
|
.multilineTextAlignment(.trailing)
|
|
.frame(width: 80)
|
|
#if os(iOS)
|
|
.keyboardType(.decimalPad)
|
|
#endif
|
|
}
|
|
|
|
HStack {
|
|
Text("Free Cl ppm")
|
|
Spacer()
|
|
TextField("ppm", text: $state.calClPpm)
|
|
.multilineTextAlignment(.trailing)
|
|
.frame(width: 80)
|
|
#if os(iOS)
|
|
.keyboardType(.decimalPad)
|
|
#endif
|
|
}
|
|
|
|
HStack {
|
|
Text("Bleach %")
|
|
Spacer()
|
|
TextField("%", text: $state.calBleachPct)
|
|
.multilineTextAlignment(.trailing)
|
|
.frame(width: 80)
|
|
#if os(iOS)
|
|
.keyboardType(.decimalPad)
|
|
#endif
|
|
}
|
|
|
|
HStack {
|
|
Text("Temperature")
|
|
Spacer()
|
|
TextField("\u{00B0}C", text: $state.calTempC)
|
|
.multilineTextAlignment(.trailing)
|
|
.frame(width: 80)
|
|
#if os(iOS)
|
|
.keyboardType(.decimalPad)
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - Computed results
|
|
|
|
private var resultsSection: some View {
|
|
Section("Preparation") {
|
|
let salt = saltGrams(volumeGal: volumeGal, ppm: naclPpm)
|
|
let tbsp = salt / 17.0
|
|
Text(String(format: "Salt: %.1f g (%.1f tbsp)", salt, tbsp))
|
|
|
|
let bleach = bleachMl(volumeGal: volumeGal, clPpm: clPpm, bleachPct: bleachPct)
|
|
let tsp = bleach / 5.0
|
|
Text(String(format: "Bleach: %.1f mL (%.1f tsp)", bleach, tsp))
|
|
|
|
let kappa = theoreticalConductivity(naclPpm: naclPpm, tempC: tempC)
|
|
Text(String(format: "Theoretical \u{03BA}: %.2f mS/cm at %.0f\u{00B0}C", kappa, tempC))
|
|
}
|
|
}
|
|
|
|
// MARK: - Cell constant from EIS
|
|
|
|
private var cellConstantSection: some View {
|
|
Section("Cell Constant") {
|
|
Button("Calculate K from Last Sweep") {
|
|
guard let rs = extractRs(points: state.eisPoints) else {
|
|
state.status = "No valid EIS data for Rs"
|
|
return
|
|
}
|
|
let kappa = theoreticalConductivity(naclPpm: naclPpm, tempC: tempC)
|
|
let k = cellConstant(kappaMsCm: kappa, rsOhm: Double(rs))
|
|
state.calRs = Double(rs)
|
|
state.calCellConstant = k
|
|
state.send(buildSysexSetCellK(Float(k)))
|
|
state.status = String(format: "K = %.4f cm\u{207B}\u{00B9} (Rs = %.1f \u{2126})", k, rs)
|
|
}
|
|
.disabled(state.eisPoints.isEmpty)
|
|
|
|
if let rs = state.calRs {
|
|
Text(String(format: "Rs: %.1f \u{2126}", rs))
|
|
}
|
|
if let k = state.calCellConstant {
|
|
Text(String(format: "Cell constant K: %.4f cm\u{207B}\u{00B9}", k))
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - Chlorine calibration
|
|
|
|
private var chlorineCalSection: some View {
|
|
Section("Chlorine Calibration") {
|
|
if let f = state.clFactor {
|
|
Text(String(format: "Cl factor: %.6f ppm/\u{00B5}A", f))
|
|
}
|
|
if let r = state.clResult {
|
|
Text(String(format: "Last free Cl peak: %.3f \u{00B5}A", r.iFreeUa))
|
|
}
|
|
|
|
HStack {
|
|
Text("Known Cl ppm")
|
|
Spacer()
|
|
TextField("ppm", text: $state.clCalKnownPpm)
|
|
.multilineTextAlignment(.trailing)
|
|
.frame(width: 80)
|
|
#if os(iOS)
|
|
.keyboardType(.decimalPad)
|
|
#endif
|
|
}
|
|
|
|
Button("Set Cl Factor") {
|
|
guard let r = state.clResult else {
|
|
state.status = "No chlorine measurement"
|
|
return
|
|
}
|
|
let knownPpm = Double(state.clCalKnownPpm) ?? 0
|
|
let peak = abs(Double(r.iFreeUa))
|
|
guard peak > 0 else {
|
|
state.status = "Peak current is zero"
|
|
return
|
|
}
|
|
let factor = knownPpm / peak
|
|
state.clFactor = factor
|
|
state.send(buildSysexSetClFactor(Float(factor)))
|
|
state.status = String(format: "Cl factor: %.6f ppm/\u{00B5}A", factor)
|
|
}
|
|
.disabled(state.clResult == nil)
|
|
}
|
|
}
|
|
|
|
// MARK: - pH calibration
|
|
|
|
private var phCalibrationSection: some View {
|
|
Section("pH Calibration (Q/HQ peak-shift)") {
|
|
if let s = state.phSlope, let o = state.phOffset {
|
|
Text(String(format: "slope: %.4f mV/pH offset: %.4f mV", s, o))
|
|
if let peak = detectQhqPeak(state.lsvPoints) {
|
|
if abs(s) > 1e-6 {
|
|
let ph = (Double(peak) - o) / s
|
|
Text(String(format: "Computed pH: %.2f (peak at %.1f mV)", ph, peak))
|
|
}
|
|
}
|
|
}
|
|
|
|
HStack {
|
|
Text("Known pH")
|
|
Spacer()
|
|
TextField("7.00", text: $state.phCalKnown)
|
|
.multilineTextAlignment(.trailing)
|
|
.frame(width: 80)
|
|
#if os(iOS)
|
|
.keyboardType(.decimalPad)
|
|
#endif
|
|
}
|
|
|
|
Button("Add Calibration Point") {
|
|
guard let peak = detectQhqPeak(state.lsvPoints) else {
|
|
state.status = "No Q/HQ peak found in LSV data"
|
|
return
|
|
}
|
|
guard let ph = Double(state.phCalKnown) else { return }
|
|
state.phCalPoints.append((ph: ph, mV: Double(peak)))
|
|
state.status = String(format: "pH cal point: pH=%.2f peak=%.1f mV (%d pts)",
|
|
ph, peak, state.phCalPoints.count)
|
|
}
|
|
.disabled(state.lsvPoints.isEmpty)
|
|
|
|
ForEach(Array(state.phCalPoints.enumerated()), id: \.offset) { i, pt in
|
|
Text(String(format: "%d. pH=%.2f peak=%.1f mV", i + 1, pt.ph, pt.mV))
|
|
.font(.caption)
|
|
}
|
|
|
|
Button("Clear Points") {
|
|
state.phCalPoints.removeAll()
|
|
state.status = "pH cal points cleared"
|
|
}
|
|
.disabled(state.phCalPoints.isEmpty)
|
|
|
|
Button("Compute & Set pH Cal") {
|
|
let pts = state.phCalPoints
|
|
guard pts.count >= 2 else {
|
|
state.status = "Need at least 2 calibration points"
|
|
return
|
|
}
|
|
let n = Double(pts.count)
|
|
let meanPh = pts.map(\.ph).reduce(0, +) / n
|
|
let meanV = pts.map(\.mV).reduce(0, +) / n
|
|
let num = pts.map { ($0.ph - meanPh) * ($0.mV - meanV) }.reduce(0, +)
|
|
let den = pts.map { ($0.ph - meanPh) * ($0.ph - meanPh) }.reduce(0, +)
|
|
guard abs(den) > 1e-12 else {
|
|
state.status = "Degenerate calibration data"
|
|
return
|
|
}
|
|
let slope = num / den
|
|
let offset = meanV - slope * meanPh
|
|
state.phSlope = slope
|
|
state.phOffset = offset
|
|
state.send(buildSysexSetPhCal(Float(slope), Float(offset)))
|
|
state.status = String(format: "pH cal set: slope=%.4f offset=%.4f", slope, offset)
|
|
}
|
|
.disabled(state.phCalPoints.count < 2)
|
|
}
|
|
}
|
|
|
|
// MARK: - Calculations
|
|
|
|
private func saltGrams(volumeGal: Double, ppm: Double) -> Double {
|
|
let liters = volumeGal * 3.78541
|
|
return ppm * liters / 1000.0
|
|
}
|
|
|
|
private func bleachMl(volumeGal: Double, clPpm: Double, bleachPct: Double) -> Double {
|
|
let liters = volumeGal * 3.78541
|
|
let clNeededMg = clPpm * liters
|
|
let bleachMgPerMl = bleachPct * 10.0
|
|
return clNeededMg / bleachMgPerMl
|
|
}
|
|
|
|
private func theoreticalConductivity(naclPpm: Double, tempC: Double) -> Double {
|
|
let kappa25 = naclPpm * 2.0 / 1000.0
|
|
return kappa25 * (1.0 + 0.0212 * (tempC - 25.0))
|
|
}
|
|
|
|
private func extractRs(points: [EisPoint]) -> Float? {
|
|
points.map(\.zReal).filter { $0.isFinite && $0 > 0 }.min()
|
|
}
|
|
|
|
private func cellConstant(kappaMsCm: Double, rsOhm: Double) -> Double {
|
|
(kappaMsCm / 1000.0) * rsOhm
|
|
}
|
|
}
|