another rev of the bolus ui, showing eventualbg, iob, pending insulin…

…, cob, and more succinct warnings

Loop/Managers/DeviceDataManager.swift

@@ -1003,8 +1003,8 @@ final class DeviceDataManager: CarbStoreDelegate, CarbStoreSyncDelegate, DoseSto
             insulinSensitivitySchedule: insulinSensitivitySchedule
         )
 
-        carbStore = CarbStore(
-            defaultAbsorptionTimes: (fast: TimeInterval(hours: 2), medium: TimeInterval(hours: 3), slow: TimeInterval(hours: 4)),
+         carbStore = CarbStore(
+            defaultAbsorptionTimes: (fast: TimeInterval(hours: 1), medium: TimeInterval(hours: 2), slow: TimeInterval(hours: 4)),
             carbRatioSchedule: carbRatioSchedule,
             insulinSensitivitySchedule: insulinSensitivitySchedule
         )

Loop/Managers/DoseMath.swift

@@ -135,12 +135,11 @@ struct DoseMath {
 
      - parameter glucose:            The ascending timeline of predicted glucose values
      - parameter date:               The date at which the bolus would apply. Defaults to the current date.
-     - parameter lastTempBasal:      The last-set temporary basal
      - parameter maxBolus:           The maximum bolus, used to constrain the output
      - parameter glucoseTargetRange: The schedule of target glucose ranges
      - parameter insulinSensitivity: The schedule of insulin sensitivities, in Units of insulin per glucose-unit
      - parameter basalRateSchedule:  The schedule of basal rates
-     - parameter pendingBolusAmount: The amount of insulin in any issued, but not confirmed, boluses
+     - parameter pendingInsulin:     The amount of insulin in any issued, but not confirmed, boluses and the amount remaining from current tempBasal
      - parameter minimumBGGuard:     If minBG is less than or equal to this value, no recommendation will be made
 
      - returns: The recommended bolus
@@ -152,7 +151,7 @@ struct DoseMath {
         glucoseTargetRange: GlucoseRangeSchedule,
         insulinSensitivity: InsulinSensitivitySchedule,
         basalRateSchedule: BasalRateSchedule,
-        pendingBolusAmount: Double,
+        pendingInsulin: Double,
         minimumBGGuard: GlucoseThreshold
     ) -> BolusRecommendation {
         guard glucose.count > 1 else {
@@ -165,65 +164,43 @@ struct DoseMath {
         let eventualGlucoseTargets = glucoseTargetRange.value(at: eventualGlucose.startDate)
 
         guard minGlucose.quantity >= minimumBGGuard.quantity else {
-            let notice = NSLocalizedString("Glucose is predicted to go below your minimum BG Guard setting. No bolus is recommended.", comment: "Bolus recommendation message when BG is below minimum BG guard.")
-            return BolusRecommendation(amount: 0, notice: notice)
+            let notice = NSLocalizedString("Predicted glucose is below your minimum BG Guard setting.", comment: "Notice message when recommending bolus when BG is below minimum BG guard.")
+            return BolusRecommendation(amount: 0, pendingInsulin: pendingInsulin, notice: notice)
         }
 
         let targetGlucose = eventualGlucoseTargets.maxValue
         let currentSensitivity = insulinSensitivity.quantity(at: date).doubleValue(for: glucoseTargetRange.unit)
 
         let doseUnits = (eventualGlucose.quantity.doubleValue(for: glucoseTargetRange.unit) - targetGlucose) / currentSensitivity
-
-        let pendingTempBasalInsulin: Double
-
-        if let lastTempBasal = lastTempBasal, lastTempBasal.unit == .unitsPerHour && lastTempBasal.endDate > date {
-            let normalBasalRate = basalRateSchedule.value(at: date)
-            let remainingTime = lastTempBasal.endDate.timeIntervalSince(date)
-            let remainingUnits = (lastTempBasal.value - normalBasalRate) * remainingTime / TimeInterval(hours: 1)
 
-            pendingTempBasalInsulin = max(0, remainingUnits)
-        } else {
-            pendingTempBasalInsulin = 0
-        }
-
-        // All outstanding potential insulin delivery
-        let pendingInsulin = pendingTempBasalInsulin + pendingBolusAmount
-
         // Round to pump accuracy increments
         let roundedAmount = round(max(0, (doseUnits - pendingInsulin)) * 40) / 40
 
         // Cap at max bolus amount
         let cappedAmount = min(maxBolus, max(0, roundedAmount))
 
-        let numberFormatter = NumberFormatter.glucoseFormatter(for: glucoseTargetRange.unit)
-        let eventualBGValueStr = numberFormatter.string(from: NSNumber(value: eventualGlucose.quantity.doubleValue(for: glucoseTargetRange.unit)))!
-        let eventualBG = "\(eventualBGValueStr) \(glucoseTargetRange.unit.glucoseUnitDisplayString)"
-
-
         let notice: String?
         if cappedAmount > 0 && minGlucose.quantity.doubleValue(for: glucoseTargetRange.unit) < eventualGlucoseTargets.minValue {
             if minGlucose.startDate == glucose[0].startDate {
-                notice = String(format: NSLocalizedString("Current glucose is below target range. Recommendation is based on eventual predicted BG of %3$@", comment: "Message when offering bolus prediction even though bg is below range. (1: eventual BG)"), eventualBG)
+                notice = NSLocalizedString("Glucose is below target range.", comment: "Message when offering bolus prediction even though bg is below range.")
             } else {
                 let timeFormatter = DateFormatter()
                 timeFormatter.dateStyle = .none
                 timeFormatter.timeStyle = .short
                 let time = timeFormatter.string(from: minGlucose.startDate)
 
+                let numberFormatter = NumberFormatter.glucoseFormatter(for: glucoseTargetRange.unit)
+
                 let minBGValue = numberFormatter.string(from: NSNumber(value: minGlucose.quantity.doubleValue(for: glucoseTargetRange.unit)))!
 
                 let minBGStr = "\(minBGValue) \(glucoseTargetRange.unit.glucoseUnitDisplayString)"
 
-                notice = String(format: NSLocalizedString("Glucose is estimated to be %1$@ at %2$@. Recommendation is based on eventual predicted BG of %3$@", comment: "Message when offering bolus prediction even though bg is below range and minBG is in future. (1: glucose number)(2: glucose time)(3: eventual BG)"), minBGStr, time, eventualBG)
+                notice = String(format: NSLocalizedString("Predicted glucose at %1$@ is %2$@.", comment: "Message when offering bolus prediction even though bg is below range and minBG is in future. (1: glucose time)(2: glucose number)"), time, minBGStr)
             }
-        } else if eventualGlucose.quantity.doubleValue(for: glucoseTargetRange.unit) < eventualGlucoseTargets.minValue {
-
-            let bgStr = "\(eventualBG) \(glucoseTargetRange.unit.glucoseUnitDisplayString)"
-            notice = String(format: NSLocalizedString("Eventual glucose is %1$@. No bolus recommended.", comment: "Notice when eventual glucose is below range, so no bolus is recommended.  (1: eventual glucose number)"), bgStr)
         } else {
             notice = nil
         }
 
-        return BolusRecommendation(amount: cappedAmount, notice: notice)
+        return BolusRecommendation(amount: cappedAmount, pendingInsulin: pendingInsulin, notice: notice)
     }
 }

Loop/Managers/LoopDataManager.swift

@@ -261,6 +261,31 @@ final class LoopDataManager {
         }
     }
 
+    func getPendingInsulin() throws -> Double {
+
+        guard let basalRates = deviceDataManager.basalRateSchedule else {
+            throw LoopError.configurationError
+        }
+
+        let pendingTempBasalInsulin: Double
+        let date = Date()
+
+        if let lastTempBasal = lastTempBasal, lastTempBasal.unit == .unitsPerHour && lastTempBasal.endDate > date {
+            let normalBasalRate = basalRates.value(at: date)
+            let remainingTime = lastTempBasal.endDate.timeIntervalSince(date)
+            let remainingUnits = (lastTempBasal.value - normalBasalRate) * remainingTime / TimeInterval(hours: 1)
+
+            pendingTempBasalInsulin = max(0, remainingUnits)
+        } else {
+            pendingTempBasalInsulin = 0
+        }
+
+        let pendingBolusAmount: Double = lastBolus?.units ?? 0
+
+        // All outstanding potential insulin delivery
+        return pendingTempBasalInsulin + pendingBolusAmount
+    }
+
     func modelPredictedGlucose(using inputs: [PredictionInputEffect], resultsHandler: @escaping (_ predictedGlucose: [GlucoseValue]?, _ error: Error?) -> Void) {
         dataAccessQueue.async { 
             guard let
@@ -479,21 +504,32 @@ final class LoopDataManager {
      */
     private func updatePredictedGlucoseAndRecommendedBasal() throws {
         guard let
-            glucose = self.deviceDataManager.glucoseStore?.latestGlucose,
-            let pumpStatusDate = self.deviceDataManager.doseStore.lastReservoirValue?.startDate
+            glucose = self.deviceDataManager.glucoseStore?.latestGlucose
+            else {
+                self.predictedGlucose = nil
+                throw LoopError.missingDataError("Glucose")
+        }
+
+        guard let
+            pumpStatusDate = self.deviceDataManager.doseStore.lastReservoirValue?.startDate
         else {
             self.predictedGlucose = nil
-            throw LoopError.missingDataError("Cannot predict glucose due to missing input data")
+            throw LoopError.missingDataError("Reservoir")
         }
 
         let startDate = Date()
         let recencyInterval = TimeInterval(minutes: 15)
 
-        guard startDate.timeIntervalSince(glucose.startDate) <= recencyInterval &&
-              startDate.timeIntervalSince(pumpStatusDate) <= recencyInterval
+        guard startDate.timeIntervalSince(glucose.startDate) <= recencyInterval
         else {
             self.predictedGlucose = nil
-            throw LoopError.staleDataError("Glucose Date: \(glucose.startDate) or Pump status date: \(pumpStatusDate) older than \(recencyInterval.minutes) min")
+            throw LoopError.glucoseTooOld(startDate.timeIntervalSince(glucose.startDate))
+        }
+
+        guard startDate.timeIntervalSince(pumpStatusDate) <= recencyInterval
+        else {
+            self.predictedGlucose = nil
+            throw LoopError.pumpDataTooOld(startDate.timeIntervalSince(pumpStatusDate))
         }
 
         guard let
@@ -502,7 +538,7 @@ final class LoopDataManager {
             let insulinEffect = self.insulinEffect else
         {
             self.predictedGlucose = nil
-            throw LoopError.missingDataError("Cannot predict glucose due to missing effect data")
+            throw LoopError.missingDataError("Glucose effects")
         }
 
         var error: Error?
@@ -548,7 +584,7 @@ final class LoopDataManager {
             let basalRates = deviceDataManager.basalRateSchedule,
             let minimumBGGuard = deviceDataManager.minimumBGGuard
         else {
-            error = LoopError.missingDataError("Loop configuration data not set")
+            error = LoopError.configurationError
             throw error!
         }
 
@@ -592,7 +628,7 @@ final class LoopDataManager {
                 }
             }
         } else {
-            resultsHandler(nil, LoopError.missingDataError("CarbStore not configured"))
+            resultsHandler(nil, LoopError.configurationError)
         }
     }
 
@@ -605,7 +641,7 @@ final class LoopDataManager {
             let basalRates = self.deviceDataManager.basalRateSchedule,
             let minimumBGGuard = self.deviceDataManager.minimumBGGuard
         else {
-            throw LoopError.missingDataError("Bolus prediction and configuration data not found")
+            throw LoopError.configurationError
         }
 
         let recencyInterval = TimeInterval(minutes: 15)
@@ -615,19 +651,20 @@ final class LoopDataManager {
         }
 
         guard abs(predictedInterval) <= recencyInterval else {
-            throw LoopError.staleDataError("Glucose is \(predictedInterval.minutes) min old")
+            throw LoopError.glucoseTooOld(predictedInterval)
         }
 
-        let pendingBolusAmount: Double = lastBolus?.units ?? 0
-
-        let bolusRecommendation = DoseMath.recommendBolusFromPredictedGlucose(glucose,
-                                                                              lastTempBasal: self.lastTempBasal,
-                                                                              maxBolus: maxBolus,
-                                                                              glucoseTargetRange: glucoseTargetRange,
-                                                                              insulinSensitivity: insulinSensitivity,
-                                                                              basalRateSchedule: basalRates,
-                                                                              pendingBolusAmount: pendingBolusAmount,
-                                                                              minimumBGGuard: minimumBGGuard)
+        let pendingInsulin = try self.getPendingInsulin()
+
+        let bolusRecommendation = DoseMath.recommendBolusFromPredictedGlucose(
+            glucose,
+            lastTempBasal: self.lastTempBasal,
+            maxBolus: maxBolus,
+            glucoseTargetRange: glucoseTargetRange,
+            insulinSensitivity: insulinSensitivity,
+            basalRateSchedule: basalRates,
+            pendingInsulin: pendingInsulin,
+            minimumBGGuard: minimumBGGuard)
 
         return bolusRecommendation
     }
@@ -650,7 +687,7 @@ final class LoopDataManager {
         }
 
         guard recommendedTempBasal.recommendedDate.timeIntervalSinceNow < TimeInterval(minutes: 5) else {
-            resultsHandler(false, LoopError.staleDataError("Recommended temp basal is \(recommendedTempBasal.recommendedDate.timeIntervalSinceNow.minutes) min old"))
+            resultsHandler(false, LoopError.recommendationExpired(recommendedTempBasal.recommendedDate.timeIntervalSinceNow))
             return
         }
 

Loop/Models/BolusRecommendation.swift

@@ -13,7 +13,7 @@ struct BolusRecommendation {
     let amount: Double
     let notice: String?
 
-    init(amount: Double, notice: String? = nil) {
+    init(amount: Double, pendingInsulin: Double? = nil, notice: String? = nil) {
         self.amount = amount
         self.notice = notice
     }

Loop/Models/LoopError.swift

@@ -6,6 +6,7 @@
 //  Copyright © 2016 Nathan Racklyeft. All rights reserved.
 //
 
+import Foundation
 
 enum LoopError: Error {
     // Failure during device communication
@@ -20,6 +21,43 @@ enum LoopError: Error {
     // Missing required data to perform an action
     case missingDataError(String)
 
-    // Out-of-date required data to perform an action
-    case staleDataError(String)
+    // Glucose data is too old to perform action
+    case glucoseTooOld(TimeInterval)
+
+    // Pump data is too old to perform action
+    case pumpDataTooOld(TimeInterval)
+
+    // Recommendation Expired
+    case recommendationExpired(TimeInterval)
+}
+
+extension LoopError: LocalizedError {
+
+    public var errorDescription: String? {
+
+        let integerFormatter = NumberFormatter()
+        integerFormatter.numberStyle = .none
+        integerFormatter.maximumFractionDigits = 0
+
+        switch self {
+        case .communicationError:
+            return NSLocalizedString("Communication Error", comment: "The error message displayed after a communication error.")
+        case .configurationError:
+            return NSLocalizedString("Configuration Error", comment: "The error message displayed for configuration errors.")
+        case .connectionError:
+            return NSLocalizedString("No connected devices, or failure during device connection", comment: "The error message displayed for device connection errors.")
+        case .missingDataError(let details):
+            return String(format: NSLocalizedString("Missing data: %1$@", comment: "The error message for missing data. (1: missing data details)"), details)
+        case .glucoseTooOld(let age):
+            let minutes = integerFormatter.string(from: NSNumber(value: age.minutes)) ?? "??"
+            return String(format: NSLocalizedString("Glucose data is %1$@ minutes old", comment: "The error message when glucose data is too old to be used. (1: glucose data age in minutes)"), minutes)
+        case .pumpDataTooOld(let age):
+            let minutes = integerFormatter.string(from: NSNumber(value: age.minutes)) ?? "??"
+            return String(format: NSLocalizedString("Pump data is %1$@ minutes old", comment: "The error message when pump data is too old to be used. (1: pump data age in minutes)"), minutes)
+        case .recommendationExpired(let age):
+            let minutes = integerFormatter.string(from: NSNumber(value: age.minutes)) ?? "??"
+            return String(format: NSLocalizedString("Recommendation expired: %1$@ minutes old", comment: "The error message when a recommendation has expired. (1: age of recommendation in minutes)"), minutes)
+        }
+    }
 }
+