From d4a6816532125a60adaf5189113a710030d4fc95 Mon Sep 17 00:00:00 2001
From: Maxime Augier <max@xolus.net>
Date: Wed, 21 Aug 2024 21:51:28 +0200
Subject: [PATCH] Continue implementing regulator

---
 src/control.rs | 63 ++++++++++++++++++++++++++++++--------------------
 1 file changed, 38 insertions(+), 25 deletions(-)

diff --git a/src/control.rs b/src/control.rs
index 57d52bd..903a899 100644
--- a/src/control.rs
+++ b/src/control.rs
@@ -10,39 +10,47 @@ use easee::api::{self, ChargerOpMode, Circuit, Context, SetCurrent, Triphase};
 use easee::observation::{self, Event, ObservationError};
 use tracing::{error, info, warn};
 
+use crate::config::{self, Config};
 use crate::mattermost::{self, Channel};
 use crate::prom::PromClient;
-use crate::config::{self, Config};
 
-use observation::{Observation,PilotMode};
+use observation::{Observation, PilotMode};
 
 struct Charger {
     inner: api::Charger,
     owners: Vec<String>,
-    current: Option<(f64, f64, f64)>
+    current: Option<(f64, f64, f64)>,
 }
 
-
 impl Charger {
     pub fn from_api(inner: api::Charger, configs: &[config::Charger]) -> Self {
-        let owners = configs.iter()
+        let owners = configs
+            .iter()
             .find(|c| c.id == inner.id)
             .map(|c| &c.owners)
             .cloned()
             .unwrap_or_default();
-        Charger { inner, owners, current: None }
+        Charger {
+            inner,
+            owners,
+            current: None,
+        }
     }
-
 }
 
-pub fn start(mut ctx: Context, config: Config, mut chargers: Vec<api::Charger>) -> Result<Infallible> {
-
+pub fn start(
+    mut ctx: Context,
+    config: Config,
+    mut chargers: Vec<api::Charger>,
+) -> Result<Infallible> {
     let mattermost = mattermost::Context::new(config.mattermost.base, &config.mattermost.token)?;
     let mut stream = observation::Stream::from_context(&mut ctx)?;
 
-    let chargers: HashMap<String, Charger> = chargers.into_iter()
+    let chargers: HashMap<String, Charger> = chargers
+        .into_iter()
         .filter_map(|c| {
-            stream.subscribe(&c.id)
+            stream
+                .subscribe(&c.id)
                 .map_err(|e| error!("Cannot subscribe {}: {e}", &c.id))
                 .ok()?;
             let name = c.name.clone();
@@ -62,15 +70,17 @@ pub fn start(mut ctx: Context, config: Config, mut chargers: Vec<api::Charger>)
     mattermost.send_to_channel(&channel, "Easee Controller started")?;
 
     if let Some(reg) = config.regulator {
-
-        let circuit = ctx.sites_details()?
-            .into_iter().find(|s| s.site.id == reg.site_id)
+        let circuit = ctx
+            .sites_details()?
+            .into_iter()
+            .find(|s| s.site.id == reg.site_id)
             .ok_or(anyhow!("Invalid site id {}", reg.site_id))?
-            .circuits.into_iter()
+            .circuits
+            .into_iter()
             .find(|c| c.id == reg.circuit_id)
             .ok_or(anyhow!("Invalid circuit id {}", reg.circuit_id))?;
 
-        let controller =  Controller {
+        let controller = Controller {
             bias: Triphase::from(reg.power_bias_watts),
             ctx,
             prom: PromClient::new(config.prometheus.base),
@@ -166,21 +176,24 @@ impl Controller {
         loop {
             let export_power = self.prom.current_power()?;
             let available_power = export_power - self.bias;
-            let available_current = available_power * (1.0/voltage);
+            let available_current = available_power * (1.0 / voltage);
 
             integrated = available_current * 0.3 + integrated * (1.0 - 0.3);
             let differentiated = available_current - prev_available_current;
             prev_available_current = available_current;
-            
-            let delta = available_current * self.p
-                                + differentiated * self.d
-                                + integrated * self.i;
+
+            let delta = available_current * self.p + differentiated * self.d + integrated * self.i;
 
             current = current + delta;
-            self.circuit.set_dynamic_current(&mut self.ctx,  SetCurrent { time_to_live, current })?;
+            self.circuit.set_dynamic_current(
+                &mut self.ctx,
+                SetCurrent {
+                    time_to_live,
+                    current,
+                },
+            )?;
 
             thread::sleep(self.delay);
-
-        }  
+        }
     }
-}
\ No newline at end of file
+}