Added dedicated light device and updated hallway logic

automation_devices/src/ikea_outlet.rs

@@ -23,7 +23,6 @@ pub enum OutletType {
     Outlet,
     Kettle,
     Charger,
-    Light,
 }
 
 #[derive(Debug, Clone, LuaDeviceConfig)]
@@ -133,7 +132,6 @@ impl google_home::Device for IkeaOutlet {
         match self.config.outlet_type {
             OutletType::Outlet => Type::Outlet,
             OutletType::Kettle => Type::Kettle,
-            OutletType::Light => Type::Light, // Find a better device type for this, ideally would like to use charger, but that needs more work
             OutletType::Charger => Type::Outlet, // Find a better device type for this, ideally would like to use charger, but that needs more work
         }
     }

automation_devices/src/lib.rs

@@ -10,11 +10,13 @@ mod kasa_outlet;
 mod light_sensor;
 mod wake_on_lan;
 mod washer;
+mod zigbee;
 
 use std::ops::Deref;
 
 use automation_cast::Cast;
 use automation_lib::device::{Device, LuaDeviceCreate};
+use zigbee::light::{LightBrightness, LightOnOff};
 
 pub use self::air_filter::AirFilter;
 pub use self::contact_sensor::ContactSensor;
@@ -99,6 +101,8 @@ macro_rules! impl_device {
     };
 }
 
+impl_device!(LightOnOff);
+impl_device!(LightBrightness);
 impl_device!(AirFilter);
 impl_device!(ContactSensor);
 impl_device!(DebugBridge);
