added more examples

9 files changed, 329 insertions, 132 deletions

diff --git a/.envrc.template b/.envrc.template
new file mode 100644
index 0000000..f6a7db7
--- /dev/null
+++ b/.envrc.template
@@ -0,0 +1 @@
+export MQTT_ADDRESS=""
diff --git a/.gitignore b/.gitignore
index f2564bc..786bc7e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,3 @@
 .DS_Store
+.envrc
 target/
diff --git a/Cargo.lock b/Cargo.lock
index 61ede9e..5bc99f3 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -161,6 +161,7 @@ dependencies = [
  "embedded-io-async",
  "embedded-mqtt",
  "heapless 0.9.2",
+ "rand",
  "serde",
  "serde-json-core",
  "static_cell",
@@ -331,6 +332,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7"
 
 [[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+ "wasip2",
+]
+
+[[package]]
 name = "hash32"
 version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -368,6 +381,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
 
 [[package]]
+name = "libc"
+version = "0.2.178"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37c93d8daa9d8a012fd8ab92f088405fb202ea0b6ab73ee2482ae66af4f42091"
+
+[[package]]
 name = "litrs"
 version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -401,6 +420,15 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"
 
 [[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
 name = "proc-macro-error-attr2"
 version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -441,6 +469,41 @@ dependencies = [
 ]
 
 [[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "rand"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
+dependencies = [
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
 name = "ryu"
 version = "1.0.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -564,3 +627,38 @@ name = "void"
 version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
+
+[[package]]
+name = "wasip2"
+version = "1.0.1+wasi-0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wit-bindgen"
+version = "0.46.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59"
+
+[[package]]
+name = "zerocopy"
+version = "0.8.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd74ec98b9250adb3ca554bdde269adf631549f51d8a8f8f0a10b50f1cb298c3"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8a8d209fdf45cf5138cbb5a506f6b52522a25afccc534d1475dad8e31105c6a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
diff --git a/Cargo.toml b/Cargo.toml
index d37e957..6a9ea4f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -22,3 +22,4 @@ embassy-sync = { version = "0.7.2" }
 static_cell = "2.1.1"
 embedded-io-async = { version = "0.6", features = ["std"] }
 critical-section = { version = "1", features = ["std"] }
+rand = "0.9.2"
diff --git a/examples/button.rs b/examples/button.rs
new file mode 100644
index 0000000..cfef3e3
--- /dev/null
+++ b/examples/button.rs
@@ -0,0 +1,38 @@
+mod common;
+
+use common::AsyncTcp;
+use embassy_executor::{Executor, Spawner};
+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 button = device.create_button("button-sensor-id", "Button Name");
+
+    spawner.must_spawn(button_task(button));
+
+    device.run(&mut stream).await;
+}
+
+#[embassy_executor::task]
+async fn button_task(mut button: embassy_ha::Button<'static>) {
+    loop {
+        button.pressed().await;
+        println!("The button has been pressed");
+    }
+}
+
+example_main!();
diff --git a/examples/common/mod.rs b/examples/common/mod.rs
new file mode 100644
index 0000000..fd61e9d
--- /dev/null
+++ b/examples/common/mod.rs
@@ -0,0 +1,18 @@
+mod std_async_tcp;
+use embassy_executor::Executor;
+use static_cell::StaticCell;
+pub use std_async_tcp::AsyncTcp;
+
+pub static EXECUTOR: StaticCell<Executor> = StaticCell::new();
+
+#[macro_export]
+macro_rules! example_main {
+    () => {
+        fn main() {
+            let executor = common::EXECUTOR.init(Executor::new());
+            executor.run(|spawner| {
+                spawner.must_spawn(main_task(spawner));
+            });
+        }
+    };
+}
diff --git a/examples/common/std_async_tcp.rs b/examples/common/std_async_tcp.rs
new file mode 100644
index 0000000..bd97fa9
--- /dev/null
+++ b/examples/common/std_async_tcp.rs
@@ -0,0 +1,125 @@
+use std::{
+    io::{Read, Write},
+    net::{TcpStream, ToSocketAddrs},
+    sync::{Arc, Mutex},
+    thread::JoinHandle,
+};
+
+use embassy_sync::waitqueue::AtomicWaker;
+
+pub struct AsyncTcp {
+    write_handle: JoinHandle<()>,
+    write_buffer: Arc<Mutex<Vec<u8>>>,
+    read_buffer: Arc<Mutex<Vec<u8>>>,
+    waker: Arc<AtomicWaker>,
+}
+
+impl AsyncTcp {
+    pub fn connect(addr: impl ToSocketAddrs) -> Self {
+        let stream = TcpStream::connect(addr).expect("failed to connect to remote");
+        let mut read_stream = stream.try_clone().unwrap();
+        let mut write_stream = stream;
+
+        let read_buffer: Arc<Mutex<Vec<u8>>> = Default::default();
+        let write_buffer: Arc<Mutex<Vec<u8>>> = Default::default();
+
+        let waker = Arc::new(AtomicWaker::new());
+
+        let write_handle = std::thread::spawn({
+            let write_buffer = write_buffer.clone();
+            move || {
+                loop {
+                    let buffer = {
+                        let mut buffer = write_buffer.lock().unwrap();
+                        std::mem::take(&mut *buffer)
+                    };
+                    if !buffer.is_empty() {
+                        println!("writing {} bytes", buffer.len());
+                        write_stream.write_all(&buffer).unwrap();
+                        write_stream.flush().unwrap();
+                    } else {
+                        std::thread::park();
+                    }
+                }
+            }
+        });
+
+        std::thread::spawn({
+            let read_buffer = read_buffer.clone();
+            let waker = waker.clone();
+            move || {
+                let mut scratch = [0u8; 1024];
+                loop {
+                    let n = read_stream.read(&mut scratch).unwrap();
+                    if n == 0 {
+                        panic!("EOF");
+                    }
+
+                    {
+                        let mut buffer = read_buffer.lock().unwrap();
+                        buffer.extend_from_slice(&scratch[..n]);
+                        waker.wake();
+                    }
+                }
+            }
+        });
+
+        Self {
+            write_handle,
+            write_buffer,
+            read_buffer,
+            waker,
+        }
+    }
+}
+
+impl embedded_io_async::ErrorType for AsyncTcp {
+    type Error = std::io::Error;
+}
+
+impl embedded_io_async::Write for AsyncTcp {
+    async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
+        {
+            let mut buffer = self.write_buffer.lock().unwrap();
+            buffer.extend_from_slice(buf);
+        }
+        self.write_handle.thread().unpark();
+        Ok(buf.len())
+    }
+}
+
+impl embedded_io_async::Read for AsyncTcp {
+    async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
+        struct WaitForWaker<'a>(&'a AtomicWaker, bool);
+
+        impl<'a> Future for WaitForWaker<'a> {
+            type Output = ();
+
+            fn poll(
+                mut self: std::pin::Pin<&mut Self>,
+                cx: &mut std::task::Context<'_>,
+            ) -> std::task::Poll<Self::Output> {
+                if self.1 {
+                    std::task::Poll::Ready(())
+                } else {
+                    self.as_mut().1 = true;
+                    self.0.register(cx.waker());
+                    std::task::Poll::Pending
+                }
+            }
+        }
+
+        loop {
+            {
+                let mut buffer = self.read_buffer.lock().unwrap();
+                if !buffer.is_empty() {
+                    let copy_n = buf.len().min(buffer.len());
+                    buf[..copy_n].copy_from_slice(&buffer[..copy_n]);
+                    buffer.drain(..copy_n);
+                    return Ok(copy_n);
+                }
+            }
+            WaitForWaker(&self.waker, false).await
+        }
+    }
+}
diff --git a/examples/constant-temperature.rs b/examples/constant-temperature.rs
index 27e1076..fed76e5 100644
--- a/examples/constant-temperature.rs
+++ b/examples/constant-temperature.rs
@@ -1,138 +1,15 @@
-use std::{
-    io::{Read, Write},
-    net::{TcpStream, ToSocketAddrs},
-    sync::{Arc, Mutex},
-    thread::JoinHandle,
-};
+mod common;
 
+use common::AsyncTcp;
 use embassy_executor::{Executor, Spawner};
-use embassy_sync::waitqueue::AtomicWaker;
 use embassy_time::Timer;
 use static_cell::StaticCell;
 
-static EXECUTOR: StaticCell<Executor> = StaticCell::new();
 static RESOURCES: StaticCell<embassy_ha::DeviceResources> = StaticCell::new();
 
-struct AsyncTcp {
-    write_handle: JoinHandle<()>,
-    write_buffer: Arc<Mutex<Vec<u8>>>,
-    read_buffer: Arc<Mutex<Vec<u8>>>,
-    waker: Arc<AtomicWaker>,
-}
-
-impl AsyncTcp {
-    fn connect(addr: impl ToSocketAddrs) -> Self {
-        let stream = TcpStream::connect(addr).expect("failed to connect to remote");
-        let mut read_stream = stream.try_clone().unwrap();
-        let mut write_stream = stream;
-
-        let read_buffer: Arc<Mutex<Vec<u8>>> = Default::default();
-        let write_buffer: Arc<Mutex<Vec<u8>>> = Default::default();
-
-        let waker = Arc::new(AtomicWaker::new());
-
-        let write_handle = std::thread::spawn({
-            let write_buffer = write_buffer.clone();
-            move || {
-                loop {
-                    let buffer = {
-                        let mut buffer = write_buffer.lock().unwrap();
-                        std::mem::take(&mut *buffer)
-                    };
-                    if !buffer.is_empty() {
-                        println!("writing {} bytes", buffer.len());
-                        write_stream.write_all(&buffer).unwrap();
-                        write_stream.flush().unwrap();
-                    } else {
-                        std::thread::park();
-                    }
-                }
-            }
-        });
-
-        std::thread::spawn({
-            let read_buffer = read_buffer.clone();
-            let waker = waker.clone();
-            move || {
-                let mut scratch = [0u8; 1024];
-                loop {
-                    let n = read_stream.read(&mut scratch).unwrap();
-                    if n == 0 {
-                        panic!("EOF");
-                    }
-
-                    {
-                        let mut buffer = read_buffer.lock().unwrap();
-                        buffer.extend_from_slice(&scratch[..n]);
-                        waker.wake();
-                    }
-                }
-            }
-        });
-
-        Self {
-            write_handle,
-            write_buffer,
-            read_buffer,
-            waker,
-        }
-    }
-}
-
-impl embedded_io_async::ErrorType for AsyncTcp {
-    type Error = std::io::Error;
-}
-
-impl embedded_io_async::Write for AsyncTcp {
-    async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
-        {
-            let mut buffer = self.write_buffer.lock().unwrap();
-            buffer.extend_from_slice(buf);
-        }
-        self.write_handle.thread().unpark();
-        Ok(buf.len())
-    }
-}
-
-impl embedded_io_async::Read for AsyncTcp {
-    async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
-        struct WaitForWaker<'a>(&'a AtomicWaker, bool);
-
-        impl<'a> Future for WaitForWaker<'a> {
-            type Output = ();
-
-            fn poll(
-                mut self: std::pin::Pin<&mut Self>,
-                cx: &mut std::task::Context<'_>,
-            ) -> std::task::Poll<Self::Output> {
-                if self.1 {
-                    std::task::Poll::Ready(())
-                } else {
-                    self.as_mut().1 = true;
-                    self.0.register(cx.waker());
-                    std::task::Poll::Pending
-                }
-            }
-        }
-
-        loop {
-            {
-                let mut buffer = self.read_buffer.lock().unwrap();
-                if !buffer.is_empty() {
-                    let copy_n = buf.len().min(buffer.len());
-                    buf[..copy_n].copy_from_slice(&buffer[..copy_n]);
-                    buffer.drain(..copy_n);
-                    return Ok(copy_n);
-                }
-            }
-            WaitForWaker(&self.waker, false).await
-        }
-    }
-}
-
 #[embassy_executor::task]
 async fn main_task(spawner: Spawner) {
-    let mut stream = AsyncTcp::connect("mqtt.d464.sh:1883");
+    let mut stream = AsyncTcp::connect(std::env!("MQTT_ADDRESS"));
 
     let mut device = embassy_ha::Device::new(
         RESOURCES.init(Default::default()),
@@ -163,9 +40,4 @@ async fn temperature(mut sensor: embassy_ha::TemperatureSensor<'static>) {
     }
 }
 
-fn main() {
-    let executor = EXECUTOR.init(Executor::new());
-    executor.run(|spawner| {
-        spawner.must_spawn(main_task(spawner));
-    });
-}
+example_main!();
diff --git a/examples/random-temperature.rs b/examples/random-temperature.rs
new file mode 100644
index 0000000..2bcae57
--- /dev/null
+++ b/examples/random-temperature.rs
@@ -0,0 +1,43 @@
+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 temperature_sensor = device.create_temperature_sensor(
+        "temperature-sensor-id",
+        "Temperature Sensor Name",
+        embassy_ha::TemperatureUnit::Celcius,
+    );
+
+    spawner.must_spawn(temperature(temperature_sensor));
+
+    device.run(&mut stream).await;
+}
+
+#[embassy_executor::task]
+async fn temperature(mut sensor: embassy_ha::TemperatureSensor<'static>) {
+    loop {
+        sensor.publish(rand::random_range(0.0..50.0));
+        Timer::after_secs(1).await;
+    }
+}
+
+example_main!();