v0.14.0

src/engine/energy.rs

@@ -0,0 +1,147 @@
+const ENERGY_ANOMALY_MAX_DELTA_KWH: f64 = 100.0;
+
+fn cumulative_energy_delta(previous_kwh: Option<f64>, current_kwh: f64) -> (f64, &'static str, bool) {
+    let Some(previous_kwh) = previous_kwh else {
+        return (0.0, "baseline", false);
+    };
+    let delta = current_kwh - previous_kwh;
+    if delta.abs() < 0.000_000_1 {
+        (0.0, "duplicate", false)
+    } else if delta < 0.0 {
+        (0.0, "reset", true)
+    } else if delta > ENERGY_ANOMALY_MAX_DELTA_KWH {
+        (0.0, "anomaly_large_jump", true)
+    } else {
+        (delta.max(0.0), "ok", false)
+    }
+}
+
+fn normalize_energy_kwh(raw_value: f64, unit: &str) -> Result<f64, AppError> {
+    if !raw_value.is_finite() || raw_value < 0.0 {
+        return Err(AppError::BadRequest("energy meter value must be a finite non-negative number".into()));
+    }
+    match unit.trim().to_ascii_lowercase().as_str() {
+        "kwh" => Ok(raw_value),
+        "wh" => Ok(raw_value / 1000.0),
+        "0.1kwh" | "0.1 kwh" => Ok(raw_value * 0.1),
+        other => Err(AppError::BadRequest(format!("unsupported energy unit: {other}"))),
+    }
+}
+
+pub(crate) fn record_cumulative_energy_sample(
+    state: &AppState,
+    device_id: &str,
+    source: &str,
+    raw_value: f64,
+    raw_unit: &str,
+    current_power_kw: Option<f64>,
+) -> Result<EnergyReading, AppError> {
+    let normalized = normalize_energy_kwh(raw_value, raw_unit)?;
+    let previous = state.db.last_energy_reading(device_id, source)?;
+    let (consumption, quality, reset_detected) = cumulative_energy_delta(
+        previous.as_ref().map(|row| row.normalized_meter_kwh),
+        normalized,
+    );
+    let reading = EnergyReading {
+        id: 0,
+        device_id: device_id.to_string(),
+        timestamp: Utc::now(),
+        source: source.to_string(),
+        raw_meter_value: raw_value,
+        raw_unit: raw_unit.to_string(),
+        normalized_meter_kwh: normalized,
+        consumption_kwh: consumption.max(0.0),
+        current_power_kw: current_power_kw.filter(|value| value.is_finite() && *value >= 0.0),
+        quality: quality.to_string(),
+        reset_detected,
+    };
+    state.db.add_energy_reading(&reading)?;
+    queue_influx_energy(state, reading.clone());
+    Ok(reading)
+}
+
+fn queue_influx_energy(state: &AppState, reading: EnergyReading) {
+    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_energy(&state.http, &settings, &reading).await {
+            tracing::warn!(error=?err, device_id=%reading.device_id, source=%reading.source, "cannot write energy metric to InfluxDB");
+        }
+    });
+}
+
+async fn sample_home_assistant_energy_device(state: &AppState, device: &Device) -> Result<(), AppError> {
+    let Some(entity_id) = device.ha_energy_entity_id.as_deref().filter(|value| !value.trim().is_empty()) else {
+        return Ok(());
+    };
+    let settings = state.settings.read().await.home_assistant.clone();
+    let payload = home_assistant::read_entity(&state.http, &settings, Some(entity_id))
+        .await
+        .map_err(|err| AppError::Device(err.to_string()))?;
+    let state_value = payload.get("state").and_then(Value::as_str).unwrap_or_default();
+    if matches!(state_value, "" | "unknown" | "unavailable") { return Ok(()); }
+    let raw_value: f64 = state_value.parse().map_err(|_| AppError::Device("Home Assistant energy state is not numeric".into()))?;
+    let attrs = payload.get("attributes").and_then(Value::as_object).cloned().unwrap_or_default();
+    let device_class = attrs.get("device_class").and_then(Value::as_str).unwrap_or_default();
+    let state_class = attrs.get("state_class").and_then(Value::as_str).unwrap_or_default();
+    let unit = attrs.get("unit_of_measurement").and_then(Value::as_str).unwrap_or_default();
+    if device_class != "energy" || !matches!(state_class, "total" | "total_increasing") {
+        return Err(AppError::BadRequest("selected Home Assistant entity is not a cumulative energy sensor".into()));
+    }
+    if !matches!(unit.to_ascii_lowercase().as_str(), "wh" | "kwh") {
+        return Err(AppError::BadRequest("Home Assistant energy sensor must use Wh or kWh".into()));
+    }
+    let _ = record_cumulative_energy_sample(state, &device.id, "home_assistant", raw_value, unit, None)?;
+    Ok(())
+}
+
+pub(crate) async fn home_assistant_energy_loop(state: AppState) {
+    sleep(Duration::from_secs(10)).await;
+    loop {
+        let settings = state.settings.read().await.home_assistant.clone();
+        if !settings.url.trim().is_empty() && !settings.token.trim().is_empty() {
+            if let Ok(devices) = state.db.list_devices() {
+                for device in devices.into_iter().filter(|device| device.enabled && device.ha_energy_entity_id.is_some()) {
+                    if let Err(err) = sample_home_assistant_energy_device(&state, &device).await {
+                        tracing::warn!(device=%device.id, error=?err, "Home Assistant energy sample failed");
+                    }
+                }
+            }
+        }
+        sleep(Duration::from_secs(60)).await;
+    }
+}
+
+#[cfg(test)]
+mod energy_tests {
+    use super::*;
+
+    #[test]
+    fn normalizes_wh_and_kwh() {
+        assert!((normalize_energy_kwh(1500.0, "Wh").unwrap() - 1.5).abs() < 1e-9);
+        assert!((normalize_energy_kwh(1.5, "kWh").unwrap() - 1.5).abs() < 1e-9);
+    }
+
+    #[test]
+    fn cumulative_counter_becomes_non_negative_delta() {
+        assert_eq!(cumulative_energy_delta(None, 152.1), (0.0, "baseline", false));
+        let (delta, quality, reset) = cumulative_energy_delta(Some(152.1), 152.4);
+        assert!((delta - 0.3).abs() < 1e-9);
+        assert_eq!(quality, "ok");
+        assert!(!reset);
+        assert_eq!(cumulative_energy_delta(Some(152.4), 152.4), (0.0, "duplicate", false));
+        assert_eq!(cumulative_energy_delta(Some(153.0), 1.0), (0.0, "reset", true));
+        assert_eq!(cumulative_energy_delta(Some(1.0), 150.0), (0.0, "anomaly_large_jump", true));
+    }
+
+    #[test]
+    fn unit_changes_normalize_before_delta() {
+        let wh = normalize_energy_kwh(152_400.0, "Wh").unwrap();
+        let kwh = normalize_energy_kwh(153.0, "kWh").unwrap();
+        let (delta, quality, reset) = cumulative_energy_delta(Some(wh), kwh);
+        assert!((delta - 0.6).abs() < 1e-9);
+        assert_eq!(quality, "ok");
+        assert!(!reset);
+    }
+}