3 files changed, 145 insertions, 12 deletions

diff --git a/examples/binary_sensor.rs b/examples/binary_sensor.rs
new file mode 100644
index 0000000..2809255
--- /dev/null
+++ b/examples/binary_sensor.rs
@@ -0,0 +1,44 @@
+mod common;
+
+use common::AsyncTcp;
+use embassy_executor::{Executor, Spawner};
+use embassy_time::Timer;
+use static_cell::StaticCell;
+
+static RESOURCES: StaticCell<embassy_ha::DeviceResources> = StaticCell::new();
+
+#[embassy_executor::task]
+async fn main_task(spawner: Spawner) {
+    let mut stream = AsyncTcp::connect(std::env!("MQTT_ADDRESS"));
+
+    let mut device = embassy_ha::Device::new(
+        RESOURCES.init(Default::default()),
+        embassy_ha::DeviceConfig {
+            device_id: "example-device-id",
+            device_name: "Example Device Name",
+            manufacturer: "Example Device Manufacturer",
+            model: "Example Device Model",
+        },
+    );
+
+    let sensor = device.create_binary_sensor(
+        "binary-sensor-id",
+        "Binary Sensor",
+        embassy_ha::constants::HA_DEVICE_CLASS_BINARY_SENSOR_SMOKE,
+    );
+
+    spawner.must_spawn(binary_sensor_class(sensor));
+
+    device.run(&mut stream).await;
+}
+
+#[embassy_executor::task]
+async fn binary_sensor_class(mut switch: embassy_ha::BinarySensor<'static>) {
+    loop {
+        let state = switch.toggle();
+        println!("state = {}", state);
+        Timer::after_secs(2).await;
+    }
+}
+
+example_main!();
diff --git a/src/constants.rs b/src/constants.rs
index 6159e3d..b05d94c 100644
--- a/src/constants.rs
+++ b/src/constants.rs
@@ -129,3 +129,6 @@ pub const HA_ENTITY_CATEGORY_DIAGNOSTIC: &str = "diagnostic";
 
 pub const HA_SWITCH_STATE_ON: &str = "ON";
 pub const HA_SWITCH_STATE_OFF: &str = "OFF";
+
+pub const HA_BINARY_SENSOR_STATE_ON: &str = "ON";
+pub const HA_BINARY_SENSOR_STATE_OFF: &str = "OFF";
diff --git a/src/lib.rs b/src/lib.rs
index d954883..408dbb9 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -213,6 +213,13 @@ impl SwitchState {
             Self::Off => constants::HA_SWITCH_STATE_OFF,
         }
     }
+
+    pub fn flip(self) -> Self {
+        match self {
+            Self::On => Self::Off,
+            Self::Off => Self::On,
+        }
+    }
 }
 
 impl core::fmt::Display for SwitchState {
@@ -253,23 +260,13 @@ impl<'a> Switch<'a> {
     }
 
     pub fn toggle(&mut self) -> SwitchState {
-        let curr_state = self.state().unwrap_or(SwitchState::Off);
-        let new_state = match curr_state {
-            SwitchState::On => SwitchState::Off,
-            SwitchState::Off => SwitchState::On,
-        };
+        let new_state = self.state().unwrap_or(SwitchState::Off).flip();
         self.set(new_state);
         new_state
     }
 
     pub fn set(&mut self, state: SwitchState) {
-        self.0.publish(
-            match state {
-                SwitchState::On => constants::HA_SWITCH_STATE_ON,
-                SwitchState::Off => constants::HA_SWITCH_STATE_OFF,
-            }
-            .as_bytes(),
-        );
+        self.0.publish(state.as_str().as_bytes());
     }
 
     pub async fn wait(&mut self) -> SwitchState {
@@ -282,6 +279,79 @@ impl<'a> Switch<'a> {
     }
 }
 
+pub struct InvalidBinarySensorState;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum BinarySensorState {
+    On,
+    Off,
+}
+
+impl BinarySensorState {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            Self::On => constants::HA_BINARY_SENSOR_STATE_ON,
+            Self::Off => constants::HA_BINARY_SENSOR_STATE_OFF,
+        }
+    }
+
+    pub fn flip(self) -> Self {
+        match self {
+            Self::On => Self::Off,
+            Self::Off => Self::On,
+        }
+    }
+}
+
+impl core::fmt::Display for BinarySensorState {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.write_str(self.as_str())
+    }
+}
+
+impl FromStr for BinarySensorState {
+    type Err = InvalidBinarySensorState;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if s.eq_ignore_ascii_case(constants::HA_BINARY_SENSOR_STATE_ON) {
+            return Ok(Self::On);
+        }
+        if s.eq_ignore_ascii_case(constants::HA_BINARY_SENSOR_STATE_OFF) {
+            return Ok(Self::Off);
+        }
+        Err(InvalidBinarySensorState)
+    }
+}
+
+impl TryFrom<&[u8]> for BinarySensorState {
+    type Error = InvalidBinarySensorState;
+
+    fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
+        let string = str::from_utf8(value).map_err(|_| InvalidBinarySensorState)?;
+        string.parse()
+    }
+}
+
+pub struct BinarySensor<'a>(Entity<'a>);
+
+impl<'a> BinarySensor<'a> {
+    pub fn set(&mut self, state: BinarySensorState) {
+        self.0.publish(state.as_str().as_bytes());
+    }
+
+    pub fn value(&self) -> Option<BinarySensorState> {
+        self.0
+            .with_data(|data| BinarySensorState::try_from(data.publish_value.as_slice()))
+            .ok()
+    }
+
+    pub fn toggle(&mut self) -> BinarySensorState {
+        let new_state = self.value().unwrap_or(BinarySensorState::Off).flip();
+        self.set(new_state);
+        new_state
+    }
+}
+
 #[derive(Default)]
 pub struct EntityConfig {
     pub id: &'static str,
@@ -487,6 +557,22 @@ impl<'a> Device<'a> {
         Switch(entity)
     }
 
+    pub fn create_binary_sensor(
+        &self,
+        id: &'static str,
+        name: &'static str,
+        class: &'static str,
+    ) -> BinarySensor<'a> {
+        let entity = self.create_entity(EntityConfig {
+            id,
+            name,
+            domain: constants::HA_DOMAIN_BINARY_SENSOR,
+            device_class: Some(class),
+            ..Default::default()
+        });
+        BinarySensor(entity)
+    }
+
     pub async fn run<T: Transport>(&mut self, transport: &mut T) -> ! {
         loop {
             self.run_iteration(&mut *transport).await;