@@ -113,6 +117,8 @@ impl_device!(WakeOnLAN);
 impl_device!(Washer);
 
 pub fn register_with_lua(lua: &mlua::Lua) -> mlua::Result<()> {
+    register_device!(lua, LightOnOff);
+    register_device!(lua, LightBrightness);
     register_device!(lua, AirFilter);
     register_device!(lua, ContactSensor);
     register_device!(lua, DebugBridge);

automation_devices/src/zigbee/light.rs

@@ -0,0 +1,298 @@
+use std::fmt::Debug;
+use std::ops::Deref;
+use std::sync::Arc;
+
+use anyhow::Result;
+use async_trait::async_trait;
+use automation_lib::action_callback::ActionCallback;
+use automation_lib::config::{InfoConfig, MqttDeviceConfig};
+use automation_lib::device::{Device, LuaDeviceCreate};
+use automation_lib::event::{OnMqtt, OnPresence};
+use automation_lib::helpers::serialization::state_deserializer;
+use automation_lib::mqtt::WrappedAsyncClient;
+use automation_macro::LuaDeviceConfig;
+use google_home::device;
+use google_home::errors::ErrorCode;
+use google_home::traits::{Brightness, OnOff};
+use google_home::types::Type;
+use rumqttc::{matches, Publish};
+use serde::{Deserialize, Serialize};
+use serde_json::json;
+use tokio::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};
+use tracing::{debug, trace, warn};
+
+pub trait LightState:
+    Debug + Clone + Default + Sync + Send + Serialize + Into<StateOnOff> + 'static
+{
+}
+
+#[derive(Debug, Clone, LuaDeviceConfig)]
+pub struct Config<T: LightState> {
+    #[device_config(flatten)]
+    pub info: InfoConfig,
+    #[device_config(flatten)]
+    pub mqtt: MqttDeviceConfig,
+
+    #[device_config(from_lua, default)]
+    pub callback: ActionCallback<Light<T>, T>,
+
+    #[device_config(from_lua)]
+    pub client: WrappedAsyncClient,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct StateOnOff {
+    #[serde(deserialize_with = "state_deserializer")]
+    state: bool,
+}
+
+impl LightState for StateOnOff {}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct StateBrightness {
+    #[serde(deserialize_with = "state_deserializer")]
+    state: bool,
+    brightness: f64,
+}
+
+impl LightState for StateBrightness {}
+
+impl From<StateBrightness> for StateOnOff {
+    fn from(state: StateBrightness) -> Self {
+        StateOnOff { state: state.state }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Light<T: LightState> {
+    config: Config<T>,
+
+    state: Arc<RwLock<T>>,
+}
+
+pub type LightOnOff = Light<StateOnOff>;
+pub type LightBrightness = Light<StateBrightness>;
+
+impl<T: LightState> Light<T> {
+    async fn state(&self) -> RwLockReadGuard<T> {
+        self.state.read().await
+    }
+
+    async fn state_mut(&self) -> RwLockWriteGuard<T> {
+        self.state.write().await
+    }
+}
+
+#[async_trait]
+impl<T: LightState> LuaDeviceCreate for Light<T> {
+    type Config = Config<T>;
+    type Error = rumqttc::ClientError;
+
+    async fn create(config: Self::Config) -> Result<Self, Self::Error> {
+        trace!(id = config.info.identifier(), "Setting up IkeaOutlet");
+
+        config
+            .client
+            .subscribe(&config.mqtt.topic, rumqttc::QoS::AtLeastOnce)
+            .await?;
+
+        Ok(Self {
+            config,
+            state: Default::default(),
+        })
+    }
+}
+
+impl<T: LightState> Device for Light<T> {
+    fn get_id(&self) -> String {
+        self.config.info.identifier()
+    }
+}
+
+#[async_trait]
+impl OnMqtt for Light<StateOnOff> {
+    async fn on_mqtt(&self, message: Publish) {
+        // Check if the message is from the device itself or from a remote
+        if matches(&message.topic, &self.config.mqtt.topic) {
+            let state = match serde_json::from_slice::<StateOnOff>(&message.payload) {
+                Ok(state) => state,
+                Err(err) => {
+                    warn!(id = Device::get_id(self), "Failed to parse message: {err}");
+                    return;
+                }
+            };
+
+            // No need to do anything if the state has not changed
+            if state.state == self.state().await.state {
+                return;
+            }
+
+            self.state_mut().await.state = state.state;
+            debug!(
+                id = Device::get_id(self),
+                "Updating state to {:?}",
+                self.state().await
+            );
+
+            self.config
+                .callback
+                .call(self, self.state().await.deref())
+                .await;
+        }
+    }
+}
+
+#[async_trait]
+impl OnMqtt for Light<StateBrightness> {
+    async fn on_mqtt(&self, message: Publish) {
+        // Check if the message is from the deviec itself or from a remote
+        if matches(&message.topic, &self.config.mqtt.topic) {
+            let state = match serde_json::from_slice::<StateBrightness>(&message.payload) {
+                Ok(state) => state,
+                Err(err) => {
+                    warn!(id = Device::get_id(self), "Failed to parse message: {err}");
+                    return;
+                }
+            };
+
+            {
+                let current_state = self.state().await;
+                // No need to do anything if the state has not changed
+                if state.state == current_state.state
+                    && state.brightness == current_state.brightness
+                {
+                    return;
+                }
+            }
+
+            self.state_mut().await.state = state.state;
+            self.state_mut().await.brightness = state.brightness;
+            debug!(
+                id = Device::get_id(self),
+                "Updating state to {:?}",
+                self.state().await
+            );
+
+            self.config
+                .callback
+                .call(self, self.state().await.deref())
+                .await;
+        }
+    }
+}
+
+#[async_trait]
+impl<T: LightState> OnPresence for Light<T> {
+    async fn on_presence(&self, presence: bool) {
+        if !presence {
+            debug!(id = Device::get_id(self), "Turning device off");
+            self.set_on(false).await.ok();
+        }
+    }
+}
+
+impl<T: LightState> google_home::Device for Light<T> {
+    fn get_device_type(&self) -> Type {
+        Type::Light
+    }
+
+    fn get_device_name(&self) -> device::Name {
+        device::Name::new(&self.config.info.name)
+    }
+
+    fn get_id(&self) -> String {
+        Device::get_id(self)
+    }
+
+    fn is_online(&self) -> bool {
+        true
+    }
+
+    fn get_room_hint(&self) -> Option<&str> {
+        self.config.info.room.as_deref()
+    }
+
+    fn will_report_state(&self) -> bool {
+        // TODO: Implement state reporting
+        false
+    }
+}
+
+#[async_trait]
+impl<T> OnOff for Light<T>
+where
+    T: LightState,
+{
+    async fn on(&self) -> Result<bool, ErrorCode> {
+        let state = self.state().await;
+        let state: StateOnOff = state.deref().clone().into();
+        Ok(state.state)
+    }
+
+    async fn set_on(&self, on: bool) -> Result<(), ErrorCode> {
+        let message = json!({
+            "state": if on { "ON" } else { "OFF"}
+        });
+
+        debug!(id = Device::get_id(self), "{message}");
+
+        let topic = format!("{}/set", self.config.mqtt.topic);
+        // TODO: Handle potential errors here
+        self.config
+            .client
+            .publish(
+                &topic,
+                rumqttc::QoS::AtLeastOnce,
+                false,
+                serde_json::to_string(&message).unwrap(),
+            )
+            .await
+            .map_err(|err| warn!("Failed to update state on {topic}: {err}"))
+            .ok();
+
+        Ok(())
+    }
+}
+
+const FACTOR: f64 = 30.0;
+
+#[async_trait]
+impl<T> Brightness for Light<T>
+where
+    T: LightState,
+    T: Into<StateBrightness>,
+{
+    async fn brightness(&self) -> Result<u8, ErrorCode> {
+        let state = self.state().await;
+        let state: StateBrightness = state.deref().clone().into();
+        let brightness =
+            100.0 * f64::log10(state.brightness / FACTOR + 1.0) / f64::log10(254.0 / FACTOR + 1.0);
+
+        Ok(brightness.clamp(0.0, 100.0).round() as u8)
+    }
+
+    async fn set_brightness(&self, brightness: u8) -> Result<(), ErrorCode> {
+        let brightness =
+            FACTOR * ((FACTOR / (FACTOR + 254.0)).powf(-(brightness as f64) / 100.0) - 1.0);
+
+        let message = json!({
+            "brightness": brightness.clamp(0.0, 254.0).round() as u8
+        });
+
+        let topic = format!("{}/set", self.config.mqtt.topic);
+        // TODO: Handle potential errors here
+        self.config
+            .client
+            .publish(
+                &topic,
+                rumqttc::QoS::AtLeastOnce,
+                false,
+                serde_json::to_string(&message).unwrap(),
+            )
+            .await
+            .map_err(|err| warn!("Failed to update state on {topic}: {err}"))
+            .ok();
+
+        Ok(())
+    }
+}

automation_devices/src/zigbee/mod.rs

@@ -0,0 +1 @@
+pub mod light;

automation_lib/src/helpers/mod.rs

@@ -1,3 +1,4 @@
+pub mod serialization;
 mod timeout;
 
 pub use timeout::Timeout;

automation_lib/src/helpers/serialization.rs

@@ -0,0 +1,16 @@
+use serde::de::{self, Unexpected};
+use serde::{Deserialize, Deserializer};
+
+pub fn state_deserializer<'de, D>(deserializer: D) -> Result<bool, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    match String::deserialize(deserializer)?.as_ref() {
+        "ON" => Ok(true),
+        "OFF" => Ok(false),
+        other => Err(de::Error::invalid_value(
+            Unexpected::Str(other),
+            &"Value expected was either ON or OFF",
+        )),
+    }
+}

config.lua

@@ -155,8 +155,7 @@ automation.device_manager:add(IkeaRemote.new({
 	callback = set_kettle,
 }))
 
-automation.device_manager:add(IkeaOutlet.new({
+automation.device_manager:add(LightOnOff.new({
-	outlet_type = "Light",
 	name = "Light",
 	room = "Bathroom",
 	topic = mqtt_z2m("bathroom/light"),
@@ -215,6 +214,65 @@ automation.device_manager:add(HueSwitch.new({
 	end,
 }))
 
+local hallway_light_automation = {
+	timeout = Timeout.new(),
+	state = {
+		door_open = false,
+		trash_open = false,
+		forced = false,
+	},
+	switch_callback = function(self, on)
+		self.timeout:cancel()
+		self.group.set_on(on)
+		self.state.forced = on
+	end,
+	door_callback = function(self, open)
+		self.state.door_open = open
+		if open then
+			self.timeout:cancel()
+
+			self.group.set_on(true)
+		elseif not self.state.forced then
+			self.timeout:start(debug and 10 or 60, function()
+				if not self.state.trash_open then
+					self.group.set_on(false)
+				end
+			end)
+		end
+	end,
+	trash_callback = function(self, open)
+		self.state.trash_open = open
+		if open then
+			self.group.set_on(true)
+		else
+			if not self.timeout:is_waiting() and not self.state.door_open and not self.state.forced then
+				self.group.set_on(false)
+			end
+		end
+	end,
+	light_callback = function(self, on)
+		if on and not self.state.trash_open and not self.state.door_open then
+			-- If the door and trash are not open, that means the light got turned on manually
+			self.timeout:cancel()
+			self.state.forced = true
+		elseif not on then
+			-- The light is never forced when it is off
+			self.state.forced = false
+		end
+	end,
+}
+
+local hallway_storage = LightBrightness.new({
+	name = "Storage",
+	room = "Hallway",
+	topic = mqtt_z2m("hallway/storage"),
+	client = mqtt_client,
+	callback = function(_, state)
+		hallway_light_automation:light_callback(state.state)
+	end,
+})
+automation.device_manager:add(hallway_storage)
+
 local hallway_bottom_lights = HueGroup.new({
 	identifier = "hallway_bottom_lights",
 	ip = hue_ip,
@@ -225,42 +283,14 @@ local hallway_bottom_lights = HueGroup.new({
 })
 automation.device_manager:add(hallway_bottom_lights)
 
-local hallway_light_automation = {
+hallway_light_automation.group = {
-	group = hallway_bottom_lights,
+	set_on = function(on)
-	timeout = Timeout.new(),
+		if on then
-	state = {
+			hallway_storage:set_brightness(80)
-		door_open = false,
-		trash_open = false,
-		forced = false,
-	},
-	switch_callback = function(self, on)
-		self.timeout:cancel()
-		self.group:set_on(on)
-		self.state.forced = on
-	end,
-	door_callback = function(self, open)
-		self.state.door_open = open
-		if open then
-			self.timeout:cancel()
-
-			self.group:set_on(true)
-		elseif not self.state.forced then
-			self.timeout:start(debug and 10 or 60, function()
-				if not self.state.trash_open then
-					self.group:set_on(false)
-				end
-			end)
-		end
-	end,
-	trash_callback = function(self, open)
-		self.state.trash_open = open
-		if open then
-			self.group:set_on(true)
 		else
-			if not self.timeout:is_waiting() and not self.state.door_open and not self.state.forced then
+			hallway_storage:set_on(false)
-				self.group:set_on(false)
-			end
 		end
+		hallway_bottom_lights:set_on(on)
 	end,
 }
 
@@ -294,8 +324,7 @@ automation.device_manager:add(ContactSensor.new({
 	end,
 }))
 
-automation.device_manager:add(IkeaOutlet.new({
+automation.device_manager:add(LightOnOff.new({
-	outlet_type = "Light",
 	name = "Light",
 	room = "Guest",
 	topic = mqtt_z2m("guest/light"),