roomRates = [:]
data.ventIdsByRoomId.each { roomId, ventIds ->
for (ventId in ventIds) {
def vent = getChildDevice(ventId)
if (!vent) {
log "Failed getting vent Id ${ventId}", 3
continue
}
def roomName = vent.currentValue('room-name')
def ratePropName = data.hvacMode == COOLING ? 'room-cooling-rate' : 'room-heating-rate'
// Check if rate already calculated for this room
if (roomRates.containsKey(roomName)) {
// Use the already calculated rate for this room
def rate = roomRates[roomName]
sendEvent(vent, [name: ratePropName, value: rate])
log "Applying same ${ratePropName} (${roundBigDecimal(rate)}) to additional vent in '${roomName}'", 3
continue
}
// Calculate rate for this room (first vent in room)
def percentOpen = (vent.currentValue('percent-open') ?: 0).toInteger()
BigDecimal currentTemp = getRoomTemp(vent)
BigDecimal lastStartTemp = vent.currentValue('room-starting-temperature-c') ?: 0
BigDecimal currentRate = vent.currentValue(ratePropName) ?: 0
def newRate = calculateRoomChangeRate(lastStartTemp, currentTemp, totalCycleMinutes, percentOpen, currentRate)
if (newRate <= 0) {
log "New rate for ${roomName} is ${newRate}", 3
// Check if room is already at or beyond setpoint
def isAtSetpoint = hasRoomReachedSetpoint(data.hvacMode,
getThermostatSetpoint(data.hvacMode), currentTemp)
if (isAtSetpoint && currentRate > 0) {
// Room is already at setpoint - maintain last known efficiency
log "${roomName} is already at setpoint, maintaining last known efficiency rate: ${currentRate}", 3
newRate = currentRate // Keep existing rate
} else if (percentOpen > 0) {
// Vent was open but no temperature change - use minimum rate
newRate = MIN_TEMP_CHANGE_RATE
log "Setting minimum rate for ${roomName} - no temperature change detected with ${percentOpen}% open vent", 3
} else if (currentRate == 0) {
// Room has zero efficiency and vent was closed - set baseline efficiency
def maxRate = data.hvacMode == COOLING ?
atomicState.maxCoolingRate ?: MAX_TEMP_CHANGE_RATE :
atomicState.maxHeatingRate ?: MAX_TEMP_CHANGE_RATE
newRate = maxRate * 0.1 // 10% of maximum as baseline
log "Setting baseline efficiency for ${roomName} (10% of max rate: ${newRate})", 3
} else {
continue // Skip if vent was closed and room has existing efficiency
}
}
def rate = rollingAverage(currentRate, newRate, percentOpen / 100, 4)
def cleanedRate = cleanDecimalForJson(rate)
sendEvent(vent, [name: ratePropName, value: cleanedRate])
log "Updating ${roomName}'s ${ratePropName} to ${roundBigDecimal(cleanedRate)}", 3
// Store the calculated rate for this room
roomRates[roomName] = cleanedRate
// Track maximum rates for baseline calculations
if (cleanedRate > 0) {
if (data.hvacMode == COOLING) {
def maxCoolRate = atomicState.maxCoolingRate ?: 0
if (cleanedRate > maxCoolRate) {
atomicState.maxCoolingRate = cleanDecimalForJson(cleanedRate)
log "Updated maximum cooling rate to ${cleanedRate}", 3
}
} else if (data.hvacMode == HEATING) {
def maxHeatRate = atomicState.maxHeatingRate ?: 0
if (cleanedRate > maxHeatRate) {
atomicState.maxHeatingRate = cleanDecimalForJson(cleanedRate)
log "Updated maximum heating rate to ${cleanedRate}", 3
}
}
}
}
}
} else {
log "Could not calculate room states as it ran for ${totalCycleMinutes} minutes and needs to run for at least ${MIN_MINUTES_TO_SETPOINT} minutes", 3
}
log 'End - Finalizing room states', 3
}
def recordStartingTemperatures() {
if (!atomicState.ventsByRoomId) { return }
log "Recording starting temperatures for all rooms", 2
atomicState.ventsByRoomId.each { roomId, ventIds ->
ventIds.each { ventId ->
try {
def vent = getChildDevice(ventId)
if (!vent) { return }
BigDecimal currentTemp = getRoomTemp(vent)
sendEvent(vent, [name: 'room-starting-temperature-c', value: currentTemp])
log "Starting temperature for '${vent.currentValue('room-name')}': ${currentTemp}°C", 2
} catch (err) {
logError err
}
}
}
}
def initializeRoomStates(String hvacMode) {
if (!settings.dabEnabled) { return }
log "Initializing room states - hvac mode: ${hvacMode}", 3
if (!atomicState.ventsByRoomId) { return }
BigDecimal setpoint = getThermostatSetpoint(hvacMode)
if (!setpoint) { return }
atomicStateUpdate('thermostat1State', 'startedCycle', now())
def rateAndTempPerVentId = getAttribsPerVentId(atomicState.ventsByRoomId, hvacMode)
def maxRunningTime = atomicState.maxHvacRunningTime ?: MAX_MINUTES_TO_SETPOINT
def longestTimeToTarget = calculateLongestMinutesToTarget(rateAndTempPerVentId, hvacMode, setpoint, maxRunningTime, settings.thermostat1CloseInactiveRooms)
if (longestTimeToTarget < 0) {
log "All vents already reached setpoint (${setpoint})", 3
longestTimeToTarget = maxRunningTime
}
if (longestTimeToTarget == 0) {
log "Opening all vents (setpoint: ${setpoint})", 3
openAllVents(atomicState.ventsByRoomId, MAX_PERCENTAGE_OPEN as int)
return
}
log "Initializing room states - setpoint: ${setpoint}, longestTimeToTarget: ${roundBigDecimal(longestTimeToTarget)}", 3
def calcPercentOpen = calculateOpenPercentageForAllVents(rateAndTempPerVentId, hvacMode, setpoint, longestTimeToTarget, settings.thermostat1CloseInactiveRooms)
if (!calcPercentOpen) {
log "No vents are being changed (setpoint: ${setpoint})", 3
return
}
calcPercentOpen = adjustVentOpeningsToEnsureMinimumAirflowTarget(rateAndTempPerVentId, hvacMode, calcPercentOpen, settings.thermostat1AdditionalStandardVents)
calcPercentOpen.each { ventId, percentOpen ->
def vent = getChildDevice(ventId)
if (vent) {
patchVent(vent, roundToNearestMultiple(percentOpen))
}
}
}
def adjustVentOpeningsToEnsureMinimumAirflowTarget(rateAndTempPerVentId, String hvacMode, Map calculatedPercentOpen, additionalStandardVents) {
int totalDeviceCount = additionalStandardVents > 0 ? additionalStandardVents : 0
def sumPercentages = totalDeviceCount * STANDARD_VENT_DEFAULT_OPEN
calculatedPercentOpen.each { ventId, percent ->
totalDeviceCount++
sumPercentages += percent ?: 0
}
if (totalDeviceCount <= 0) {
logWarn 'Total device count is zero'
return calculatedPercentOpen
}
BigDecimal maxTemp = null
BigDecimal minTemp = null
rateAndTempPerVentId.each { ventId, stateVal ->
maxTemp = maxTemp == null || maxTemp < stateVal.temp ? stateVal.temp : maxTemp
minTemp = minTemp == null || minTemp > stateVal.temp ? stateVal.temp : minTemp
}
if (minTemp == null || maxTemp == null) {
minTemp = 20.0
maxTemp = 25.0
} else {
minTemp = minTemp - TEMP_BOUNDARY_ADJUSTMENT
maxTemp = maxTemp + TEMP_BOUNDARY_ADJUSTMENT
}
def combinedFlowPercentage = (100 * sumPercentages) / (totalDeviceCount * 100)
if (combinedFlowPercentage >= MIN_COMBINED_VENT_FLOW) {
log "Combined vent flow percentage (${combinedFlowPercentage}%) is greater than ${MIN_COMBINED_VENT_FLOW}%", 3
return calculatedPercentOpen
}
log "Combined Vent Flow Percentage (${combinedFlowPercentage}) is lower than ${MIN_COMBINED_VENT_FLOW}%", 3
def targetPercentSum = MIN_COMBINED_VENT_FLOW * totalDeviceCount
def diffPercentageSum = targetPercentSum - sumPercentages
log "sumPercentages=${sumPercentages}, targetPercentSum=${targetPercentSum}, diffPercentageSum=${diffPercentageSum}", 2
int iterations = 0
while (diffPercentageSum > 0 && iterations++ < MAX_ITERATIONS) {
for (item in rateAndTempPerVentId) {
def ventId = item.key
def stateVal = item.value
BigDecimal percentOpenVal = calculatedPercentOpen[ventId] ?: 0
if (percentOpenVal >= MAX_PERCENTAGE_OPEN) {
percentOpenVal = MAX_PERCENTAGE_OPEN
} else {
def proportion = hvacMode == COOLING ?
(stateVal.temp - minTemp) / (maxTemp - minTemp) :
(maxTemp - stateVal.temp) / (maxTemp - minTemp)
def increment = INCREMENT_PERCENTAGE * proportion
percentOpenVal = percentOpenVal + increment
calculatedPercentOpen[ventId] = percentOpenVal
log "Adjusting % open from ${roundBigDecimal(percentOpenVal - increment)}% to ${roundBigDecimal(percentOpenVal)}%", 2
diffPercentageSum = diffPercentageSum - increment
if (diffPercentageSum <= 0) { break }
}
}
}
return calculatedPercentOpen
}
def getAttribsPerVentId(ventsByRoomId, String hvacMode) {
def rateAndTemp = [:]
ventsByRoomId.each { roomId, ventIds ->
ventIds.each { ventId ->
try {
def vent = getChildDevice(ventId)
if (!vent) { return }
def rate = hvacMode == COOLING ? (vent.currentValue('room-cooling-rate') ?: 0) : (vent.currentValue('room-heating-rate') ?: 0)
rate = rate ?: 0
def isActive = vent.currentValue('room-active') == 'true'
def roomTemp = getRoomTemp(vent)
def roomName = vent.currentValue('room-name') ?: ''
// Log rooms with zero efficiency for debugging
if (rate == 0) {
def tempSource = settings."thermostat${ventId}" ? "Puck ${settings."thermostat${ventId}".getLabel()}" : "Room API"
log "Room '${roomName}' has zero ${hvacMode} efficiency rate, temp=${roomTemp}°C from ${tempSource}", 2
}
rateAndTemp[ventId] = [ rate: rate, temp: roomTemp, active: isActive, name: roomName ]
} catch (err) {
logError err
}
}
}
return rateAndTemp
}
def calculateOpenPercentageForAllVents(rateAndTempPerVentId, String hvacMode, BigDecimal setpoint, longestTime, boolean closeInactive = true) {
def percentOpenMap = [:]
rateAndTempPerVentId.each { ventId, stateVal ->
try {
def percentageOpen = MIN_PERCENTAGE_OPEN
if (closeInactive && !stateVal.active) {
log "Closing vent on inactive room: ${stateVal.name}", 3
} else if (stateVal.rate < MIN_TEMP_CHANGE_RATE) {
log "Opening vent at max since change rate is too low: ${stateVal.name}", 3
percentageOpen = MAX_PERCENTAGE_OPEN
} else {
percentageOpen = calculateVentOpenPercentage(stateVal.name, stateVal.temp, setpoint, hvacMode, stateVal.rate, longestTime)
}
percentOpenMap[ventId] = percentageOpen
} catch (err) {
logError err
}
}
return percentOpenMap
}
def calculateVentOpenPercentage(String roomName, BigDecimal startTemp, BigDecimal setpoint, String hvacMode, BigDecimal maxRate, BigDecimal longestTime) {
if (hasRoomReachedSetpoint(hvacMode, setpoint, startTemp)) {
def msg = hvacMode == COOLING ? 'cooler' : 'warmer'
log "'${roomName}' is already ${msg} (${startTemp}) than setpoint (${setpoint})", 3
return MIN_PERCENTAGE_OPEN
}
BigDecimal percentageOpen = MAX_PERCENTAGE_OPEN
if (maxRate > 0 && longestTime > 0) {
BigDecimal BASE_CONST = 0.0991
BigDecimal EXP_CONST = 2.3
// Calculate the target rate: the average temperature change required per minute.
def targetRate = Math.abs(setpoint - startTemp) / longestTime
percentageOpen = BASE_CONST * Math.exp((targetRate / maxRate) * EXP_CONST)
percentageOpen = roundBigDecimal(percentageOpen * 100, 3)
// Ensure percentageOpen stays within defined limits.
percentageOpen = percentageOpen < MIN_PERCENTAGE_OPEN ? MIN_PERCENTAGE_OPEN :
(percentageOpen > MAX_PERCENTAGE_OPEN ? MAX_PERCENTAGE_OPEN : percentageOpen)
log "changing percentage open for ${roomName} to ${percentageOpen}% (maxRate=${roundBigDecimal(maxRate)})", 3
}
return percentageOpen
}
def calculateLongestMinutesToTarget(rateAndTempPerVentId, String hvacMode, BigDecimal setpoint, maxRunningTime, boolean closeInactive = true) {
def longestTime = -1
rateAndTempPerVentId.each { ventId, stateVal ->
try {
def minutesToTarget = -1
if (closeInactive && !stateVal.active) {
log "'${stateVal.name}' is inactive", 3
} else if (hasRoomReachedSetpoint(hvacMode, setpoint, stateVal.temp)) {
log "'${stateVal.name}' has already reached setpoint", 3
} else if (stateVal.rate > 0) {
minutesToTarget = Math.abs(setpoint - stateVal.temp) / stateVal.rate
// Check for unrealistic time estimates due to minimal temperature change
if (minutesToTarget > maxRunningTime * 2) {
logWarn "'${stateVal.name}' shows minimal temperature change (rate: ${roundBigDecimal(stateVal.rate)}°C/min). " +
"Estimated time ${roundBigDecimal(minutesToTarget)} minutes is unrealistic."
minutesToTarget = maxRunningTime // Cap at max running time
}
} else if (stateVal.rate == 0) {
minutesToTarget = 0
logWarn "'${stateVal.name}' shows no temperature change with vent open"
}
if (minutesToTarget > maxRunningTime) {
logWarn "'${stateVal.name}' is estimated to take ${roundBigDecimal(minutesToTarget)} minutes to reach target temp, which is longer than the average ${roundBigDecimal(maxRunningTime)} minutes"
minutesToTarget = maxRunningTime
}
longestTime = Math.max(longestTime, minutesToTarget.doubleValue())
log "Room '${stateVal.name}' temp: ${stateVal.temp}", 3
} catch (err) {
logError err
}
}
return longestTime
}
// Overloaded method for backward compatibility with tests
def calculateRoomChangeRate(def lastStartTemp, def currentTemp, def totalMinutes, def percentOpen, def currentRate) {
// Null safety checks
if (lastStartTemp == null || currentTemp == null || totalMinutes == null || percentOpen == null || currentRate == null) {
log "calculateRoomChangeRate: null parameter detected", 3
return -1
}
try {
return calculateRoomChangeRate(
lastStartTemp as BigDecimal,
currentTemp as BigDecimal,
totalMinutes as BigDecimal,
percentOpen as int,
currentRate as BigDecimal
)
} catch (Exception e) {
log "calculateRoomChangeRate casting error: ${e.message}", 3
return -1
}
}
def calculateRoomChangeRate(BigDecimal lastStartTemp, BigDecimal currentTemp, BigDecimal totalMinutes, int percentOpen, BigDecimal currentRate) {
if (totalMinutes < MIN_MINUTES_TO_SETPOINT) {
log "Insufficient number of minutes required to calculate change rate (${totalMinutes} should be greater than ${MIN_MINUTES_TO_SETPOINT})", 3
return -1
}
// Skip rate calculation if HVAC hasn't run long enough for meaningful temperature changes
if (totalMinutes < MIN_RUNTIME_FOR_RATE_CALC) {
log "HVAC runtime too short for rate calculation: ${totalMinutes} minutes < ${MIN_RUNTIME_FOR_RATE_CALC} minutes minimum", 3
return -1
}
if (percentOpen <= MIN_PERCENTAGE_OPEN) {
log "Vent was opened less than ${MIN_PERCENTAGE_OPEN}% (${percentOpen}), therefore it is being excluded", 3
return -1
}
BigDecimal diffTemps = Math.abs(lastStartTemp - currentTemp)
// Check if temperature change is within sensor noise/accuracy range
if (diffTemps < MIN_DETECTABLE_TEMP_CHANGE) {
log "Temperature change (${diffTemps}°C) is below minimum detectable threshold (${MIN_DETECTABLE_TEMP_CHANGE}°C) - likely sensor noise", 2
// If no meaningful temperature change but vent was significantly open, assign minimum efficiency
if (percentOpen >= 30) {
log "Vent was ${percentOpen}% open but no meaningful temperature change detected - assigning minimum efficiency", 2
return MIN_TEMP_CHANGE_RATE
}
return -1
}
// Account for sensor accuracy when detecting minimal changes
if (diffTemps < TEMP_SENSOR_ACCURACY) {
log "Temperature change (${diffTemps}°C) is within sensor accuracy range (±${TEMP_SENSOR_ACCURACY}°C) - adjusting calculation", 2
// Use a minimum reliable change for calculation to avoid division by near-zero
diffTemps = Math.max(diffTemps, MIN_DETECTABLE_TEMP_CHANGE)
}
BigDecimal rate = diffTemps / totalMinutes
BigDecimal pOpen = percentOpen / 100
BigDecimal maxRate = Math.max(rate.doubleValue(), currentRate.doubleValue())
BigDecimal approxRate = maxRate != 0 ? (rate / maxRate) / pOpen : 0
if (approxRate > MAX_TEMP_CHANGE_RATE) {
log "Change rate (${roundBigDecimal(approxRate)}) is greater than ${MAX_TEMP_CHANGE_RATE}, therefore it is being excluded", 3
return -1
} else if (approxRate < MIN_TEMP_CHANGE_RATE) {
log "Change rate (${roundBigDecimal(approxRate)}) is lower than ${MIN_TEMP_CHANGE_RATE}, adjusting to minimum (startTemp=${lastStartTemp}, currentTemp=${currentTemp}, percentOpen=${percentOpen}%)", 3
// Return minimum rate instead of excluding to prevent zero efficiency
return MIN_TEMP_CHANGE_RATE
}
return approxRate
}
// ------------------------------
// Dynamic Polling Control
// ------------------------------
def updateDevicePollingInterval(Integer intervalMinutes) {
log "Updating device polling interval to ${intervalMinutes} minutes", 3
// Update all child vents
getChildDevices()?.findAll { it.typeName == 'Flair vents' }?.each { device ->
try {
device.updateParentPollingInterval(intervalMinutes)
} catch (Exception e) {
log "Error updating polling interval for vent ${device.getLabel()}: ${e.message}", 2
}
}
// Update all child pucks
getChildDevices()?.findAll { it.typeName == 'Flair pucks' }?.each { device ->
try {
device.updateParentPollingInterval(intervalMinutes)
} catch (Exception e) {
log "Error updating polling interval for puck ${device.getLabel()}: ${e.message}", 2
}
}
atomicState.currentPollingInterval = intervalMinutes
log "Updated polling interval for ${getChildDevices()?.size() ?: 0} devices", 3
}
// ------------------------------
// Efficiency Data Export/Import Functions
// ------------------------------
def handleExportEfficiencyData() {
try {
log "Starting efficiency data export", 2
// Collect efficiency data from all vents
def efficiencyData = exportEfficiencyData()
// Generate JSON format
def jsonData = generateEfficiencyJSON(efficiencyData)
// Set export status message
def roomCount = efficiencyData.roomEfficiencies.size()
state.exportStatus = "✓ Exported efficiency data for ${roomCount} rooms. Copy the JSON data below:"
// Store the JSON data for display
state.exportedJsonData = jsonData
log "Export completed successfully for ${roomCount} rooms", 2
} catch (Exception e) {
def errorMsg = "Export failed: ${e.message}"
logError errorMsg
state.exportStatus = "✗ ${errorMsg}"
state.exportedJsonData = null
}
}
def handleImportEfficiencyData() {
try {
log "Starting efficiency data import", 2
// Clear previous status
state.remove('importStatus')
state.remove('importSuccess')
// Get JSON data from user input
def jsonData = settings.importJsonData
if (!jsonData?.trim()) {
state.importStatus = "✗ No JSON data provided. Please paste the exported efficiency data."
state.importSuccess = false
return
}
// Import the data
def result = importEfficiencyData(jsonData.trim())
if (result.success) {
def statusMsg = "✓ Import successful! Updated ${result.roomsUpdated} rooms"
if (result.globalUpdated) {
statusMsg += " and global efficiency rates"
}
if (result.roomsSkipped > 0) {
statusMsg += ". Skipped ${result.roomsSkipped} rooms (not found)"
}
state.importStatus = statusMsg
state.importSuccess = true
// Clear the input field after successful import
app.updateSetting('importJsonData', '')
log "Import completed: ${result.roomsUpdated} rooms updated, ${result.roomsSkipped} skipped", 2
} else {
state.importStatus = "✗ Import failed: ${result.error}"
state.importSuccess = false
logError "Import failed: ${result.error}"
}
} catch (Exception e) {
def errorMsg = "Import failed: ${e.message}"
logError errorMsg
state.importStatus = "✗ ${errorMsg}"
state.importSuccess = false
}
}
def handleClearExportData() {
try {
log "Clearing export data", 2
state.remove('exportStatus')
state.remove('exportedJsonData')
log "Export data cleared successfully", 2
} catch (Exception e) {
logError "Failed to clear export data: ${e.message}"
}
}
def exportEfficiencyData() {
def data = [
globalRates: [
maxCoolingRate: cleanDecimalForJson(atomicState.maxCoolingRate),
maxHeatingRate: cleanDecimalForJson(atomicState.maxHeatingRate)
],
roomEfficiencies: []
]
// Only collect from vents (devices with percent-open attribute)
getChildDevices().findAll { it.hasAttribute('percent-open') }.each { device ->
def coolingRate = device.currentValue('room-cooling-rate') ?: 0
def heatingRate = device.currentValue('room-heating-rate') ?: 0
def roomData = [
roomId: device.currentValue('room-id'),
roomName: device.currentValue('room-name'),
ventId: device.getDeviceNetworkId(),
coolingRate: cleanDecimalForJson(coolingRate),
heatingRate: cleanDecimalForJson(heatingRate)
]
data.roomEfficiencies << roomData
}
return data
}
def generateEfficiencyJSON(data) {
def exportData = [
exportMetadata: [
version: '0.23',
exportDate: new Date().format("yyyy-MM-dd'T'HH:mm:ss'Z'"),
structureId: settings.structureId ?: 'Unknown'
],
efficiencyData: data
]
return JsonOutput.toJson(exportData)
}
def importEfficiencyData(jsonContent) {
try {
def jsonData = new groovy.json.JsonSlurper().parseText(jsonContent)
if (!validateImportData(jsonData)) {
return [success: false, error: 'Invalid data format. Please ensure you are using exported efficiency data.']
}
def results = applyImportedEfficiencies(jsonData.efficiencyData)
return [
success: true,
globalUpdated: results.globalUpdated,
roomsUpdated: results.roomsUpdated,
roomsSkipped: results.roomsSkipped,
errors: results.errors
]
} catch (Exception e) {
return [success: false, error: e.message]
}
}
def validateImportData(jsonData) {
// Check required structure
if (!jsonData.exportMetadata || !jsonData.efficiencyData) return false
if (!jsonData.efficiencyData.globalRates) return false
if (!jsonData.efficiencyData.roomEfficiencies) return false
// Validate global rates
def globalRates = jsonData.efficiencyData.globalRates
if (globalRates.maxCoolingRate == null || globalRates.maxHeatingRate == null) return false
if (globalRates.maxCoolingRate < 0 || globalRates.maxHeatingRate < 0) return false
if (globalRates.maxCoolingRate > 10 || globalRates.maxHeatingRate > 10) return false
// Validate room efficiencies
for (room in jsonData.efficiencyData.roomEfficiencies) {
if (!room.roomId || !room.roomName || !room.ventId) return false
if (room.coolingRate == null || room.heatingRate == null) return false
if (room.coolingRate < 0 || room.heatingRate < 0) return false
if (room.coolingRate > 10 || room.heatingRate > 10) return false
}
return true
}
def applyImportedEfficiencies(efficiencyData) {
def results = [
globalUpdated: false,
roomsUpdated: 0,
roomsSkipped: 0,
errors: []
]
// Update global rates
if (efficiencyData.globalRates) {
atomicState.maxCoolingRate = efficiencyData.globalRates.maxCoolingRate
atomicState.maxHeatingRate = efficiencyData.globalRates.maxHeatingRate
results.globalUpdated = true
log "Updated global rates: cooling=${efficiencyData.globalRates.maxCoolingRate}, heating=${efficiencyData.globalRates.maxHeatingRate}", 2
}
// Update room efficiencies
efficiencyData.roomEfficiencies?.each { roomData ->
def device = matchDeviceByRoomId(roomData.roomId) ?: matchDeviceByRoomName(roomData.roomName)
if (device) {
sendEvent(device, [name: 'room-cooling-rate', value: roomData.coolingRate])
sendEvent(device, [name: 'room-heating-rate', value: roomData.heatingRate])
results.roomsUpdated++
log "Updated efficiency for '${roomData.roomName}': cooling=${roomData.coolingRate}, heating=${roomData.heatingRate}", 2
} else {
results.roomsSkipped++
results.errors << "Room not found: ${roomData.roomName} (${roomData.roomId})"
log "Skipped room '${roomData.roomName}' - no matching device found", 2
}
}
return results
}
def matchDeviceByRoomId(roomId) {
return getChildDevices().find { device ->
device.hasAttribute('percent-open') && device.currentValue('room-id') == roomId
}
}
def matchDeviceByRoomName(roomName) {
return getChildDevices().find { device ->
device.hasAttribute('percent-open') && device.currentValue('room-name') == roomName
}
}
def efficiencyDataPage() {
// Auto-generate export data on page load
def vents = getChildDevices().findAll { it.hasAttribute('percent-open') }
def roomsWithData = vents.findAll {
(it.currentValue('room-cooling-rate') ?: 0) > 0 ||
(it.currentValue('room-heating-rate') ?: 0) > 0
}
// Automatically generate JSON data when page loads
def exportJsonData = ""
if (roomsWithData.size() > 0) {
try {
def efficiencyData = exportEfficiencyData()
exportJsonData = generateEfficiencyJSON(efficiencyData)
} catch (Exception e) {
log "Error generating export data: ${e.message}", 2
}
}
dynamicPage(name: 'efficiencyDataPage', title: '🔄 Backup & Restore Efficiency Data', install: false, uninstall: false) {
section {
paragraph '''
📚 What is this?
Your Flair vents learn how efficiently each room heats and cools over time. This data helps the system optimize energy usage.
Use this page to backup your data before app updates or restore it after system resets.
'''
}
// Show current status
if (vents.size() > 0) {
section("📊 Current Status") {
if (roomsWithData.size() > 0) {
paragraph "✓ Your system has learned efficiency data for ${roomsWithData.size()} out of ${vents.size()} rooms
"
} else {
paragraph "⚠ Your system is still learning (${vents.size()} rooms found, but no efficiency data yet)
"
paragraph "Let your system run for a few heating/cooling cycles before backing up data."
}
}
}
// Export Section - Auto-generated
if (roomsWithData.size() > 0 && exportJsonData) {
section("💾 Save Your Data (Backup)") {
// Create base64 encoded download link with current date
def currentDate = new Date().format("yyyy-MM-dd")
def fileName = "Flair-Backup-${currentDate}.json"
def base64Data = exportJsonData.bytes.encodeBase64().toString()
def downloadUrl = "data:application/json;charset=utf-8;base64,${base64Data}"
paragraph "Your backup data is ready:"
paragraph "📥 Download ${fileName}"
}
} else if (vents.size() > 0) {
section("💾 Save Your Data (Backup)") {
paragraph "System is still learning. Check back after a few heating/cooling cycles."
}
}
// Import Section
section("📥 Step 2: Restore Your Data (Import)") {
paragraph '''
When should I do this?
• After reinstalling this app
• After resetting your Hubitat hub
• After replacing hardware
'''
paragraph '''
How to restore your data:
1. Find your saved backup JSON file (e.g., "Flair-Backup-2025-06-26.json")
2. Open the JSON file in Notepad/TextEdit
3. Select all text (Ctrl+A) and copy (Ctrl+C)
4. Paste it in the box below (Ctrl+V)
5. Click "Restore My Data"
Note: Hubitat doesn't support file uploads, so we need to copy/paste the JSON content.
'''
input name: 'importJsonData', type: 'textarea', title: 'Paste JSON Backup Data',
description: 'Open your backup JSON file and paste ALL the content here',
required: false, rows: 8
input name: 'importEfficiencyData', type: 'button', title: 'Restore My Data',
submitOnChange: true, width: 4
if (state.importStatus) {
def statusColor = state.importSuccess ? 'green' : 'red'
def statusIcon = state.importSuccess ? '✓' : '✗'
paragraph "${statusIcon} ${state.importStatus}
"
if (state.importSuccess) {
paragraph '''
🎉 Success! What happens now?
Your room learning data has been restored. Your Flair vents will now use the saved efficiency information to:
- Optimize airflow to each room
- Reduce energy usage
- Maintain comfortable temperatures
You're all set! The system will continue learning and improving from this restored baseline.
'''
}
}
}
// Help & Tips Section
section("❓ Need Help?") {
paragraph '''
💡 Tips for Success
- Regular Backups: Save your data monthly or before any system changes
- File Naming: Include the date in your backup filename (e.g., "Flair-Backup-2025-06-26")
- Multiple Copies: Store backups in multiple places (email, cloud storage, USB drive)
- When to Restore: Only restore data when setting up a new system or after data loss
🚨 Troubleshooting
- Import Failed: Make sure you copied ALL the text from your backup file
- No Data to Export: Let your system run for a few heating/cooling cycles first
- Room Not Found: Room names may have changed - the system will skip those rooms
- Still Need Help: Check the Hubitat community forums or contact support
'''
}
section {
href name: 'backToMain', title: '← Back to Main Settings', description: 'Return to the main app configuration', page: 'mainPage'
}
}
}
// ------------------------------
// End of Core Functions
// ------------------------------