gru/gree-controller
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
b93a1f2d922e4a91afc93f06a666c389473f3976
gree-controller/src/engine.rs
T
Mateusz Gruszczyński b93a1f2d92 v0.7.13
2026-08-27 22:00:13 +02:00

2698 lines
128 KiB
Rust
Raw Blame History

use std::{collections::HashMap, sync::atomic::Ordering, time::{Duration, Instant}};
use anyhow::Result;
use chrono::{DateTime, Datelike, Local, NaiveTime, Timelike, Utc, Weekday};
use serde_json::{json, Value};
use tokio::time::sleep;
use crate::{
error::AppError,
home_assistant,
influxdb,
models::{Automation, AutomationPlanRule, ControlPlan, ControlPlanEvent, Device, DeviceCommand, GroupControlPatch, HaReading, NightModeSettings, Reading, Schedule, Zone, ZoneControlPlan, ZoneReading},
state::{AppState, PendingControllerCommand},
};
pub fn start(state: AppState) {
let poll_state = state.clone();
tokio::spawn(async move {
sleep(Duration::from_millis(500)).await;
loop {
match poll_all(&poll_state).await {
Ok(()) => {
if !poll_state.initial_device_sync_complete.swap(true, Ordering::AcqRel) {
tracing::info!("initial device state synchronized; thermostat control enabled");
}
}
Err(err) => tracing::error!(error=?err, "device poll cycle failed"),
}
let seconds = poll_state.settings.read().await.poll_interval_seconds.max(2);
sleep(Duration::from_secs(seconds)).await;
}
});
let control_state = state.clone();
tokio::spawn(async move {
sleep(Duration::from_secs(2)).await;
loop {
// A restart must never make decisions from the persisted, potentially stale
// device snapshot. Wait for one full live poll before thermostat/schedule/automation
// ownership can emit commands. Manual API/remote control remains available.
if !control_state.initial_device_sync_complete.load(Ordering::Acquire) {
sleep(Duration::from_millis(250)).await;
continue;
}
if let Err(err) = control_zones(&control_state).await {
tracing::error!(error=?err, "zone cycle failed");
}
if let Err(err) = run_automations(&control_state).await {
tracing::error!(error=?err, "automation cycle failed");
}
let seconds = control_state.settings.read().await.zone_interval_seconds.max(2);
let normal_delay = Duration::from_secs(seconds);
let resume_delay = match next_local_thermostat_resume_delay(&control_state) {
Ok(value) => value,
Err(err) => {
tracing::warn!(error=?err, "cannot calculate local thermostat resume deadline");
None
}
};
let sleep_for = resume_delay.map(|delay| delay.min(normal_delay)).unwrap_or(normal_delay);
tokio::select! {
_ = sleep(sleep_for) => {},
_ = control_state.zone_control_wakeup.notified() => {},
}
}
});
let maintenance_state = state;
tokio::spawn(async move {
sleep(Duration::from_secs(60)).await;
loop {
let settings = maintenance_state.settings.read().await.clone();
// When InfluxDB is enabled, compact all locally retained legacy history before
// transferring old buckets. Without Influx, compact only the configured retention window.
let compaction_days = if settings.influxdb.enabled { 3650 } else { settings.history_retention_days.max(1) } as i64;
if settings.history_compaction_enabled {
match maintenance_state.db.compact_history(compaction_days) {
Ok(count) if count > 0 => tracing::info!(count, "history samples compacted"),
Ok(_) => {}
Err(err) => tracing::warn!(error=?err, "cannot compact history"),
}
}
if settings.influxdb.enabled {
match archive_old_history(&maintenance_state, settings.influxdb.history_threshold_days.max(1)).await {
Ok(count) if count > 0 => tracing::info!(count, "old local readings archived to InfluxDB and removed from SQLite"),
Ok(_) => {}
Err(err) => tracing::warn!(error=?err, "cannot archive old history to InfluxDB; SQLite copies were kept"),
}
} else {
let retention_days = settings.history_retention_days.max(1) as i64;
match maintenance_state.db.prune_readings(retention_days) {
Ok(count) if count > 0 => tracing::info!(count, retention_days, "old local readings pruned"),
Ok(_) => {}
Err(err) => tracing::warn!(error=?err, "cannot prune readings"),
}
}
let event_retention_days = settings.event_log_retention_days.max(1) as i64;
match maintenance_state.db.prune_events(event_retention_days) {
Ok(count) if count > 0 => tracing::info!(count, event_retention_days, "old event log rows pruned"),
Ok(_) => {}
Err(err) => tracing::warn!(error=?err, "cannot prune event log"),
}
sleep(Duration::from_secs(6 * 60 * 60)).await;
}
});
}
async fn archive_old_history(state: &AppState, threshold_days: u32) -> Result<u64> {
let cutoff = Utc::now() - chrono::Duration::days(threshold_days.max(1) as i64);
let settings = state.settings.read().await.influxdb.clone();
let mut moved = 0_u64;
// Bound one maintenance pass so a very large legacy database never monopolizes the runtime.
// Successful batches are deleted from SQLite, so the next pass naturally continues forward.
for _ in 0..50 {
let (devices, zones, ha) = state.db.history_before(cutoff, 1_000)?;
if devices.is_empty() && zones.is_empty() && ha.is_empty() { break; }
influxdb::write_batch(&state.http, &settings, &devices, &zones, &ha).await?;
let deleted = state.db.delete_history_batch(&devices, &zones, &ha)?;
moved += deleted;
if deleted == 0 { break; }
}
Ok(moved)
}
pub async fn send_command(state: &AppState, device_id: &str, command: DeviceCommand) -> Result<Device, AppError> {
let _device_guard = state.lock_device_operation(device_id).await;
send_command_locked(state, device_id, command).await
}
async fn send_command_locked(state: &AppState, device_id: &str, command: DeviceCommand) -> Result<Device, AppError> {
send_command_locked_inner(state, device_id, command, true, true).await
}
async fn send_command_locked_forced(state: &AppState, device_id: &str, command: DeviceCommand) -> Result<Device, AppError> {
send_command_locked_inner(state, device_id, command, false, true).await
}
async fn send_command_locked_inner(
state: &AppState,
device_id: &str,
command: DeviceCommand,
dedupe_against_cache: bool,
track_controller_command: bool,
) -> Result<Device, AppError> {
validate_command(&command)?;
let mut device = state.db.get_device(device_id)?
.ok_or_else(|| AppError::NotFound(format!("device {device_id}")))?;
if !device.enabled { return Err(AppError::BadRequest("device is disabled".into())); }
// Routine control avoids redundant frames. Explicit safety transitions (global/group OFF,
// detach) may bypass cache de-duplication so stale state cannot leave a unit powered.
let command = if dedupe_against_cache && device.online && device.communication_failures == 0 { command.changed_from(&device) } else { command };
if command.is_empty() { return Ok(device); }
let controller_command_baseline = device.clone();
let suppress_beep = state.settings.read().await.suppress_device_beep;
let response_started = Instant::now();
let mut applied_command = command.clone();
let mut confirmed_state = false;
let mut confirmed_requested_state = true;
if device.simulated {
applied_command.apply(&mut device);
confirmed_state = true;
device.online = true;
device.response_time_ms = Some(0);
device.last_seen = Some(Utc::now());
device.last_error = None;
state.db.save_device(&device)?;
} else {
if device.key.as_deref().unwrap_or_default().is_empty() {
match state.gree.bind(&device).await {
Ok(bound) => {
device.key = Some(bound.key);
device.protocol_version = bound.protocol_version;
device.communication_failures = 0;
state.db.save_device(&device)?;
state.log("info", "device.bound", &format!("Bound {} using protocol V{}", device.name, device.protocol_version), json!({"device_id": device.id, "protocol_version": device.protocol_version}));
}
Err(err) => {
register_device_failure(state, &mut device, &err.to_string())?;
return Err(AppError::Device(err.to_string()));
}
}
}
match state.gree.command(&device, &command, suppress_beep).await {
Ok(result) => applied_command = result,
Err(first_err) => {
// A lost command ACK does not mean the command was lost. Read the device
// first and avoid sending the same frame (and another beep) when the requested
// state is already present. Only rebind when the verification read also fails.
let mut observed = device.clone();
let retry_result = match state.gree.poll(&mut observed).await {
Ok(()) if command.changed_from(&observed).is_empty() => {
device = observed;
confirmed_state = true;
tracing::debug!(device=%device.id, "GREE command ACK was uncertain, but status confirms the requested state");
Ok(command.clone())
}
Ok(()) => {
device = observed;
let remaining = command.changed_from(&device);
if remaining.is_empty() { Ok(command.clone()) }
else { state.gree.command(&device, &remaining, suppress_beep).await }
}
Err(_) => {
match state.gree.bind(&device).await {
Ok(bound) => {
device.key = Some(bound.key);
device.protocol_version = bound.protocol_version;
state.db.save_device(&device)?;
state.gree.command(&device, &command, suppress_beep).await
}
Err(_) => Err(first_err),
}
}
};
match retry_result {
Ok(result) => applied_command = result,
Err(err) => {
register_device_failure(state, &mut device, &err.to_string())?;
return Err(AppError::Device(err.to_string()));
}
}
}
}
if command.quiet.is_some() && applied_command.quiet.is_none() { device.supports_quiet = Some(false); }
if command.sleep.is_some() && applied_command.sleep.is_none() { device.supports_sleep = Some(false); }
// A command ACK confirms transport/acceptance, but several GREE firmwares keep
// returning the pre-command status for a short settling window. Publishing that first
// stale read makes Home Assistant visibly bounce ON -> OFF -> ON. Verify a few times
// with bounded backoff and only publish a differing state after the settling window.
if !confirmed_state {
let verification_delays_ms = [0_u64, 150, 350, 650];
let mut last_verification_error: Option<String> = None;
for delay_ms in verification_delays_ms {
if delay_ms > 0 { sleep(Duration::from_millis(delay_ms)).await; }
let mut observed = device.clone();
match state.gree.poll(&mut observed).await {
Ok(()) => {
let requested_matches = applied_command.changed_from(&observed).is_empty();
device = observed;
confirmed_state = true;
confirmed_requested_state = requested_matches;
last_verification_error = None;
if requested_matches { break; }
}
Err(err) => {
last_verification_error = Some(err.to_string());
}
}
}
if confirmed_state && !confirmed_requested_state {
tracing::debug!(device=%device.id, command=?applied_command, "GREE command acknowledged but status still differs after settling window");
} else if !confirmed_state {
let error = last_verification_error.unwrap_or_else(|| "status verification failed".into());
record_poll_failure(&mut device, &format!("command accepted but status verification failed: {error}"));
state.log("warn", "device.command_unconfirmed", &format!("Command accepted by {}, but resulting state could not be verified", device.name), json!({
"device_id": device.id, "error": error
}));
}
}
if confirmed_state {
device.response_time_ms = Some(response_started.elapsed().as_millis().min(u64::MAX as u128) as u64);
}
state.db.save_device(&device)?;
if !dedupe_against_cache && confirmed_state && !confirmed_requested_state {
if track_controller_command && !command_manual_control_fields(&applied_command).is_empty() {
remember_controller_command(state, device_id, &applied_command, &controller_command_baseline).await;
}
state.broadcast("device.updated", serde_json::to_value(&device).unwrap_or_default());
return Err(AppError::Device("device did not confirm the requested forced state change".into()));
}
}
if track_controller_command && !command_manual_control_fields(&applied_command).is_empty() {
// Keep a bounded settling history even after the requested state has already been
// observed once. Several GREE modules can briefly publish an older snapshot again
// and then return to the controller-requested state. Without this guard that normal
// firmware bounce can be misclassified as a physical/pilot takeover.
remember_controller_command(state, device_id, &applied_command, &controller_command_baseline).await;
}
state.log("info", "device.command", &format!("Updated {}", device.name), json!({
"device_id": device.id,
"command": applied_command,
"confirmed": confirmed_state,
}));
state.broadcast("device.updated", serde_json::to_value(&device).unwrap_or_default());
Ok(device)
}
pub async fn poll_one(state: &AppState, device_id: &str) -> Result<Device, AppError> {
let _device_guard = state.lock_device_operation(device_id).await;
poll_one_locked(state, device_id).await
}
async fn poll_one_locked(state: &AppState, device_id: &str) -> Result<Device, AppError> {
let mut device = state.db.get_device(device_id)?
.ok_or_else(|| AppError::NotFound(format!("device {device_id}")))?;
let before = device.clone();
poll_device(state, &mut device).await;
if poll_completed_successfully(&device) {
detect_external_device_control(state, &before, &device).await?;
}
state.db.save_device(&device)?;
record_reading(state, &device)?;
state.broadcast("device.updated", serde_json::to_value(&device).unwrap_or_default());
Ok(device)
}
async fn poll_all(state: &AppState) -> Result<()> {
let device_ids: Vec<String> = state.db.list_devices()?.into_iter()
.filter(|device| device.enabled)
.map(|device| device.id)
.collect();
for device_id in device_ids {
let _device_guard = state.lock_device_operation(&device_id).await;
let _ = poll_one_locked(state, &device_id).await?;
}
Ok(())
}
async fn poll_device(state: &AppState, device: &mut Device) {
if device.simulated {
simulate_tick(device);
return;
}
let previous_failures = device.communication_failures;
let response_started = Instant::now();
if device.key.as_deref().unwrap_or_default().is_empty() {
match state.gree.bind(device).await {
Ok(bound) => {
device.key = Some(bound.key);
device.protocol_version = bound.protocol_version;
device.communication_failures = 0;
}
Err(err) => {
record_poll_failure(device, &err.to_string());
log_poll_health_transition(state, device, previous_failures).await;
return;
}
}
}
if let Err(first_err) = state.gree.poll(device).await {
// One lost UDP response is common on Wi-Fi and must not trigger a bind storm.
// Rebind only after at least one consecutive failed poll; a successful retry clears
// the counter in GreeClient::poll.
if previous_failures == 0 {
record_poll_failure(device, &first_err.to_string());
} else {
match state.gree.bind(device).await {
Ok(bound) => {
device.key = Some(bound.key);
device.protocol_version = bound.protocol_version;
if let Err(err) = state.gree.poll(device).await {
record_poll_failure(device, &err.to_string());
}
}
Err(_) => record_poll_failure(device, &first_err.to_string()),
}
}
}
if device.communication_failures == 0 && device.online {
device.response_time_ms = Some(response_started.elapsed().as_millis().min(u64::MAX as u128) as u64);
}
log_poll_health_transition(state, device, previous_failures).await;
}
async fn log_poll_health_transition(state: &AppState, device: &Device, previous_failures: u8) {
let threshold = state.settings.read().await.notifications.communication_failure_threshold.max(2);
let current_failures = u32::from(device.communication_failures);
let previous_failures = u32::from(previous_failures);
if current_failures >= threshold && previous_failures < threshold {
state.log("warn", "device.offline", &format!("{} did not respond {} times in a row", device.name, device.communication_failures), json!({
"device_id": device.id, "consecutive_failures": device.communication_failures, "threshold": threshold
}));
} else if current_failures == 0 && previous_failures >= threshold {
state.log("info", "device.recovered", &format!("{} is responding again", device.name), json!({"device_id": device.id}));
}
}
fn simulate_tick(device: &mut Device) {
let mut current = device.current_temperature.unwrap_or(25.0);
let minute_wave = ((Utc::now().timestamp() % 3600) as f64 / 3600.0 * std::f64::consts::TAU).sin();
let ambient = 25.5 + minute_wave * 0.35;
if device.power {
match device.mode.as_str() {
"cool" => {
let floor = device.target_temperature - 0.2;
if current > floor { current -= if device.turbo { 0.25 } else { 0.12 }; }
}
"heat" => {
let ceiling = device.target_temperature + 0.2;
if current < ceiling { current += if device.turbo { 0.25 } else { 0.12 }; }
}
"dry" => current -= 0.04,
_ => current += (ambient - current) * 0.02,
}
} else {
current += (ambient - current) * 0.04;
}
device.current_temperature = Some((current * 10.0).round() / 10.0);
device.outdoor_temperature = Some((30.0 + minute_wave * 1.2) * 10.0_f64.round() / 10.0);
// Correct rounding for outdoor temperature without accumulating precision noise.
device.outdoor_temperature = device.outdoor_temperature.map(|v| (v * 10.0).round() / 10.0);
device.online = true;
device.response_time_ms = Some(0);
device.last_seen = Some(Utc::now());
device.last_error = None;
device.updated_at = Utc::now();
}
fn record_reading(state: &AppState, device: &Device) -> Result<()> {
let reading = Reading {
id: 0,
device_id: device.id.clone(),
timestamp: Utc::now(),
indoor_temperature: device.current_temperature,
outdoor_temperature: device.outdoor_temperature,
target_temperature: device.target_temperature,
power: device.power,
source: if device.simulated { "simulator".into() } else { "gree".into() },
};
state.db.add_reading(&reading)?;
queue_influx_device(state, reading);
Ok(())
}
fn record_poll_failure(device: &mut Device, error: &str) {
device.communication_failures = device.communication_failures.saturating_add(1);
// A single dropped UDP response is not enough to declare an AC offline.
if device.communication_failures >= 3 { device.online = false; }
device.last_error = Some(error.to_string());
device.updated_at = Utc::now();
}
fn register_device_failure(state: &AppState, device: &mut Device, error: &str) -> Result<(), AppError> {
record_poll_failure(device, error);
state.db.save_device(device)?;
state.log("warn", "device.communication_error", &format!("{}: {error}", device.name), json!({
"device_id": device.id,
"consecutive_failures": device.communication_failures,
"offline": !device.online,
}));
Ok(())
}
pub(crate) fn validate_command(command: &DeviceCommand) -> Result<(), AppError> {
if let Some(value) = command.target_temperature {
if !(8.0..=30.0).contains(&value) { return Err(AppError::BadRequest("target temperature must be between 8 and 30 C".into())); }
}
if let Some(value) = command.fan_speed {
if value > 5 { return Err(AppError::BadRequest("fan speed must be between 0 and 5".into())); }
}
if let Some(value) = &command.mode {
if !matches!(value.as_str(), "auto" | "cool" | "dry" | "fan" | "heat") {
return Err(AppError::BadRequest("unsupported HVAC mode".into()));
}
}
Ok(())
}
fn poll_completed_successfully(device: &Device) -> bool {
device.online && device.communication_failures == 0 && device.last_error.is_none()
}
fn command_manual_control_fields(command: &DeviceCommand) -> Vec<String> {
let mut fields = Vec::new();
if command.power.is_some() { fields.push("power".to_string()); }
if command.mode.is_some() { fields.push("mode".to_string()); }
if command.target_temperature.is_some() { fields.push("target_temperature".to_string()); }
if command.fan_speed.is_some() { fields.push("fan_speed".to_string()); }
if command.quiet.is_some() { fields.push("quiet".to_string()); }
if command.sleep.is_some() { fields.push("sleep".to_string()); }
fields
}
fn command_baseline_from_device(command: &DeviceCommand, device: &Device) -> DeviceCommand {
DeviceCommand {
power: command.power.map(|_| device.power),
mode: command.mode.as_ref().map(|_| device.mode.clone()),
target_temperature: command.target_temperature.map(|_| device.target_temperature),
fan_speed: command.fan_speed.map(|_| device.fan_speed),
quiet: command.quiet.map(|_| device.quiet),
sleep: command.sleep.map(|_| device.sleep),
..Default::default()
}
}
async fn remember_controller_command(state: &AppState, device_id: &str, command: &DeviceCommand, baseline_device: &Device) {
let poll_seconds = state.settings.read().await.poll_interval_seconds.max(2);
let ttl = Duration::from_secs(poll_seconds.saturating_mul(2).saturating_add(5).min(120));
let mut pending = state.pending_controller_commands.lock().await;
let expires_at = Instant::now() + ttl;
let baseline = command_baseline_from_device(command, baseline_device);
if let Some(existing) = pending.get_mut(device_id) {
existing.commands.push(command.clone());
existing.baselines.push(baseline);
// The history only spans one settling window; cap it defensively so a noisy device
// cannot grow this allocation without bound.
if existing.commands.len() > 8 { existing.commands.remove(0); }
if existing.baselines.len() > 8 { existing.baselines.remove(0); }
existing.expires_at = expires_at;
} else {
pending.insert(device_id.to_string(), PendingControllerCommand {
commands: vec![command.clone()],
baselines: vec![baseline],
expires_at,
});
}
}
fn command_field_matches_device(command: &DeviceCommand, field: &str, device: &Device) -> bool {
match field {
"power" => command.power.map(|value| value == device.power).unwrap_or(false),
"mode" => command.mode.as_deref().map(|value| value == device.mode.as_str()).unwrap_or(false),
"target_temperature" => command.target_temperature
.map(|value| value.clamp(8.0, 30.0).round() == device.target_temperature.clamp(8.0, 30.0).round())
.unwrap_or(false),
"fan_speed" => command.fan_speed.map(|value| value.min(5) == device.fan_speed).unwrap_or(false),
"quiet" => command.quiet.map(|value| value == device.quiet).unwrap_or(false),
"sleep" => command.sleep.map(|value| value == device.sleep).unwrap_or(false),
_ => false,
}
}
async fn suppress_expected_controller_changes(
state: &AppState,
device: &Device,
fields: Vec<String>,
) -> Vec<String> {
if fields.is_empty() { return fields; }
let mut pending = state.pending_controller_commands.lock().await;
let expired = pending.get(&device.id)
.map(|expected| Instant::now() > expected.expires_at)
.unwrap_or(false);
if expired {
pending.remove(&device.id);
return fields;
}
let Some(expected) = pending.get(&device.id).cloned() else { return fields; };
let filtered = fields.into_iter()
.filter(|field| {
let matches_recent_controller_state = expected.commands.iter()
.chain(expected.baselines.iter())
.any(|command| command_field_matches_device(command, field, device));
!matches_recent_controller_state
})
.collect();
// Do not clear the settling guard merely because one poll matched the requested state.
// A later status packet can still briefly roll back to the pre-command snapshot. The
// bounded TTL is what ends this ambiguity window.
filtered
}
fn externally_changed_control_fields(before: &Device, after: &Device, zone: &Zone) -> Vec<String> {
let mut fields = Vec::new();
if before.power != after.power { fields.push("power".to_string()); }
if before.mode != after.mode { fields.push("mode".to_string()); }
if before.target_temperature.round() != after.target_temperature.round() {
fields.push("target_temperature".to_string());
}
// Some GREE units accept the controller's standby Low fan hint and later report Auto
// again without user interaction. Treat that one known normalization as firmware drift,
// not as a remote-control takeover. Other fan changes remain meaningful manual input.
let standby_low_to_auto = zone.smart_fan && !zone.demand && before.fan_speed == 1 && after.fan_speed == 0;
if before.fan_speed != after.fan_speed && !standby_low_to_auto {
fields.push("fan_speed".to_string());
}
fields
}
pub const LOCAL_THERMOSTAT_RESUME_DELAY_MINUTES: i64 = 15;
/// Apply local quick-thermostat power ownership and keep the automatic hand-back
/// deadline in one backend-owned place. Every fresh OFF action receives a fresh
/// deadline; ON cancels any pending hand-back.
pub fn set_local_thermostat_power(zone: &mut Zone, power: bool, now: DateTime<Utc>) -> bool {
let resume_at = if power {
None
} else {
Some(now + chrono::Duration::minutes(LOCAL_THERMOSTAT_RESUME_DELAY_MINUTES))
};
let changed = zone.local_thermostat_power != Some(power)
|| zone.local_thermostat_resume_at != resume_at;
zone.local_thermostat_power = Some(power);
zone.local_thermostat_resume_at = resume_at;
changed
}
/// Re-arm a local-OFF hand-back after a temporary direct/manual device takeover.
/// The countdown must start from the moment that manual control ends, not from the
/// older OFF action that happened before the takeover.
fn rearm_local_thermostat_resume(zone: &mut Zone, now: DateTime<Utc>) -> bool {
if zone.local_thermostat_power != Some(false) { return false; }
set_local_thermostat_power(zone, false, now)
}
fn local_thermostat_handback_is_active(zone: &Zone) -> bool {
zone.local_thermostat_power == Some(false) && !zone.device_manual_override
}
pub fn reset_local_thermostat_override(zone: &mut Zone) -> bool {
let changed = zone.local_thermostat_power.is_some()
|| zone.local_thermostat_resume_at.is_some()
|| zone.manual_preset.is_some()
|| zone.manual_setpoint.is_some()
|| zone.manual_override_until.is_some();
zone.local_thermostat_power = None;
zone.local_thermostat_resume_at = None;
zone.manual_preset = None;
zone.manual_setpoint = None;
zone.manual_override_until = None;
changed
}
fn expire_local_thermostat_overrides(state: &AppState, zones: &mut [Zone], schedules: &[Schedule], house_mode: &str) -> Result<(), AppError> {
let now = Utc::now();
for zone in zones.iter_mut() {
// A direct device/pilot takeover has higher priority than the local-OFF hand-back.
// Do not let the old timer expire underneath someone who is actively controlling
// the unit. When that takeover ends and the device returns to OFF, the deadline is
// re-armed from that moment.
if !local_thermostat_handback_is_active(zone) { continue; }
if zone.local_thermostat_resume_at.is_none() {
// Upgrade safety for a persisted 0.7.10/0.7.11 local-OFF state: old releases
// had no hand-back deadline, so start one from the first cycle after upgrade.
set_local_thermostat_power(zone, false, now.clone());
zone.updated_at = now.clone();
state.db.save_zone(zone)?;
state.broadcast("zone.updated", serde_json::to_value(&*zone)?);
state.log("info", "zone.local_thermostat_resume_scheduled", &format!("Local thermostat hand-back scheduled for {}", zone.name), json!({
"zone_id": zone.id, "device_id": zone.device_id, "delay_minutes": LOCAL_THERMOSTAT_RESUME_DELAY_MINUTES
}));
continue;
}
let expired = zone.local_thermostat_resume_at.as_ref().map(|at| at <= &now).unwrap_or(false);
if !expired { continue; }
reset_local_thermostat_override(zone);
refresh_zone_runtime_target(zone, schedules, house_mode);
zone.updated_at = now.clone();
state.db.save_zone(zone)?;
state.broadcast("zone.updated", serde_json::to_value(&*zone)?);
state.log("info", "zone.local_thermostat_resumed", &format!("Local thermostat hand-back completed for {}", zone.name), json!({
"zone_id": zone.id, "device_id": zone.device_id, "delay_minutes": LOCAL_THERMOSTAT_RESUME_DELAY_MINUTES
}));
}
Ok(())
}
fn next_local_thermostat_resume_delay(state: &AppState) -> Result<Option<Duration>, AppError> {
let now = Utc::now();
Ok(state.db.list_zones()?.into_iter()
.filter(local_thermostat_handback_is_active)
.filter_map(|zone| zone.local_thermostat_resume_at)
.map(|at| (at - now.clone()).to_std().unwrap_or(Duration::ZERO))
.min())
}
pub fn reset_device_manual_override(zone: &mut Zone) -> bool {
let changed = zone.device_manual_override
|| zone.device_manual_override_since.is_some()
|| zone.device_manual_override_until.is_some()
|| !zone.device_manual_override_fields.is_empty()
|| zone.device_manual_override_baseline.is_some();
zone.device_manual_override = false;
zone.device_manual_override_since = None;
zone.device_manual_override_until = None;
zone.device_manual_override_fields.clear();
zone.device_manual_override_baseline = None;
changed
}
fn manual_override_matches_baseline(zone: &Zone, device: &Device) -> bool {
let Some(baseline) = zone.device_manual_override_baseline.as_ref() else { return false; };
if zone.device_manual_override_fields.is_empty() { return false; }
// If the unit was OFF before takeover, returning it to OFF is operationally the same
// controller state even if the remote retained a different mode/target internally.
// Those dormant values will be set explicitly if automation later powers the unit.
if !baseline.power { return !device.power; }
zone.device_manual_override_fields.iter().all(|field| match field.as_str() {
"power" => device.power == baseline.power,
"mode" => device.mode == baseline.mode,
"target_temperature" => device.target_temperature.round() == baseline.target_temperature.round(),
"fan_speed" => device.fan_speed == baseline.fan_speed,
"quiet" => device.quiet == baseline.quiet,
"sleep" => device.sleep == baseline.sleep,
_ => false,
})
}
fn persist_manual_override_clear(state: &AppState, zone: &mut Zone, source: &str, restored: bool) -> Result<bool, AppError> {
if !reset_device_manual_override(zone) { return Ok(false); }
let now = Utc::now();
let local_resume_rearmed = restored && rearm_local_thermostat_resume(zone, now.clone());
zone.updated_at = now;
state.db.save_zone(zone)?;
state.broadcast("zone.updated", serde_json::to_value(&*zone)?);
let (kind, message) = if restored {
("zone.device_manual_override_restored", format!("Manual device control returned {} to its previous state", zone.name))
} else {
("zone.device_manual_override_cleared", format!("Manual device control ended for {}", zone.name))
};
state.log("info", kind, &message, json!({
"zone_id": zone.id, "device_id": zone.device_id, "source": source,
"local_thermostat_resume_rearmed": local_resume_rearmed,
"local_thermostat_resume_at": zone.local_thermostat_resume_at,
}));
Ok(true)
}
fn set_device_manual_override(state: &AppState, zone: &mut Zone, fields: Vec<String>, source: &str, baseline: &Device) -> Result<(), AppError> {
if fields.is_empty() { return Ok(()); }
let now = Utc::now();
if !zone.device_manual_override {
zone.device_manual_override_since = Some(now);
zone.device_manual_override_baseline = Some(baseline.into());
}
zone.device_manual_override = true;
zone.device_manual_override_until = if zone.enabled {
next_schedule_boundary_utc(&zone.id, &state.db.list_schedules()?, Local::now())
} else {
None
};
for field in fields {
if !zone.device_manual_override_fields.iter().any(|existing| existing == &field) {
zone.device_manual_override_fields.push(field);
}
}
zone.demand = false;
zone.demand_since = None;
zone.updated_at = now;
state.db.save_zone(zone)?;
state.broadcast("zone.updated", serde_json::to_value(&*zone)?);
state.log("info", "zone.device_manual_override", &format!("Manual device control detected for {}", zone.name), json!({
"zone_id": zone.id,
"device_id": zone.device_id,
"fields": zone.device_manual_override_fields,
"source": source,
"override_until": zone.device_manual_override_until,
}));
Ok(())
}
async fn detect_external_device_control(state: &AppState, before: &Device, after: &Device) -> Result<(), AppError> {
if before.id != after.id { return Ok(()); }
for mut zone in state.db.list_zones()?.into_iter().filter(|zone| zone.device_id == after.id) {
let fields = suppress_expected_controller_changes(
state,
after,
externally_changed_control_fields(before, after, &zone),
).await;
if zone.device_manual_override && manual_override_matches_baseline(&zone, after) {
persist_manual_override_clear(state, &mut zone, "gree_poll", true)?;
continue;
}
if fields.is_empty() { continue; }
// A disabled zone is outside controller ownership. When its manually operated unit is
// switched off there is no takeover left to display or remember.
if !zone.enabled && !after.power {
persist_manual_override_clear(state, &mut zone, "gree_poll", false)?;
continue;
}
set_device_manual_override(state, &mut zone, fields, "gree_poll", before)?;
}
Ok(())
}
pub async fn send_manual_command(state: &AppState, device_id: &str, command: DeviceCommand, source: &str) -> Result<Device, AppError> {
// Keep the device lock until the zone takeover marker is persisted. Otherwise a poll
// could observe our own just-sent command before the controller records manual ownership.
let _device_guard = state.lock_device_operation(device_id).await;
let before = state.db.get_device(device_id)?
.ok_or_else(|| AppError::NotFound(format!("device {device_id}")))?;
let effective_command = if before.online && before.communication_failures == 0 { command.changed_from(&before) } else { command.clone() };
let fields = command_manual_control_fields(&effective_command);
let updated = send_command_locked_inner(state, device_id, command, true, false).await?;
if !fields.is_empty() {
for mut zone in state.db.list_zones()?.into_iter().filter(|zone| zone.device_id == device_id) {
if zone.device_manual_override && manual_override_matches_baseline(&zone, &updated) {
persist_manual_override_clear(state, &mut zone, source, true)?;
continue;
}
if !zone.enabled && !updated.power {
persist_manual_override_clear(state, &mut zone, source, false)?;
continue;
}
set_device_manual_override(state, &mut zone, fields.clone(), source, &before)?;
}
}
Ok(updated)
}
pub async fn force_house_power_off_device(state: &AppState, device_id: &str, source: &str) -> Result<Device, AppError> {
// Global OFF is a one-shot authority transition. Clear takeover and send OFF while
// polling for this unit is excluded; a later remote change happens after the lock and
// is therefore preserved as a new manual takeover.
let _device_guard = state.lock_device_operation(device_id).await;
for mut zone in state.db.list_zones()?.into_iter().filter(|zone| zone.device_id == device_id) {
if !reset_device_manual_override(&mut zone) { continue; }
zone.updated_at = Utc::now();
state.db.save_zone(&zone)?;
state.broadcast("zone.updated", serde_json::to_value(&zone)?);
state.log("info", "zone.device_manual_override_cleared", &format!("Automation resumed for {}", zone.name), json!({
"zone_id": zone.id, "device_id": zone.device_id, "source": source
}));
}
send_command_locked_forced(state, device_id, DeviceCommand { power: Some(false), ..Default::default() }).await
}
pub async fn force_power_off_device(state: &AppState, device_id: &str) -> Result<Device, AppError> {
let _device_guard = state.lock_device_operation(device_id).await;
send_command_locked_forced(state, device_id, DeviceCommand { power: Some(false), ..Default::default() }).await
}
pub fn clear_all_device_manual_overrides(state: &AppState, source: &str) -> Result<usize, AppError> {
let mut cleared = 0usize;
for mut zone in state.db.list_zones()? {
if !reset_device_manual_override(&mut zone) { continue; }
zone.updated_at = Utc::now();
state.db.save_zone(&zone)?;
state.broadcast("zone.updated", serde_json::to_value(&zone)?);
state.log("info", "zone.device_manual_override_cleared", &format!("Automation resumed for {}", zone.name), json!({
"zone_id": zone.id, "device_id": zone.device_id, "source": source
}));
cleared += 1;
}
Ok(cleared)
}
pub async fn control_group(state: &AppState, group_id: &str, patch: GroupControlPatch, source: &str) -> Result<Value, AppError> {
if let Some(mode) = patch.mode.as_deref() {
if !matches!(mode, "house" | "auto" | "cool" | "heat") {
return Err(AppError::BadRequest("group mode must be house, cool or heat".into()));
}
}
if let Some(preset) = patch.preset.as_deref() {
if !matches!(preset, "auto" | "comfort" | "sleep" | "away") {
return Err(AppError::BadRequest("group preset must be auto, comfort, sleep or away".into()));
}
}
let mut group = state.db.get_group(group_id)?
.ok_or_else(|| AppError::NotFound(format!("group {group_id}")))?;
let schedules = state.db.list_schedules()?;
let activates_group = patch.mode.is_some() || patch.preset.is_some();
if let Some(power) = patch.power {
group.power_enabled = power;
} else if activates_group {
group.power_enabled = true;
}
group.updated_at = Utc::now();
state.db.save_group(&group)?;
state.broadcast("group.updated", serde_json::to_value(&group)?);
// Explicit group ON is a conscious request to run this group. Resume the global
// master without changing the gates of any other groups. This makes group ON work
// even after a previous whole-house OFF while preserving multi-group OFF priority.
if patch.power == Some(true) {
let mut settings = state.settings.write().await;
if !settings.house_power_enabled {
settings.house_power_enabled = true;
state.db.save_runtime_settings(&settings)?;
state.broadcast("house.power_changed", json!({"house_power_enabled": true}));
state.log("info", "house.power_resumed_by_group", &format!("Whole-house master resumed by group {}", group.name), json!({
"group_id": group.id, "source": source
}));
}
}
let mut zones = Vec::new();
for zone_id in &group.zone_ids {
let Some(mut zone) = state.db.get_zone(zone_id)? else { continue; };
if let Some(mode) = patch.mode.as_deref() {
match mode {
"house" | "auto" => zone.inherit_house_mode = true,
"cool" | "heat" => {
zone.inherit_house_mode = false;
zone.mode = mode.to_string();
}
_ => {}
}
}
if let Some(preset) = patch.preset.as_deref() {
if preset == "auto" {
zone.manual_preset = None;
zone.manual_setpoint = None;
zone.manual_override_until = None;
} else {
zone.manual_preset = Some(preset.to_string());
zone.manual_setpoint = None;
zone.manual_override_until = next_schedule_boundary_utc(&zone.id, &schedules, Local::now());
}
}
zone.updated_at = Utc::now();
state.db.save_zone(&zone)?;
state.broadcast("zone.updated", serde_json::to_value(&zone)?);
zones.push(zone);
}
let runtime = state.settings.read().await.clone();
let master_power_enabled = runtime.house_power_enabled;
let should_command_power = patch.power.is_some() || activates_group;
let desired_power = group.power_enabled;
// A zone may intentionally belong to more than one group. Power-off is authoritative:
// turning one group on must never briefly wake a member that is still blocked by another group.
let mut failed = Vec::new();
if should_command_power && (!desired_power || master_power_enabled) {
let mut seen = std::collections::HashSet::new();
for zone in &zones {
if !seen.insert(zone.device_id.clone()) { continue; }
// Re-check manual takeover and all group gates only after acquiring the
// per-device lock, so a pilot event detected by polling cannot be overwritten.
let Some(device) = state.db.get_device(&zone.device_id)? else { continue; };
if !device.enabled { continue; }
match send_group_power_if_current(state, &group.id, &zone.id, &device.id, desired_power).await {
Ok(_) => {}
Err(err) => {
state.log("error", "group.power_error", &err.to_string(), json!({
"group_id": group.id, "device_id": device.id, "device_name": device.name,
"power": desired_power, "source": source,
}));
failed.push(json!({"device_id": device.id, "device_name": device.name, "error": err.to_string()}));
}
}
}
}
if desired_power && should_command_power {
state.wake_zone_control();
}
state.log("info", source, &format!("Updated group {}", group.name), json!({
"group_id": group.id, "power_enabled": group.power_enabled, "mode": patch.mode, "preset": patch.preset,
"zones": zones.len(), "failed": failed.len(), "master_power_enabled": master_power_enabled,
}));
Ok(json!({
"group": group,
"zones": zones,
"devices": state.db.list_devices()?,
"failed": failed,
"master_power_enabled": master_power_enabled,
}))
}
fn persist_zone_cycle(state: &AppState, computed: &Zone, cycle_started_at: DateTime<Utc>) -> Result<Zone, AppError> {
let Some(mut latest) = state.db.get_zone(&computed.id)? else { return Ok(computed.clone()); };
if latest.updated_at <= cycle_started_at {
state.db.save_zone(computed)?;
return Ok(computed.clone());
}
// Another actor changed this zone while the regulator was doing network I/O. Never
// write the old controller snapshot over fresh configuration or manual takeover state.
// Sensor observations are safe to carry forward only while the device assignment matches.
if latest.device_id == computed.device_id {
latest.device_temperature = computed.device_temperature;
latest.external_temperature = computed.external_temperature;
latest.current_temperature = computed.current_temperature;
latest.control_temperature_source = computed.control_temperature_source.clone();
latest.updated_at = Utc::now();
state.db.save_zone(&latest)?;
}
Ok(latest)
}
async fn thermostat_ownership_is_current(state: &AppState, zone_id: &str, device_id: &str) -> Result<bool, AppError> {
if !state.settings.read().await.house_power_enabled { return Ok(false); }
let Some(zone) = state.db.get_zone(zone_id)? else { return Ok(false); };
if zone.device_id != device_id || !zone.enabled || zone.device_manual_override || zone.local_thermostat_power == Some(false) { return Ok(false); }
if zone.local_thermostat_power == Some(true) { return Ok(true); }
let blocked = state.db.list_groups()?.iter().any(|group| {
!group.power_enabled && group.zone_ids.iter().any(|member| member == zone_id)
});
Ok(!blocked)
}
async fn group_off_ownership_is_current(state: &AppState, zone_id: &str, device_id: &str) -> Result<bool, AppError> {
if !state.settings.read().await.house_power_enabled { return Ok(false); }
let Some(zone) = state.db.get_zone(zone_id)? else { return Ok(false); };
if zone.device_id != device_id || !zone.enabled || zone.device_manual_override || zone.local_thermostat_power.is_some() { return Ok(false); }
Ok(state.db.list_groups()?.iter().any(|group| {
!group.power_enabled && group.zone_ids.iter().any(|member| member == zone_id)
}))
}
async fn send_zone_command_if_owned(
state: &AppState,
zone_id: &str,
device_id: &str,
command: DeviceCommand,
require_group_block: bool,
) -> Result<Option<Device>, AppError> {
// Ownership must be checked after acquiring the same per-device lock used by polling.
// Otherwise polling could detect a remote takeover while this task is waiting for the lock,
// and a stale thermostat decision would still be sent immediately afterwards.
let _device_guard = state.lock_device_operation(device_id).await;
let owned = if require_group_block {
group_off_ownership_is_current(state, zone_id, device_id).await?
} else {
thermostat_ownership_is_current(state, zone_id, device_id).await?
};
if !owned { return Ok(None); }
send_command_locked(state, device_id, command).await.map(Some)
}
async fn send_group_power_if_current(
state: &AppState,
group_id: &str,
zone_id: &str,
device_id: &str,
desired_power: bool,
) -> Result<Option<Device>, AppError> {
let _device_guard = state.lock_device_operation(device_id).await;
let Some(zone) = state.db.get_zone(zone_id)? else { return Ok(None); };
if zone.device_id != device_id || !zone.enabled || zone.device_manual_override || zone.local_thermostat_power.is_some() { return Ok(None); }
let groups = state.db.list_groups()?;
let Some(group) = groups.iter().find(|group| group.id == group_id) else { return Ok(None); };
if group.power_enabled != desired_power || !group.zone_ids.iter().any(|member| member == zone_id) { return Ok(None); }
if desired_power {
let settings = state.settings.read().await;
if !settings.house_power_enabled { return Ok(None); }
let effective_mode = if zone.inherit_house_mode { settings.house_mode.as_str() } else { zone.mode.as_str() };
if effective_mode == "off" { return Ok(None); }
if groups.iter().any(|other| {
other.id != group_id && !other.power_enabled && other.zone_ids.iter().any(|member| member == zone_id)
}) {
return Ok(None);
}
}
let Some(device) = state.db.get_device(device_id)? else { return Ok(None); };
if !device.enabled { return Ok(None); }
let command = DeviceCommand { power: Some(desired_power), ..Default::default() };
if desired_power {
send_command_locked(state, device_id, command).await.map(Some)
} else {
// A deliberate group OFF is a one-shot safety transition. Send it even if the
// cached state already says OFF; the regulator itself will not keep repeating it.
send_command_locked_forced(state, device_id, command).await.map(Some)
}
}
async fn send_automatic_device_command_if_owned(
state: &AppState,
device_id: &str,
command: DeviceCommand,
) -> Result<Option<Device>, AppError> {
let _device_guard = state.lock_device_operation(device_id).await;
if !state.settings.read().await.house_power_enabled { return Ok(None); }
let zones = state.db.list_zones()?;
if device_blocked_by_disabled_zone(device_id, &zones)
|| device_blocked_by_manual_override(device_id, &zones)
|| device_blocked_by_local_thermostat(device_id, &zones)
|| device_blocked_by_disabled_group(device_id, &zones, &state.db.list_groups()?)
{
return Ok(None);
}
send_command_locked(state, device_id, command).await.map(Some)
}
async fn control_zones(state: &AppState) -> Result<()> {
let schedules = state.db.list_schedules()?;
let groups = state.db.list_groups()?;
let settings = state.settings.read().await.clone();
let mut zone_snapshot = state.db.list_zones()?;
// Local quick-thermostat OFF is intentionally temporary. Expire the ownership marker
// before the house-power early return so the hand-back still happens while the master
// is off; no physical state is restored here, only automation ownership.
expire_local_thermostat_overrides(state, &mut zone_snapshot, &schedules, &settings.house_mode)?;
// Outdoor temperature is deliberately optional. Prefer the configured Home
// Assistant entity, but keep the dashboard/assist useful by falling back to the
// outdoor sensors reported by GREE units when HA is temporarily unavailable.
let device_snapshot = state.db.list_devices()?;
let configured_outdoor = settings.home_assistant.outdoor_entity_id.trim();
let resolved_outdoor = if configured_outdoor.is_empty() {
None
} else {
home_assistant::resolve_entity_id(&settings.home_assistant, Some(configured_outdoor))
};
let ha_outdoor_temperature = if let Some(entity_id) = resolved_outdoor.as_deref() {
match home_assistant::read_temperature(&state.http, &settings.home_assistant, Some(entity_id)).await {
Ok(value) => {
record_ha_history(
state,
entity_id,
None,
"outdoor",
value,
settings.poll_interval_seconds,
);
Some(value)
}
Err(err) => {
tracing::debug!(configured_entity=%configured_outdoor, resolved_entity=%entity_id, error=?err, "outdoor Home Assistant sensor unavailable; trying GREE fallback");
None
}
}
} else {
None
};
let outdoor_temperature = ha_outdoor_temperature.or_else(|| gree_outdoor_temperature(&device_snapshot));
{
let mut current = state.outdoor_temperature.write().await;
if *current != outdoor_temperature {
*current = outdoor_temperature;
state.broadcast("outdoor.updated", json!({"temperature": outdoor_temperature}));
}
}
let outdoor_assist_temperature = if settings.outdoor_assist_enabled { outdoor_temperature } else { None };
let night_active = night_mode_active(&settings.night_mode, Local::now().time());
if !settings.house_power_enabled {
// Whole-house OFF is a one-shot action performed by the API endpoint. While the
// master remains off the regulator stays passive. A later physical/remote change
// is therefore detected as manual takeover and is not erased or forced OFF again.
return Ok(());
}
// Read all per-zone Home Assistant sensors concurrently. A down HA instance should cost
// one request timeout per cycle, not one timeout multiplied by the number of zones.
let room_sensor_reads = futures_util::future::join_all(zone_snapshot.iter().filter_map(|zone| {
if !matches!(zone.sensor_source.as_str(), "home_assistant" | "combined") { return None; }
let zone_id = zone.id.clone();
let resolved_entity = home_assistant::resolve_entity_id(&settings.home_assistant, zone.ha_entity_id.as_deref());
let http = &state.http;
let ha_settings = &settings.home_assistant;
Some(async move {
let result = home_assistant::read_temperature(http, ha_settings, resolved_entity.as_deref()).await
.map_err(|err| err.to_string());
(zone_id, resolved_entity, result)
})
})).await;
let mut room_sensor_results: HashMap<String, (Option<String>, Result<f64, String>)> = room_sensor_reads.into_iter()
.map(|(zone_id, entity_id, result)| (zone_id, (entity_id, result)))
.collect();
for mut zone in zone_snapshot {
let cycle_started_at = zone.updated_at;
if zone.manual_override_until.map(|until| until <= Utc::now()).unwrap_or(false) {
zone.manual_preset = None;
zone.manual_setpoint = None;
zone.manual_override_until = None;
}
if zone.device_manual_override_until.map(|until| until <= Utc::now()).unwrap_or(false) {
reset_device_manual_override(&mut zone);
state.log("info", "zone.device_manual_override_expired", &format!("Manual device control expired for {} at schedule transition", zone.name), json!({
"zone_id": zone.id, "device_id": zone.device_id
}));
}
let Some(device) = state.db.get_device(&zone.device_id)? else {
state.log("error", "zone.device_missing", &format!("Zone {} has no device", zone.name), json!({"zone_id": zone.id}));
continue;
};
// House "off" means the smart thermostat does not control inherited zones.
// A zone explicitly switched to heat/cool remains independent and may still run.
let effective_mode = if zone.inherit_house_mode {
settings.house_mode.as_str()
} else {
zone.mode.as_str()
};
zone.effective_mode = effective_mode.to_string();
let previous_source = zone.control_temperature_source.clone();
// Never feed the thermostat a cached GREE temperature after any communication
// failure. External HA sensors may still keep a zone operational when configured.
let device_temperature = if device.enabled && device.online && device.communication_failures == 0 {
device.current_temperature
} else {
None
};
let external_temperature = if matches!(zone.sensor_source.as_str(), "home_assistant" | "combined") {
match room_sensor_results.remove(&zone.id) {
Some((resolved_entity, Ok(value))) => {
if let Some(entity_id) = resolved_entity.as_deref() {
record_ha_history(state, entity_id, Some(&zone.id), "room", value, settings.poll_interval_seconds);
}
Some(value)
}
Some((resolved_entity, Err(err))) => {
if !matches!(previous_source.as_str(), "device_fallback" | "device_discrepancy_fallback") {
state.log("warn", "ha.sensor_error", &err, json!({
"zone_id": zone.id,
"configured_entity_id": zone.ha_entity_id.as_deref(),
"resolved_entity_id": resolved_entity,
}));
}
None
}
None => None,
}
} else {
None
};
let (temperature, control_source, discrepancy) = select_zone_temperature(&zone, device_temperature, external_temperature);
zone.device_temperature = device_temperature;
zone.external_temperature = external_temperature;
zone.current_temperature = temperature;
zone.control_temperature_source = control_source;
zone.updated_at = Utc::now();
// A disabled thermostat zone is completely outside normal controller ownership.
// Keep its sensors fresh, but do not let group state, schedules or thermostat
// modulation touch the unit. Manual control from the technical Devices view may
// therefore remain active until the zone is explicitly enabled again.
if !zone.enabled {
zone.demand = false;
zone.demand_since = None;
record_zone_history(state, &zone, outdoor_temperature, settings.poll_interval_seconds);
let persisted_zone = persist_zone_cycle(state, &zone, cycle_started_at)?;
state.broadcast("zone.updated", serde_json::to_value(&persisted_zone)?);
continue;
}
// A technically disabled device is outside thermostat ownership. Do not create
// repeated command errors while keeping any available external sensor data visible.
if !device.enabled {
zone.demand = false;
zone.demand_since = None;
zone.device_setpoint = None;
record_zone_history(state, &zone, outdoor_temperature, settings.poll_interval_seconds);
let persisted_zone = persist_zone_cycle(state, &zone, cycle_started_at)?;
state.broadcast("zone.updated", serde_json::to_value(&persisted_zone)?);
continue;
}
// A physical/manual takeover has higher priority than thermostat, schedule, group and
// automation control. Continue sensor/history updates, but reflect the unit's real state
// instead of sending corrective frames that would fight the person holding the remote.
if zone.device_manual_override {
// Manual/remote takeover pauses commands, but it must not erase the thermostat's
// selected profile/target. Keep the intended target visible and report the physical
// unit target separately through device_setpoint. This makes Resume/Profile actions
// deterministic and avoids a standby device target (for example 25 C) masquerading
// as the zone's Sleep/Comfort target.
let target_mode = if effective_mode == "off" { zone.mode.as_str() } else { effective_mode };
let active_schedule = active_schedule_for_zone(&zone, &schedules, Local::now());
let (preset, target) = resolve_zone_target(&zone, active_schedule, target_mode);
zone.active_preset = preset;
zone.effective_setpoint = Some(target);
// Keep effective_mode's existing meaning during takeover: it reflects the physical
// unit, while effective_setpoint above remains the thermostat intent.
zone.effective_mode = if device.power { device.mode.clone() } else { "off".into() };
zone.device_setpoint = if device.power { Some(device.target_temperature) } else { None };
zone.demand = false;
zone.demand_since = None;
zone.target_alerted_at = None;
record_zone_history(state, &zone, outdoor_temperature, settings.poll_interval_seconds);
let persisted_zone = persist_zone_cycle(state, &zone, cycle_started_at)?;
state.broadcast("zone.updated", serde_json::to_value(&persisted_zone)?);
continue;
}
if zone.local_thermostat_power == Some(false) {
zone.effective_mode = "off".into();
zone.demand = false;
zone.demand_since = None;
zone.device_setpoint = None;
if device.online && device.communication_failures == 0 && device.power {
let _device_guard = state.lock_device_operation(&zone.device_id).await;
let latest = state.db.get_zone(&zone.id)?;
if latest.as_ref().map(|item| item.local_thermostat_power == Some(false) && !item.device_manual_override).unwrap_or(false) {
if let Err(err) = send_command_locked(
state,
&zone.device_id,
DeviceCommand { power: Some(false), ..Default::default() },
).await {
state.log("error", "zone.local_power_error", &err.to_string(), json!({"zone_id": zone.id, "device_id": zone.device_id}));
}
}
}
record_zone_history(state, &zone, outdoor_temperature, settings.poll_interval_seconds);
let persisted_zone = persist_zone_cycle(state, &zone, cycle_started_at)?;
state.broadcast("zone.updated", serde_json::to_value(&persisted_zone)?);
continue;
}
let blocked_by_group = zone.local_thermostat_power != Some(true)
&& groups.iter().any(|group| !group.power_enabled && group.zone_ids.iter().any(|zone_id| zone_id == &zone.id));
if blocked_by_group {
zone.effective_mode = "off".into();
zone.demand = false;
zone.demand_since = None;
zone.device_setpoint = None;
if device.online && device.communication_failures == 0 && device.power {
match send_zone_command_if_owned(
state,
&zone.id,
&zone.device_id,
DeviceCommand { power: Some(false), ..Default::default() },
true,
).await {
Ok(_) => {}
Err(err) => state.log("error", "group.power_error", &err.to_string(), json!({"zone_id": zone.id, "device_id": zone.device_id})),
}
}
record_zone_history(state, &zone, outdoor_temperature, settings.poll_interval_seconds);
let persisted_zone = persist_zone_cycle(state, &zone, cycle_started_at)?;
state.broadcast("zone.updated", serde_json::to_value(&persisted_zone)?);
continue;
}
if discrepancy && previous_source != "device_discrepancy_fallback" {
state.log("warn", "zone.sensor_discrepancy", &format!("Zone {} sensors differ by more than {:.1} C; using GREE sensor", zone.name, zone.max_sensor_difference), json!({
"zone_id": zone.id,
"device_temperature": zone.device_temperature,
"external_temperature": zone.external_temperature,
"max_difference": zone.max_sensor_difference,
"entity_id": zone.ha_entity_id.as_deref(),
}));
}
// House "off" is a no-control state, not a power-off command. Keep polling and
// publishing the zone, but never overwrite manual device state while it follows
// the house mode. Explicit per-zone heat/cool bypasses this branch above.
if effective_mode == "off" {
zone.effective_setpoint = None;
zone.device_setpoint = None;
zone.demand = false;
zone.demand_since = None;
zone.target_alerted_at = None;
record_zone_history(state, &zone, outdoor_temperature, settings.poll_interval_seconds);
let persisted_zone = persist_zone_cycle(state, &zone, cycle_started_at)?;
state.broadcast("zone.updated", serde_json::to_value(&persisted_zone)?);
continue;
}
let active_schedule = active_schedule_for_zone(&zone, &schedules, Local::now());
let (preset, target) = resolve_zone_target(&zone, active_schedule, effective_mode);
zone.active_preset = preset;
zone.effective_setpoint = Some(target);
let Some(temp) = temperature else {
record_zone_history(state, &zone, outdoor_temperature, settings.poll_interval_seconds);
let persisted_zone = persist_zone_cycle(state, &zone, cycle_started_at)?;
state.broadcast("zone.updated", serde_json::to_value(&persisted_zone)?);
continue;
};
let half = zone.hysteresis.max(0.1) / 2.0;
let previous_demand = zone.demand;
zone.demand = match effective_mode {
"heat" => {
if temp <= target - half { true }
else if temp >= target + half { false }
else { zone.demand }
}
_ => {
if temp >= target + half { true }
else if temp <= target - half { false }
else { zone.demand }
}
};
if zone.demand && !previous_demand {
zone.demand_since = Some(Utc::now());
zone.target_alerted_at = None;
} else if !zone.demand {
zone.demand_since = None;
zone.target_alerted_at = None;
}
if zone.demand && zone.target_alerted_at.is_none() {
let timeout_minutes = settings.notifications.target_timeout_minutes.max(5) as i64;
if let Some(since) = zone.demand_since {
if (Utc::now() - since).num_minutes() >= timeout_minutes {
state.log("warn", "zone.target_timeout", &format!("Zone {} has not reached {:.1} C within {} minutes", zone.name, target, timeout_minutes), json!({
"zone_id": zone.id, "room_temperature": temp, "target_temperature": target, "minutes": timeout_minutes
}));
zone.target_alerted_at = Some(Utc::now());
}
}
}
// Setpoint modulation: keep the indoor unit powered and let its own inverter/compressor
// stop naturally when we move the target to the satisfied side of room temperature.
let outdoor_assist = outdoor_assist_offset(effective_mode, outdoor_assist_temperature, temp, target);
// When an independent room sensor is actually driving cooling, the indoor unit's
// own sensor can satisfy too early. Apply a half-degree pre-rounding bias: because
// GREE setpoints are sent as whole degrees, this selects the next lower whole-degree
// target (0.5-1.0 C below the room target). Do not stack it with outdoor assist and
// do not use it during device/fallback control.
let room_sensor_assist = external_room_sensor_cooling_assist(effective_mode, &zone.control_temperature_source);
let demand_assist = outdoor_assist.max(room_sensor_assist);
let active_target = match effective_mode {
"heat" => target + outdoor_assist,
_ => target - demand_assist,
};
let standby_target = match effective_mode {
"heat" => target - zone.standby_offset_c.max(0.5),
_ => target + zone.standby_offset_c.max(0.5),
};
let desired_device_target = round_device_setpoint(effective_mode, zone.demand, if zone.demand { active_target } else { standby_target });
// Report only the last confirmed device state here. The desired target belongs to
// effective_setpoint/command planning until a device command succeeds.
zone.device_setpoint = if device.power { Some(device.target_temperature) } else { None };
let demand_changed = previous_demand != zone.demand;
let desired_fan = if night_active {
let max_fan = settings.night_mode.max_fan_speed.clamp(1, 5);
if zone.smart_fan {
Some(night_limited_fan_speed(
smart_fan_speed(effective_mode, temp, target, outdoor_assist_temperature, zone.demand),
max_fan,
))
} else if device.fan_speed == 0 || device.fan_speed > max_fan {
Some(max_fan)
} else {
Some(device.fan_speed)
}
} else if zone.smart_fan {
Some(smart_fan_speed(effective_mode, temp, target, outdoor_assist_temperature, zone.demand))
} else {
None
};
// When the room becomes satisfied, ask compatible units for Quiet in the same
// frame as the standby setpoint and Low fan. When demand returns, disable Quiet
// on the normal smart-fan transition. When scheduled night mode owns Quiet, it
// explicitly enables it inside the window and releases it outside the window.
let desired_quiet = smart_quiet_command(
zone.smart_fan,
state.gree.quiet_command_supported(&device.id),
previous_demand,
zone.demand,
device.quiet,
settings.night_mode.enabled,
night_active,
settings.night_mode.force_quiet,
);
let desired_sleep = native_sleep_command(
settings.night_mode.enabled,
night_active,
settings.night_mode.use_native_sleep,
device.supports_sleep == Some(true) && state.gree.sleep_command_supported(&device.id),
device.sleep,
);
let core_needs_command = !device.power
|| device.mode != effective_mode
|| (device.target_temperature - desired_device_target).abs() >= 0.5;
// In normal standby, Low fan is a transition hint rather than a state that should
// be reasserted forever. Some GREE firmwares accept the frame but later report Auto
// again; retrying every min_adjust_seconds only causes needless command beeps.
let fan_needs_command = desired_fan
.map(|fan| fan != device.fan_speed)
.unwrap_or(false)
&& (zone.demand || demand_changed || core_needs_command || night_active);
let needs_command = core_needs_command
|| fan_needs_command
|| desired_quiet.map(|quiet| quiet != device.quiet).unwrap_or(false)
|| desired_sleep.map(|sleep| sleep != device.sleep).unwrap_or(false);
let urgent_mode_change = !device.power || device.mode != effective_mode;
if needs_command && (urgent_mode_change || adjustment_allowed(&zone)) {
let command = DeviceCommand {
power: Some(true),
mode: Some(effective_mode.to_string()),
target_temperature: Some(desired_device_target),
fan_speed: if fan_needs_command { desired_fan } else { None },
quiet: desired_quiet,
sleep: desired_sleep,
..Default::default()
};
match send_zone_command_if_owned(state, &zone.id, &zone.device_id, command, false).await {
Ok(Some(updated_device)) => {
zone.device_setpoint = if updated_device.power { Some(updated_device.target_temperature) } else { None };
zone.last_action_at = Some(Utc::now());
state.log("info", "zone.setpoint_modulation", &format!("Zone {} -> {:.1} C ({})", zone.name, desired_device_target, if zone.demand { "demand" } else { "standby" }), json!({
"zone_id": zone.id,
"room_temperature": temp,
"comfort_target": target,
"device_target": desired_device_target,
"mode": effective_mode,
"preset": zone.active_preset,
"outdoor_temperature": outdoor_temperature,
"fan_speed": updated_device.fan_speed,
"quiet": updated_device.quiet,
"sleep": updated_device.sleep,
"night_mode": night_active,
}));
}
Ok(None) => {
record_zone_history(state, &zone, outdoor_temperature, settings.poll_interval_seconds);
let persisted_zone = persist_zone_cycle(state, &zone, cycle_started_at)?;
state.broadcast("zone.updated", serde_json::to_value(&persisted_zone)?);
continue;
}
Err(err) => state.log("error", "zone.action_error", &err.to_string(), json!({"zone_id": zone.id})),
}
}
record_zone_history(state, &zone, outdoor_temperature, settings.poll_interval_seconds);
let persisted_zone = persist_zone_cycle(state, &zone, cycle_started_at)?;
state.broadcast("zone.updated", serde_json::to_value(&persisted_zone)?);
}
Ok(())
}
fn record_zone_history(state: &AppState, zone: &Zone, outdoor_temperature: Option<f64>, poll_interval_seconds: u64) {
let device = match state.db.get_device(&zone.device_id) {
Ok(Some(device)) => device,
Ok(None) => return,
Err(err) => {
tracing::warn!(error=?err, zone_id=%zone.id, "cannot load device for zone history");
return;
}
};
let reading = ZoneReading {
id: 0,
zone_id: zone.id.clone(),
device_id: zone.device_id.clone(),
timestamp: Utc::now(),
gree_temperature: zone.device_temperature.or(device.current_temperature),
external_temperature: zone.external_temperature,
control_temperature: zone.current_temperature.or(zone.device_temperature).or(device.current_temperature),
target_temperature: zone.effective_setpoint.or(zone.manual_setpoint).or(Some(zone.setpoint)),
device_setpoint: zone.device_setpoint.or(Some(device.target_temperature)),
outdoor_temperature: outdoor_temperature.or(device.outdoor_temperature),
power: device.power,
mode: if zone.effective_mode.is_empty() { device.mode.clone() } else { zone.effective_mode.clone() },
fan_speed: device.fan_speed,
demand: zone.demand,
control_source: zone.control_temperature_source.clone(),
active_preset: zone.active_preset.clone(),
};
let interval = poll_interval_seconds.max(15) as i64;
match state.db.add_zone_reading_if_due(&reading, interval) {
Ok(true) => queue_influx_zone(state, reading),
Ok(false) => {}
Err(err) => tracing::warn!(error=?err, zone_id=%zone.id, "cannot save zone history sample"),
}
}
fn record_ha_history(
state: &AppState,
entity_id: &str,
zone_id: Option<&str>,
kind: &str,
temperature: f64,
poll_interval_seconds: u64,
) {
let reading = HaReading {
id: 0,
entity_id: entity_id.to_string(),
zone_id: zone_id.map(str::to_string),
kind: kind.to_string(),
timestamp: Utc::now(),
temperature,
};
let interval = poll_interval_seconds.max(15) as i64;
match state.db.add_ha_reading_if_due(&reading, interval) {
Ok(true) => queue_influx_ha(state, reading),
Ok(false) => {}
Err(err) => tracing::warn!(error=?err, entity_id=%entity_id, "cannot save Home Assistant history sample"),
}
}
fn queue_influx_device(state: &AppState, reading: Reading) {
let state = state.clone();
tokio::spawn(async move {
let settings = state.settings.read().await.influxdb.clone();
if !settings.enabled { return; }
if let Err(err) = influxdb::write_device(&state.http, &settings, &reading).await {
tracing::warn!(error=?err, device_id=%reading.device_id, "cannot write device metric to InfluxDB");
}
});
}
fn queue_influx_zone(state: &AppState, reading: ZoneReading) {
let state = state.clone();
tokio::spawn(async move {
let settings = state.settings.read().await.influxdb.clone();
if !settings.enabled { return; }
if let Err(err) = influxdb::write_zone(&state.http, &settings, &reading).await {
tracing::warn!(error=?err, zone_id=%reading.zone_id, "cannot write zone metric to InfluxDB");
}
});
}
fn queue_influx_ha(state: &AppState, reading: HaReading) {
let state = state.clone();
tokio::spawn(async move {
let settings = state.settings.read().await.influxdb.clone();
if !settings.enabled { return; }
if let Err(err) = influxdb::write_ha(&state.http, &settings, &reading).await {
tracing::warn!(error=?err, entity_id=%reading.entity_id, "cannot write HA metric to InfluxDB");
}
});
}
fn gree_outdoor_temperature(devices: &[Device]) -> Option<f64> {
let mut values: Vec<f64> = devices.iter()
.filter(|device| device.enabled && device.online && device.communication_failures == 0)
.filter_map(|device| device.outdoor_temperature)
.filter(|value| value.is_finite() && (-60.0..=70.0).contains(value))
.collect();
if values.is_empty() { return None; }
values.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
let middle = values.len() / 2;
let value = if values.len() % 2 == 0 {
(values[middle - 1] + values[middle]) / 2.0
} else {
values[middle]
};
Some((value * 10.0).round() / 10.0)
}
fn select_zone_temperature(zone: &Zone, device_temperature: Option<f64>, external_temperature: Option<f64>) -> (Option<f64>, String, bool) {
match zone.sensor_source.as_str() {
"home_assistant" => match (external_temperature, device_temperature) {
(Some(value), _) => (Some(value), "external".into(), false),
(None, Some(value)) => (Some(value), "device_fallback".into(), false),
(None, None) => (None, "unavailable".into(), false),
},
"combined" => match (device_temperature, external_temperature) {
(Some(device), Some(external)) => {
if (device - external).abs() > zone.max_sensor_difference.max(0.1) {
(Some(device), "device_discrepancy_fallback".into(), true)
} else {
let external_weight = zone.external_sensor_weight.clamp(0.0, 1.0);
let value = device * (1.0 - external_weight) + external * external_weight;
(Some((value * 10.0).round() / 10.0), "combined".into(), false)
}
}
(Some(value), None) => (Some(value), "device_fallback".into(), false),
(None, Some(value)) => (Some(value), "external".into(), false),
(None, None) => (None, "unavailable".into(), false),
},
_ => match device_temperature {
Some(value) => (Some(value), "device".into(), false),
None => (None, "unavailable".into(), false),
},
}
}
fn adjustment_allowed(zone: &Zone) -> bool {
let Some(last) = zone.last_action_at else { return true; };
(Utc::now() - last).num_seconds().max(0) as u64 >= zone.min_adjust_seconds.max(15)
}
fn external_room_sensor_cooling_assist(mode: &str, control_source: &str) -> f64 {
if mode == "cool" && matches!(control_source, "external" | "combined") { 0.5 } else { 0.0 }
}
fn round_device_setpoint(mode: &str, demand: bool, value: f64) -> f64 {
let value = value.clamp(16.0, 30.0);
match (mode, demand) {
("heat", true) => value.ceil(),
("heat", false) => value.floor(),
(_, true) => value.floor(),
(_, false) => value.ceil(),
}
}
fn outdoor_assist_offset(mode: &str, outdoor: Option<f64>, room: f64, target: f64) -> f64 {
let Some(outdoor) = outdoor else { return 0.0; };
let room_error = (room - target).abs();
let weather = match mode {
"heat" => ((5.0 - outdoor) / 15.0).clamp(0.0, 1.0),
_ => ((outdoor - 30.0) / 10.0).clamp(0.0, 1.0),
};
(weather * room_error.clamp(0.0, 2.0) * 0.5).clamp(0.0, 1.0)
}
fn smart_quiet_command(
smart_fan: bool,
quiet_supported: bool,
previous_demand: bool,
demand: bool,
device_quiet: bool,
night_enabled: bool,
night_active: bool,
night_force_quiet: bool,
) -> Option<bool> {
if !quiet_supported { return None; }
if night_enabled && night_force_quiet && night_active {
return if device_quiet { None } else { Some(true) };
}
if night_enabled && night_force_quiet && !night_active && device_quiet {
// Explicitly release Quiet when the scheduled night window ends.
return Some(false);
}
if smart_fan {
// Smart Quiet follows demand transitions. Do not keep reasserting Quiet while a
// satisfied room remains in standby: some units report Quiet=false again even after
// accepting the command, which otherwise produces a beep every adjustment interval.
if previous_demand && !demand && !device_quiet { return Some(true); }
if !previous_demand && demand && device_quiet { return Some(false); }
return None;
}
// Without Smart Fan, Quiet can only have been requested by scheduled night mode,
// so release it after the night window ends.
if night_enabled && night_force_quiet && device_quiet { return Some(false); }
None
}
fn native_sleep_command(
night_enabled: bool,
night_active: bool,
use_native_sleep: bool,
sleep_supported: bool,
device_sleep: bool,
) -> Option<bool> {
if !sleep_supported { return None; }
if night_enabled && use_native_sleep && night_active {
return if device_sleep { None } else { Some(true) };
}
// If night mode ended or native Sleep was disabled in settings, remove a previously
// active device Sleep flag instead of leaving it latched indefinitely.
if device_sleep { return Some(false); }
None
}
fn night_limited_fan_speed(requested: u8, max_fan: u8) -> u8 {
let max_fan = max_fan.clamp(1, 5);
if requested == 0 { 1 } else { requested.min(max_fan) }
}
pub fn night_mode_active(settings: &NightModeSettings, time: NaiveTime) -> bool {
if !settings.enabled { return false; }
let Ok(start) = NaiveTime::parse_from_str(&settings.start_time, "%H:%M") else { return false; };
let Ok(end) = NaiveTime::parse_from_str(&settings.end_time, "%H:%M") else { return false; };
if start == end { return true; }
if start < end { time >= start && time < end } else { time >= start || time < end }
}
fn smart_fan_speed(mode: &str, room: f64, target: f64, outdoor: Option<f64>, demand: bool) -> u8 {
// When the thermostat is satisfied, keep airflow quiet instead of leaving the
// unit in Auto. The caller sends this together with the standby setpoint in
// the same GREE command, so e.g. 21 C reached -> 19 C + Low fan for heating.
if !demand { return 1; }
let error = (room - target).abs();
let extreme_weather = match (mode, outdoor) {
("heat", Some(value)) => value <= 0.0,
(_, Some(value)) => value >= 32.0,
_ => false,
};
if error >= 2.0 || extreme_weather { 3 } else if error >= 1.0 { 2 } else { 0 }
}
fn profile_setpoint(zone: &Zone, preset: &str, mode: &str) -> f64 {
if zone.profile_version == 0 && preset == "comfort" { return zone.setpoint; }
match (mode, preset) {
("heat", "sleep") => zone.heat_sleep_setpoint,
("heat", "away") => zone.heat_away_setpoint,
("heat", _) => zone.heat_comfort_setpoint,
(_, "sleep") => zone.cool_sleep_setpoint,
(_, "away") => zone.cool_away_setpoint,
(_, _) => zone.cool_comfort_setpoint,
}
}
fn resolve_zone_target(zone: &Zone, schedule: Option<&Schedule>, mode: &str) -> (String, f64) {
let (preset, base_target) = if let Some(manual) = zone.manual_preset.as_deref() {
if manual == "custom" {
("custom".into(), zone.setpoint)
} else {
(manual.to_string(), profile_setpoint(zone, manual, mode))
}
} else if let Some(item) = schedule {
if item.preset == "custom" {
("custom".into(), item.setpoint)
} else {
(item.preset.clone(), profile_setpoint(zone, &item.preset, mode))
}
} else {
("comfort".into(), profile_setpoint(zone, "comfort", mode))
};
// Quick +/- temperature adjustments are independent from the selected preset.
// The UI can therefore stay in Auto/Sleep/Comfort while temporarily nudging the target.
(preset, zone.manual_setpoint.unwrap_or(base_target))
}
pub fn refresh_zone_runtime_target(zone: &mut Zone, schedules: &[Schedule], house_mode: &str) {
let configured_mode = if zone.inherit_house_mode { house_mode } else { zone.mode.as_str() };
zone.effective_mode = configured_mode.to_string();
let target_mode = if configured_mode == "off" { zone.mode.as_str() } else { configured_mode };
let schedule = active_schedule_for_zone(zone, schedules, Local::now());
let (preset, target) = resolve_zone_target(zone, schedule, target_mode);
zone.active_preset = preset;
if !zone.device_manual_override {
zone.effective_setpoint = Some(target);
}
}
fn active_schedule_for_zone<'a>(zone: &Zone, schedules: &'a [Schedule], now: DateTime<Local>) -> Option<&'a Schedule> {
schedules.iter()
.filter(|item| item.enabled && item.zone_id == zone.id && schedule_active(item, now))
// Overlaps are rejected by the API, but imported/legacy data may still contain one.
// Prefer the most recently edited entry instead of depending on database/name order.
.max_by_key(|item| item.updated_at)
}
fn minute_floor(now: DateTime<Local>) -> DateTime<Local> {
now.with_second(0).and_then(|value| value.with_nanosecond(0)).unwrap_or(now)
}
pub fn next_schedule_boundary_utc(zone_id: &str, schedules: &[Schedule], now: DateTime<Local>) -> Option<DateTime<Utc>> {
let current = schedules.iter()
.filter(|item| item.enabled && item.zone_id == zone_id && schedule_active(item, now))
.max_by_key(|item| item.updated_at)
.map(|item| item.id.as_str());
let base = minute_floor(now);
// Eight days cover a complete weekly schedule plus the next transition.
for minute in 1..=(8 * 24 * 60) {
let candidate = base + chrono::Duration::minutes(minute);
let next = schedules.iter()
.filter(|item| item.enabled && item.zone_id == zone_id && schedule_active(item, candidate))
.max_by_key(|item| item.updated_at)
.map(|item| item.id.as_str());
if next != current {
return Some(candidate.with_timezone(&Utc));
}
}
// No schedule transition exists: keep a manual override until the user clears it.
None
}
fn schedule_active(item: &Schedule, now: DateTime<Local>) -> bool {
let Ok(start) = NaiveTime::parse_from_str(&item.start_time, "%H:%M") else { return false; };
let Ok(end) = NaiveTime::parse_from_str(&item.end_time, "%H:%M") else { return false; };
let time = now.time();
let today = now.weekday().number_from_monday();
if start == end {
// Equal times mean a 24-hour block starting on each selected weekday.
if time >= start {
item.weekdays.contains(&today)
} else {
let previous = previous_weekday(now.weekday()).number_from_monday();
item.weekdays.contains(&previous)
}
} else if start < end {
item.weekdays.contains(&today) && time >= start && time < end
} else if time >= start {
item.weekdays.contains(&today)
} else if time < end {
let previous = previous_weekday(now.weekday()).number_from_monday();
item.weekdays.contains(&previous)
} else {
false
}
}
fn schedule_week_mask(item: &Schedule) -> Option<Vec<bool>> {
let start = NaiveTime::parse_from_str(&item.start_time, "%H:%M").ok()?;
let end = NaiveTime::parse_from_str(&item.end_time, "%H:%M").ok()?;
let start_minute = (start.hour() * 60 + start.minute()) as usize;
let end_minute = (end.hour() * 60 + end.minute()) as usize;
let mut mask = vec![false; 7 * 24 * 60];
for weekday in &item.weekdays {
if !(1..=7).contains(weekday) { return None; }
let day = (*weekday as usize) - 1;
let mark = |mask: &mut [bool], day: usize, from: usize, to: usize| {
let base = (day % 7) * 24 * 60;
for minute in from..to { mask[base + minute] = true; }
};
if start_minute == end_minute {
mark(&mut mask, day, start_minute, 24 * 60);
mark(&mut mask, day + 1, 0, end_minute);
} else if start_minute < end_minute {
mark(&mut mask, day, start_minute, end_minute);
} else {
mark(&mut mask, day, start_minute, 24 * 60);
mark(&mut mask, day + 1, 0, end_minute);
}
}
Some(mask)
}
pub(crate) fn schedules_overlap(a: &Schedule, b: &Schedule) -> bool {
if !a.enabled || !b.enabled || a.zone_id != b.zone_id { return false; }
let (Some(left), Some(right)) = (schedule_week_mask(a), schedule_week_mask(b)) else { return false; };
left.iter().zip(right.iter()).any(|(a, b)| *a && *b)
}
fn previous_weekday(day: Weekday) -> Weekday {
match day {
Weekday::Mon => Weekday::Sun, Weekday::Tue => Weekday::Mon, Weekday::Wed => Weekday::Tue,
Weekday::Thu => Weekday::Wed, Weekday::Fri => Weekday::Thu, Weekday::Sat => Weekday::Fri,
Weekday::Sun => Weekday::Sat,
}
}
pub async fn build_control_plan(state: &AppState) -> Result<ControlPlan, AppError> {
let settings = state.settings.read().await.clone();
let schedules = state.db.list_schedules()?;
let devices = state.db.list_devices()?;
let zones = state.db.list_zones()?;
let groups = state.db.list_groups()?;
let house_preset = zones.first().and_then(|first| {
let first_preset = first.manual_preset.as_deref().unwrap_or("auto");
zones.iter().all(|zone| zone.manual_preset.as_deref().unwrap_or("auto") == first_preset)
.then(|| first_preset.to_string())
});
let house_power = settings.house_power_enabled;
let now = Local::now();
let night_active = night_mode_active(&settings.night_mode, now.time());
let mut zones_out = Vec::new();
let mut house_events = next_night_mode_events(&settings.night_mode, now, 2);
for zone in zones {
let device = devices.iter().find(|item| item.id == zone.device_id);
let configured_effective_mode = if zone.inherit_house_mode {
settings.house_mode.as_str()
} else {
zone.mode.as_str()
};
let blocked_by_group = zone.local_thermostat_power != Some(true)
&& groups.iter().any(|group| !group.power_enabled && group.zone_ids.iter().any(|zone_id| zone_id == &zone.id));
let manual_device_mode = device.map(|item| if item.power { item.mode.as_str() } else { "off" });
let effective_mode = if zone.device_manual_override {
manual_device_mode.unwrap_or(configured_effective_mode)
} else if zone.local_thermostat_power == Some(false) || blocked_by_group {
"off"
} else {
configured_effective_mode
};
// Keep the thermostat target readable even while the zone/group/house control is off.
// Home Assistant climate entities otherwise expose target_temperature as unknown.
let target_mode = if configured_effective_mode == "off" { zone.mode.as_str() } else { configured_effective_mode };
let active_for_target = active_schedule_for_zone(&zone, &schedules, now);
let (resolved_preset, resolved_target) = resolve_zone_target(&zone, active_for_target, target_mode);
let active = if effective_mode == "off" { None } else { active_for_target };
let next_events = if effective_mode == "off" {
Vec::new()
} else {
next_schedule_events(&zone, &schedules, effective_mode, now, 8)
};
for event in next_events.iter().take(2) {
let mut event = event.clone();
event.label = format!("{}: {}", zone.name, event.label);
house_events.push(event);
}
let effective_enabled = zone.enabled
&& zone.local_thermostat_power != Some(false)
&& (!blocked_by_group || zone.device_manual_override);
zones_out.push(ZoneControlPlan {
zone_id: zone.id.clone(),
zone_name: zone.name.clone(),
device_id: zone.device_id.clone(),
device_name: device.map(|item| item.name.clone()).unwrap_or_else(|| zone.device_id.clone()),
enabled: zone.enabled,
effective_enabled,
mode: effective_mode.to_string(),
configured_mode: zone.mode.clone(),
inherit_house_mode: zone.inherit_house_mode,
preset: resolved_preset,
preset_override: zone.manual_preset.clone(),
current_temperature: zone.current_temperature,
target_temperature: if zone.device_manual_override || !zone.enabled || effective_mode == "off" {
// A remote/manual takeover may leave a physical standby target persisted in the
// zone runtime snapshot. Never publish that value as the thermostat target.
Some(resolved_target)
} else {
zone.effective_setpoint.or(Some(resolved_target))
},
device_setpoint: device.filter(|item| item.power).map(|item| item.target_temperature),
demand: settings.house_power_enabled && zone.enabled && effective_mode != "off" && !zone.device_manual_override && zone.demand,
control_source: zone.control_temperature_source.clone(),
manual_override_until: zone.manual_override_until,
local_thermostat_power: zone.local_thermostat_power,
local_thermostat_resume_at: zone.local_thermostat_resume_at,
device_manual_override: zone.device_manual_override,
device_manual_override_until: zone.device_manual_override_until,
current_schedule_id: active.map(|item| item.id.clone()),
current_schedule_name: active.map(|item| item.name.clone()),
next_events,
});
}
let mut rules = Vec::new();
for item in state.db.list_automations()? {
let action_group_name = item.action_group_id.as_deref()
.and_then(|id| groups.iter().find(|group| group.id == id))
.map(|group| group.name.clone());
let action_name = action_group_name.clone().unwrap_or_else(|| {
devices.iter().find(|device| device.id == item.action_device_id)
.map(|device| device.name.clone())
.unwrap_or_else(|| item.action_device_id.clone())
});
let trigger_name = item.trigger_device_id.as_deref().and_then(|id| devices.iter().find(|device| device.id == id)).map(|device| device.name.clone());
let next_ready_at = item.last_fired_at.map(|last| last + chrono::Duration::seconds(item.cooldown_seconds as i64));
if item.enabled && item.trigger_kind == "time" {
if let Some(event) = next_time_automation_event(&item, &action_name, now) {
house_events.push(event);
}
}
rules.push(AutomationPlanRule {
id: item.id,
name: item.name,
enabled: item.enabled,
trigger_kind: item.trigger_kind,
trigger_device_id: item.trigger_device_id,
trigger_device_name: trigger_name,
threshold: item.threshold,
at_time: item.at_time,
action_device_id: item.action_device_id,
action_device_name: action_name,
action_group_id: item.action_group_id,
action_group_name,
action_preset: item.action_preset,
action: item.action,
last_fired_at: item.last_fired_at,
next_ready_at,
});
}
house_events.sort_by_key(|event| event.at);
house_events.truncate(12);
Ok(ControlPlan {
generated_at: Utc::now(),
house_mode: settings.house_mode,
house_preset,
house_power,
outdoor_temperature: *state.outdoor_temperature.read().await,
control_strategy: settings.control_strategy,
night_mode_active: night_active,
night_mode_start: settings.night_mode.start_time,
night_mode_end: settings.night_mode.end_time,
night_mode_max_fan_speed: settings.night_mode.max_fan_speed.clamp(1, 5),
next_events: house_events,
zones: zones_out,
rules,
})
}
fn next_night_mode_events(settings: &NightModeSettings, now: DateTime<Local>, limit: usize) -> Vec<ControlPlanEvent> {
if !settings.enabled || limit == 0 { return Vec::new(); }
let Ok(start) = NaiveTime::parse_from_str(&settings.start_time, "%H:%M") else { return Vec::new(); };
let Ok(end) = NaiveTime::parse_from_str(&settings.end_time, "%H:%M") else { return Vec::new(); };
let mut events = Vec::new();
let base = minute_floor(now);
for minute in 1..=(48 * 60) {
let candidate = base + chrono::Duration::minutes(minute);
let time = candidate.time();
let (kind, label) = if time.hour() == start.hour() && time.minute() == start.minute() {
let quiet = if settings.force_quiet { " + Quiet" } else { "" };
("night_mode_start", format!("Night mode -> fan max {}{}", settings.max_fan_speed.clamp(1, 5), quiet))
} else if time.hour() == end.hour() && time.minute() == end.minute() {
("night_mode_end", "Night mode ends".to_string())
} else {
continue;
};
events.push(ControlPlanEvent {
at: candidate.with_timezone(&Utc),
kind: kind.into(),
label,
preset: None,
target_temperature: None,
});
if events.len() >= limit { break; }
}
events
}
fn next_time_automation_event(item: &Automation, action_name: &str, now: DateTime<Local>) -> Option<ControlPlanEvent> {
let expected = NaiveTime::parse_from_str(item.at_time.as_deref()?, "%H:%M").ok()?;
let base = minute_floor(now.clone());
if time_automation_due(item, now) {
return Some(ControlPlanEvent {
at: base.with_timezone(&Utc),
kind: "automation".into(),
label: format!("{} -> {}", item.name, action_name),
preset: None,
target_temperature: item.action.target_temperature,
});
}
// A local day can last 25 hours at the end of daylight saving time.
for minute in 1..=(26 * 60) {
let candidate = base + chrono::Duration::minutes(minute);
if candidate.hour() == expected.hour() && candidate.minute() == expected.minute() {
return Some(ControlPlanEvent {
at: candidate.with_timezone(&Utc),
kind: "automation".into(),
label: format!("{} -> {}", item.name, action_name),
preset: None,
target_temperature: item.action.target_temperature,
});
}
}
None
}
fn next_schedule_events(zone: &Zone, schedules: &[Schedule], mode: &str, now: DateTime<Local>, limit: usize) -> Vec<ControlPlanEvent> {
if mode == "off" { return Vec::new(); }
let mut events = Vec::new();
let mut current = active_schedule_for_zone(zone, schedules, now).map(|item| item.id.as_str());
let base = minute_floor(now);
for minute in 1..=(8 * 24 * 60) {
let candidate = base + chrono::Duration::minutes(minute);
let next = active_schedule_for_zone(zone, schedules, candidate);
let next_id = next.map(|item| item.id.as_str());
if next_id == current { continue; }
current = next_id;
let (preset, target, label) = if let Some(item) = next {
let target = if item.preset == "custom" { item.setpoint } else { profile_setpoint(zone, &item.preset, mode) };
(Some(item.preset.clone()), Some(target), format!("{} -> {} {:.1} C", item.name, item.preset, target))
} else {
let target = profile_setpoint(zone, "comfort", mode);
(Some("comfort".into()), Some(target), format!("comfort {:.1} C", target))
};
events.push(ControlPlanEvent {
at: candidate.with_timezone(&Utc),
kind: "schedule_transition".into(),
label,
preset,
target_temperature: target,
});
if events.len() >= limit { break; }
}
events
}
async fn run_automations(state: &AppState) -> Result<()> {
if !state.settings.read().await.house_power_enabled { return Ok(()); }
let devices = state.db.list_devices()?;
let zones = state.db.list_zones()?;
let groups = state.db.list_groups()?;
for mut item in state.db.list_automations()? {
if !item.enabled || !automation_ready(&item) { continue; }
let should_fire = match item.trigger_kind.as_str() {
"temperature_above" => find_temperature(&devices, item.trigger_device_id.as_deref())
.zip(item.threshold).map(|(t, threshold)| t > threshold).unwrap_or(false),
"temperature_below" => find_temperature(&devices, item.trigger_device_id.as_deref())
.zip(item.threshold).map(|(t, threshold)| t < threshold).unwrap_or(false),
"time" => time_automation_due(&item, Local::now()),
_ => false,
};
if !should_fire { continue; }
if item.action_group_id.is_none() && device_blocked_by_disabled_zone(&item.action_device_id, &zones) {
// Disabled thermostat zones are outside normal automation. The underlying
// unit can still be operated manually from the technical Devices view.
item.last_fired_at = Some(Utc::now());
item.updated_at = Utc::now();
state.db.save_automation(&item)?;
state.log("info", "automation.blocked_by_zone", &format!("Automation {} suppressed by disabled zone", item.name), json!({
"automation_id": item.id, "device_id": item.action_device_id
}));
continue;
}
if item.action_group_id.is_none() && device_blocked_by_manual_override(&item.action_device_id, &zones) {
item.last_fired_at = Some(Utc::now());
item.updated_at = Utc::now();
state.db.save_automation(&item)?;
state.log("info", "automation.blocked_by_manual_override", &format!("Automation {} suppressed by manual device control", item.name), json!({
"automation_id": item.id, "device_id": item.action_device_id
}));
continue;
}
if item.action_group_id.is_none() && device_blocked_by_local_thermostat(&item.action_device_id, &zones) {
item.last_fired_at = Some(Utc::now());
item.updated_at = Utc::now();
state.db.save_automation(&item)?;
state.log("info", "automation.blocked_by_local_thermostat", &format!("Automation {} suppressed by local thermostat ownership", item.name), json!({
"automation_id": item.id, "device_id": item.action_device_id
}));
continue;
}
if item.action_group_id.is_none() && device_blocked_by_disabled_group(&item.action_device_id, &zones, &groups) {
// Group power-off is authoritative for normal controller-owned zones. A manual
// takeover is filtered above and therefore remains higher priority than the group.
item.last_fired_at = Some(Utc::now());
item.updated_at = Utc::now();
state.db.save_automation(&item)?;
state.log("info", "automation.blocked_by_group", &format!("Automation {} suppressed by disabled group", item.name), json!({
"automation_id": item.id, "device_id": item.action_device_id
}));
continue;
}
let result = if let Some(group_id) = item.action_group_id.as_deref() {
let group_mode = item.action.mode.as_deref().map(|mode| if mode == "auto" { "house".to_string() } else { mode.to_string() });
control_group(state, group_id, GroupControlPatch {
power: item.action.power,
mode: group_mode,
preset: item.action_preset.clone(),
}, "automation.group").await.map(|_| ())
} else {
match send_automatic_device_command_if_owned(state, &item.action_device_id, item.action.clone()).await {
Ok(Some(_)) => Ok(()),
Ok(None) => {
state.log("info", "automation.blocked_by_fresh_ownership", &format!("Automation {} was suppressed after ownership changed", item.name), json!({
"automation_id": item.id, "device_id": item.action_device_id
}));
Ok(())
}
Err(err) => Err(err),
}
};
match result {
Ok(()) => {
item.last_fired_at = Some(Utc::now());
item.updated_at = Utc::now();
state.db.save_automation(&item)?;
state.log("info", "automation.fired", &format!("Automation {} fired", item.name), json!({
"automation_id": item.id, "group_id": item.action_group_id, "device_id": item.action_device_id
}));
}
Err(err) => {
// A failed action is still an execution attempt. Apply the configured cooldown
// so an offline/disabled target cannot be hammered on every automation cycle.
item.last_fired_at = Some(Utc::now());
item.updated_at = Utc::now();
state.db.save_automation(&item)?;
state.log("error", "automation.error", &err.to_string(), json!({"automation_id": item.id}));
}
}
}
Ok(())
}
fn device_blocked_by_disabled_zone(device_id: &str, zones: &[Zone]) -> bool {
zones.iter().any(|zone| zone.device_id == device_id && !zone.enabled)
}
fn device_blocked_by_manual_override(device_id: &str, zones: &[Zone]) -> bool {
zones.iter().any(|zone| zone.device_id == device_id && zone.device_manual_override)
}
fn device_blocked_by_local_thermostat(device_id: &str, zones: &[Zone]) -> bool {
zones.iter().any(|zone| zone.device_id == device_id && zone.local_thermostat_power.is_some())
}
fn device_blocked_by_disabled_group(device_id: &str, zones: &[Zone], groups: &[crate::models::ClimateGroup]) -> bool {
let zone_ids: std::collections::HashSet<&str> = zones.iter()
.filter(|zone| zone.device_id == device_id)
.map(|zone| zone.id.as_str())
.collect();
if zone_ids.is_empty() { return false; }
groups.iter().any(|group| !group.power_enabled && group.zone_ids.iter().any(|zone_id| zone_ids.contains(zone_id.as_str())))
}
fn find_temperature(devices: &[Device], device_id: Option<&str>) -> Option<f64> {
let id = device_id?;
// Never fire a temperature automation from stale cached data of an offline/disabled unit.
devices.iter().find(|d| d.id == id && d.enabled && d.online && d.communication_failures == 0)?.current_temperature
}
fn automation_ready(item: &Automation) -> bool {
item.last_fired_at.map(|last| (Utc::now() - last).num_seconds().max(0) as u64 >= item.cooldown_seconds).unwrap_or(true)
}
fn time_automation_due(item: &Automation, now: DateTime<Local>) -> bool {
let Some(expected) = item.at_time.as_deref() else { return false; };
let Ok(value) = NaiveTime::parse_from_str(expected, "%H:%M") else { return false; };
if now.hour() != value.hour() || now.minute() != value.minute() { return false; }
if let Some(last) = item.last_fired_at {
let local_last = last.with_timezone(&Local);
if local_last.date_naive() == now.date_naive()
&& local_last.hour() == now.hour()
&& local_last.minute() == now.minute()
{
return false;
}
}
true
}
#[cfg(test)]
mod tests {
use super::*;
use chrono::TimeZone;
#[test]
fn overnight_schedule_works() {
let now = Utc.with_ymd_and_hms(2025, 1, 7, 1, 0, 0).unwrap().with_timezone(&Local); // Tuesday
let item = Schedule {
id: "1".into(), zone_id: "z".into(), name: "night".into(), enabled: true,
weekdays: vec![1], start_time: "22:00".into(), end_time: "06:00".into(), preset: "custom".into(), setpoint: 20.0,
created_at: Utc::now(), updated_at: Utc::now(),
};
assert!(schedule_active(&item, now));
}
fn test_schedule(id: &str, weekdays: Vec<u32>, start: &str, end: &str) -> Schedule {
Schedule {
id: id.into(), zone_id: "z".into(), name: id.into(), enabled: true,
weekdays, start_time: start.into(), end_time: end.into(), preset: "comfort".into(), setpoint: 21.0,
created_at: Utc::now(), updated_at: Utc::now(),
}
}
#[test]
fn equal_schedule_times_mean_a_full_day() {
let item = test_schedule("full", vec![1], "06:00", "06:00");
let monday_noon = Local.with_ymd_and_hms(2025, 1, 6, 12, 0, 0).single().unwrap();
let tuesday_early = Local.with_ymd_and_hms(2025, 1, 7, 5, 59, 0).single().unwrap();
let tuesday_after = Local.with_ymd_and_hms(2025, 1, 7, 6, 1, 0).single().unwrap();
assert!(schedule_active(&item, monday_noon));
assert!(schedule_active(&item, tuesday_early));
assert!(!schedule_active(&item, tuesday_after));
}
#[test]
fn schedule_overlap_detection_handles_overnight_ranges() {
let daytime = test_schedule("day", vec![1,2,3,4,5,6,7], "06:30", "22:30");
let night = test_schedule("night", vec![1,2,3,4,5,6,7], "22:30", "06:30");
let conflict = test_schedule("conflict", vec![1], "22:00", "23:00");
assert!(!schedules_overlap(&daytime, &night));
assert!(schedules_overlap(&night, &conflict));
}
#[test]
fn next_schedule_boundary_scans_the_whole_week() {
let friday = test_schedule("friday", vec![5], "12:00", "13:00");
let monday = Local.with_ymd_and_hms(2025, 1, 6, 10, 0, 30).single().unwrap();
let boundary = next_schedule_boundary_utc("z", &[friday], monday).unwrap().with_timezone(&Local);
assert_eq!(boundary.weekday(), Weekday::Fri);
assert_eq!(boundary.hour(), 12);
assert_eq!(boundary.minute(), 0);
assert_eq!(boundary.second(), 0);
}
#[test]
fn full_week_schedule_has_no_manual_override_boundary() {
let always = test_schedule("always", vec![1,2,3,4,5,6,7], "00:00", "00:00");
let now = Local.with_ymd_and_hms(2025, 1, 6, 10, 0, 30).single().unwrap();
assert!(next_schedule_boundary_utc("z", &[always], now).is_none());
}
#[test]
fn workday_weekend_handoff_has_no_overlaps() {
let schedules = vec![
test_schedule("morning", vec![1,2,3,4,5], "06:30", "08:00"),
test_schedule("away", vec![1,2,3,4,5], "08:00", "16:00"),
test_schedule("evening", vec![1,2,3,4,5], "16:00", "22:30"),
test_schedule("sleep", vec![1,2,3,4,5], "22:30", "06:30"),
test_schedule("weekend", vec![6,7], "08:00", "23:00"),
test_schedule("saturday-sleep", vec![6], "23:00", "08:00"),
test_schedule("sunday-sleep", vec![7], "23:00", "06:30"),
];
for (index, item) in schedules.iter().enumerate() {
for other in schedules.iter().skip(index + 1) {
assert!(!schedules_overlap(item, other), "{} overlaps {}", item.name, other.name);
}
}
}
#[test]
fn time_automation_fires_only_once_in_the_same_minute() {
let now = Local.with_ymd_and_hms(2025, 1, 6, 10, 15, 40).single().unwrap();
let mut item = Automation {
id: "a".into(), name: "at time".into(), enabled: true, trigger_kind: "time".into(),
trigger_device_id: None, threshold: None, at_time: Some("10:15".into()),
action_device_id: "d".into(), action_group_id: None, action_preset: None,
action: DeviceCommand { power: Some(true), ..Default::default() }, cooldown_seconds: 30,
last_fired_at: None, created_at: Utc::now(), updated_at: Utc::now(),
};
assert!(time_automation_due(&item, now.clone()));
item.last_fired_at = Some((now.clone() - chrono::Duration::seconds(35)).with_timezone(&Utc));
assert!(!time_automation_due(&item, now));
}
fn test_zone(source: &str) -> Zone {
Zone {
id: "z".into(), name: "Room".into(), device_id: "d".into(), enabled: true,
mode: "heat".into(), inherit_house_mode: true, setpoint: 21.0, profile_version: 1,
cool_comfort_setpoint: 23.0, cool_sleep_setpoint: 24.5, cool_away_setpoint: 27.0,
heat_comfort_setpoint: 21.0, heat_sleep_setpoint: 19.0, heat_away_setpoint: 17.0,
hysteresis: 0.6, min_on_seconds: 180, min_off_seconds: 180, min_adjust_seconds: 120, standby_offset_c: 2.0, smart_fan: true,
sensor_source: source.into(), ha_entity_id: Some("sensor.room_temperature".into()),
external_sensor_weight: 0.4, max_sensor_difference: 3.0, device_temperature: None, external_temperature: None,
current_temperature: None, control_temperature_source: "device".into(), active_preset: "comfort".into(),
manual_preset: None, manual_setpoint: None, manual_override_until: None, local_thermostat_power: None, local_thermostat_resume_at: None,
device_manual_override: false, device_manual_override_since: None, device_manual_override_until: None, device_manual_override_fields: Vec::new(), device_manual_override_baseline: None,
effective_mode: "heat".into(), effective_setpoint: Some(21.0), device_setpoint: None,
demand: false, demand_since: None, target_alerted_at: None, last_action_at: None, created_at: Utc::now(), updated_at: Utc::now(),
}
}
#[test]
fn external_device_change_detects_manual_climate_controls() {
let zone = test_zone("device");
let before = Device::simulated_default();
let mut after = before.clone();
after.power = !before.power;
after.target_temperature = before.target_temperature + 1.0;
after.fan_speed = 3;
let fields = externally_changed_control_fields(&before, &after, &zone);
assert!(fields.iter().any(|field| field == "power"));
assert!(fields.iter().any(|field| field == "target_temperature"));
assert!(fields.iter().any(|field| field == "fan_speed"));
}
#[test]
fn controller_expected_climate_change_is_recognized() {
let mut device = Device::simulated_default();
device.power = true;
device.mode = "cool".into();
device.target_temperature = 22.0;
let command = DeviceCommand {
power: Some(true),
mode: Some("cool".into()),
target_temperature: Some(22.0),
..Default::default()
};
assert!(command_field_matches_device(&command, "power", &device));
assert!(command_field_matches_device(&command, "mode", &device));
assert!(command_field_matches_device(&command, "target_temperature", &device));
device.target_temperature = 25.0;
assert!(!command_field_matches_device(&command, "target_temperature", &device));
}
#[test]
fn local_thermostat_ownership_blocks_direct_automation() {
let mut zone = test_zone("device");
assert!(!device_blocked_by_local_thermostat(
&zone.device_id,
std::slice::from_ref(&zone),
));
zone.local_thermostat_power = Some(true);
assert!(device_blocked_by_local_thermostat(
&zone.device_id,
std::slice::from_ref(&zone),
));
zone.local_thermostat_power = Some(false);
assert!(device_blocked_by_local_thermostat(
&zone.device_id,
std::slice::from_ref(&zone),
));
}
#[test]
fn local_thermostat_resume_clears_only_local_quick_control_state() {
let mut zone = test_zone("device");
zone.local_thermostat_power = Some(false);
zone.local_thermostat_resume_at = Some(Utc::now() + chrono::Duration::minutes(15));
zone.manual_preset = Some("comfort".into());
zone.manual_setpoint = Some(23.0);
zone.manual_override_until = Some(Utc::now() + chrono::Duration::hours(1));
zone.device_manual_override = true;
assert!(reset_local_thermostat_override(&mut zone));
assert!(zone.local_thermostat_power.is_none());
assert!(zone.local_thermostat_resume_at.is_none());
assert!(zone.manual_preset.is_none());
assert!(zone.manual_setpoint.is_none());
assert!(zone.manual_override_until.is_none());
assert!(zone.device_manual_override);
assert_eq!(LOCAL_THERMOSTAT_RESUME_DELAY_MINUTES, 15);
}
#[test]
fn local_thermostat_off_restarts_backend_handback_deadline() {
let mut zone = test_zone("device");
let first = Utc::now();
set_local_thermostat_power(&mut zone, false, first.clone());
let first_deadline = zone.local_thermostat_resume_at.clone().unwrap();
assert_eq!(first_deadline, first.clone() + chrono::Duration::minutes(15));
let second = first + chrono::Duration::minutes(4);
set_local_thermostat_power(&mut zone, true, second.clone());
assert!(zone.local_thermostat_resume_at.is_none());
set_local_thermostat_power(&mut zone, false, second.clone());
assert_eq!(zone.local_thermostat_resume_at, Some(second + chrono::Duration::minutes(15)));
assert!(zone.local_thermostat_resume_at.clone().unwrap() > first_deadline);
}
#[test]
fn manual_device_takeover_suspends_local_handback_until_control_returns() {
let mut zone = test_zone("device");
let now = Utc::now();
set_local_thermostat_power(&mut zone, false, now.clone());
assert!(local_thermostat_handback_is_active(&zone));
zone.device_manual_override = true;
assert!(!local_thermostat_handback_is_active(&zone));
zone.device_manual_override = false;
let returned = now + chrono::Duration::minutes(7);
assert!(rearm_local_thermostat_resume(&mut zone, returned.clone()));
assert_eq!(zone.local_thermostat_resume_at, Some(returned + chrono::Duration::minutes(15)));
assert!(local_thermostat_handback_is_active(&zone));
}
#[test]
fn rounded_gree_setpoint_does_not_create_manual_override() {
let zone = test_zone("device");
let mut before = Device::simulated_default();
before.target_temperature = 23.5;
let mut after = before.clone();
after.target_temperature = 24.0;
assert!(externally_changed_control_fields(&before, &after, &zone).is_empty());
}
#[test]
fn standby_low_to_auto_fan_drift_is_not_manual_override() {
let mut zone = test_zone("device");
zone.smart_fan = true;
zone.demand = false;
let mut before = Device::simulated_default();
before.fan_speed = 1;
let mut after = before.clone();
after.fan_speed = 0;
assert!(externally_changed_control_fields(&before, &after, &zone).is_empty());
}
#[test]
fn reset_device_manual_override_clears_takeover_state() {
let mut zone = test_zone("device");
let device = Device::simulated_default();
zone.device_manual_override = true;
zone.device_manual_override_since = Some(Utc::now());
zone.device_manual_override_until = Some(Utc::now());
zone.device_manual_override_fields = vec!["target_temperature".into()];
zone.device_manual_override_baseline = Some((&device).into());
assert!(reset_device_manual_override(&mut zone));
assert!(!zone.device_manual_override);
assert!(zone.device_manual_override_since.is_none());
assert!(zone.device_manual_override_until.is_none());
assert!(zone.device_manual_override_fields.is_empty());
assert!(zone.device_manual_override_baseline.is_none());
}
#[test]
fn restored_manual_device_state_matches_original_takeover_baseline() {
let mut zone = test_zone("device");
let baseline = Device::simulated_default();
zone.device_manual_override = true;
zone.device_manual_override_fields = vec!["power".into(), "target_temperature".into()];
zone.device_manual_override_baseline = Some((&baseline).into());
let mut changed = baseline.clone();
changed.power = !baseline.power;
changed.target_temperature = baseline.target_temperature + 2.0;
assert!(!manual_override_matches_baseline(&zone, &changed));
let mut returned_off = baseline.clone();
returned_off.target_temperature = baseline.target_temperature + 3.0;
assert!(manual_override_matches_baseline(&zone, &returned_off));
assert!(manual_override_matches_baseline(&zone, &baseline));
}
#[test]
fn device_command_drops_unchanged_fields() {
let device = Device::simulated_default();
let command = DeviceCommand {
power: Some(false),
mode: Some("cool".into()),
target_temperature: Some(23.4),
fan_speed: Some(3),
light: Some(false),
..DeviceCommand::default()
};
let changed = command.changed_from(&device);
assert_eq!(changed.power, None);
assert_eq!(changed.mode, None);
assert_eq!(changed.target_temperature, None);
assert_eq!(changed.fan_speed, Some(3));
assert_eq!(changed.light, Some(false));
}
#[test]
fn combined_temperature_prefers_room_sensor_weight() {
let zone = test_zone("combined");
let (value, source, discrepancy) = select_zone_temperature(&zone, Some(22.0), Some(20.0));
assert_eq!(value, Some(21.2));
assert_eq!(source, "combined");
assert!(!discrepancy);
}
#[test]
fn combined_temperature_falls_back_on_large_discrepancy() {
let zone = test_zone("combined");
let (value, source, discrepancy) = select_zone_temperature(&zone, Some(21.0), Some(27.0));
assert_eq!(value, Some(21.0));
assert_eq!(source, "device_discrepancy_fallback");
assert!(discrepancy);
}
#[test]
fn combined_temperature_falls_back_when_external_is_missing() {
let zone = test_zone("combined");
let (value, source, discrepancy) = select_zone_temperature(&zone, Some(21.5), None);
assert_eq!(value, Some(21.5));
assert_eq!(source, "device_fallback");
assert!(!discrepancy);
}
#[test]
fn seasonal_profiles_resolve_independently() {
let zone = test_zone("device");
assert_eq!(profile_setpoint(&zone, "comfort", "cool"), 23.0);
assert_eq!(profile_setpoint(&zone, "sleep", "cool"), 24.5);
assert_eq!(profile_setpoint(&zone, "comfort", "heat"), 21.0);
assert_eq!(profile_setpoint(&zone, "sleep", "heat"), 19.0);
}
#[test]
fn quick_setpoint_keeps_active_preset() {
let mut zone = test_zone("device");
zone.manual_setpoint = Some(22.5);
let (preset, target) = resolve_zone_target(&zone, None, "cool");
assert_eq!(preset, "comfort");
assert_eq!(target, 22.5);
}
#[test]
fn runtime_target_refresh_applies_manual_profile_immediately() {
let mut zone = test_zone("device");
zone.inherit_house_mode = false;
zone.mode = "cool".into();
zone.manual_preset = Some("sleep".into());
zone.active_preset = "comfort".into();
zone.effective_setpoint = Some(25.0);
refresh_zone_runtime_target(&mut zone, &[], "cool");
assert_eq!(zone.active_preset, "sleep");
assert_eq!(zone.effective_setpoint, Some(24.5));
assert_eq!(zone.effective_mode, "cool");
}
#[test]
fn legacy_zone_keeps_old_comfort_setpoint() {
let mut zone = test_zone("device");
zone.profile_version = 0;
zone.setpoint = 22.5;
assert_eq!(profile_setpoint(&zone, "comfort", "cool"), 22.5);
assert_eq!(profile_setpoint(&zone, "comfort", "heat"), 22.5);
}
#[test]
fn device_setpoint_rounding_preserves_control_direction() {
assert_eq!(round_device_setpoint("cool", true, 23.5), 23.0);
assert_eq!(round_device_setpoint("cool", false, 25.5), 26.0);
assert_eq!(round_device_setpoint("heat", true, 21.5), 22.0);
assert_eq!(round_device_setpoint("heat", false, 19.5), 19.0);
}
#[test]
fn external_room_sensor_selects_lower_cooling_setpoint_only_when_used() {
assert_eq!(external_room_sensor_cooling_assist("cool", "external"), 0.5);
assert_eq!(external_room_sensor_cooling_assist("cool", "combined"), 0.5);
assert_eq!(external_room_sensor_cooling_assist("cool", "device_fallback"), 0.0);
assert_eq!(external_room_sensor_cooling_assist("cool", "device_discrepancy_fallback"), 0.0);
assert_eq!(external_room_sensor_cooling_assist("heat", "external"), 0.0);
}
#[test]
fn smart_fan_uses_low_speed_when_zone_is_satisfied() {
assert_eq!(smart_fan_speed("heat", 21.0, 21.0, None, false), 1);
assert_eq!(smart_fan_speed("cool", 23.0, 23.0, None, false), 1);
}
#[test]
fn smart_quiet_follows_satisfied_transition_only_when_supported() {
assert_eq!(smart_quiet_command(true, true, true, false, false, false, false, true), Some(true));
assert_eq!(smart_quiet_command(true, true, false, false, false, false, false, true), None);
assert_eq!(smart_quiet_command(true, true, false, false, true, false, false, true), None);
assert_eq!(smart_quiet_command(true, true, false, true, true, false, false, true), Some(false));
assert_eq!(smart_quiet_command(true, true, true, true, true, false, false, true), None);
assert_eq!(smart_quiet_command(true, false, true, false, false, false, false, true), None);
assert_eq!(smart_quiet_command(false, true, true, false, false, false, false, true), None);
}
#[test]
fn night_mode_handles_midnight_and_limits_auto_fan() {
let settings = NightModeSettings { enabled: true, start_time: "22:00".into(), end_time: "06:00".into(), max_fan_speed: 1, force_quiet: true, use_native_sleep: true };
assert!(night_mode_active(&settings, NaiveTime::from_hms_opt(23, 30, 0).unwrap()));
assert!(night_mode_active(&settings, NaiveTime::from_hms_opt(5, 59, 0).unwrap()));
assert!(!night_mode_active(&settings, NaiveTime::from_hms_opt(12, 0, 0).unwrap()));
assert_eq!(night_limited_fan_speed(0, 1), 1);
assert_eq!(night_limited_fan_speed(3, 1), 1);
assert_eq!(smart_quiet_command(false, true, true, true, false, true, true, true), Some(true));
assert_eq!(smart_quiet_command(false, true, true, true, true, true, false, true), Some(false));
assert_eq!(smart_quiet_command(true, true, false, false, true, true, false, true), Some(false));
assert_eq!(native_sleep_command(true, true, true, true, false), Some(true));
assert_eq!(native_sleep_command(true, false, true, true, true), Some(false));
assert_eq!(native_sleep_command(false, false, false, true, true), Some(false));
assert_eq!(native_sleep_command(true, true, true, false, false), None);
}
#[test]
fn gree_outdoor_fallback_uses_median_of_online_units() {
let mut a = Device::simulated_default();
a.outdoor_temperature = Some(10.0);
let mut b = Device::simulated_default();
b.id = "sim-b".into();
b.outdoor_temperature = Some(12.0);
let mut c = Device::simulated_default();
c.id = "sim-c".into();
c.outdoor_temperature = Some(40.0);
assert_eq!(gree_outdoor_temperature(&[a, b, c]), Some(12.0));
}
#[test]
fn outdoor_assist_is_bounded_and_direction_neutral() {
let cool = outdoor_assist_offset("cool", Some(36.0), 27.0, 23.0);
let heat = outdoor_assist_offset("heat", Some(-5.0), 17.0, 21.0);
assert!(cool > 0.0 && cool <= 1.0);
assert!(heat > 0.0 && heat <= 1.0);
assert_eq!(outdoor_assist_offset("cool", None, 27.0, 23.0), 0.0);
}
}
Reference in New Issue View Git Blame Copy Permalink