add hotreplug function for devices

src/bluetooth.rs

@@ -27,7 +27,11 @@ async fn has_service(device: &Device, uuid: &Uuid) -> Result<bool> {
     Ok(false)
 }
 
-async fn bluetooth_scan(tx: mpsc::Sender<Device>, adapter: Adapter, uuid: Uuid) -> Result<()> {
+pub(crate) async fn bluetooth_scan(
+    tx: mpsc::Sender<Device>,
+    adapter: Adapter,
+    uuid: Uuid,
+) -> Result<()> {
     println!("start bluetooth scan");
     let discover = adapter.discover_devices().await?;
     let mut already_scanned: HashSet<Address> = HashSet::new();
@@ -35,6 +39,7 @@ async fn bluetooth_scan(tx: mpsc::Sender<Device>, adapter: Adapter, uuid: Uuid)
     while let Some(evt) = discover.next().await {
         match evt {
             AdapterEvent::DeviceAdded(addr) => {
+                println!("new device {}", addr);
                 if already_scanned.contains(&addr) {
                     continue;
                 }
@@ -50,7 +55,12 @@ async fn bluetooth_scan(tx: mpsc::Sender<Device>, adapter: Adapter, uuid: Uuid)
                     Err(_) => continue,
                 }
             }
-            _ => {}
+            AdapterEvent::DeviceRemoved(addr) => {
+                already_scanned.remove(&addr);
+                adapter.remove_device(addr).await;
+                println!("device {} removed", addr);
+            }
+            AdapterEvent::PropertyChanged(_) => {}
         }
     }
     Ok(())

src/main.rs

@@ -1,13 +1,12 @@
 mod bluetooth;
 mod patterns;
 
-use crate::patterns::PixelColor;
+use crate::patterns::{ColorWipe, Fade, PixelColor, Rainbow};
 use bluer::gatt::remote::Characteristic;
 use patterns::Strip;
-use std::convert::TryFrom;
 use std::time::Duration;
+use tokio::sync::mpsc;
 use tokio::sync::watch;
-use tokio::sync::watch::error::SendError;
 
 const SERVICE_UUID: bluer::Uuid = bluer::Uuid::from_u128(0xadaf0900c33242a893bd25e905756cb8);
 const PIXEL_DATA_UUID: bluer::Uuid = bluer::Uuid::from_u128(0xadaf0903c33242a893bd25e905756cb8);
@@ -18,10 +17,39 @@ const BASE_STRIP_DATA: [u8; 3] = [0x00, 0x00, 0x01];
 async fn main() -> bluer::Result<()> {
     let adapter = bluetooth::create_session().await?;
 
-    let devices = bluetooth::scan_devices(adapter, SERVICE_UUID).await;
+    let (tx_scan, mut rx_scan) = mpsc::channel(3);
+
+    tokio::spawn(bluetooth::bluetooth_scan(
+        tx_scan,
+        adapter.clone(),
+        SERVICE_UUID,
+    ));
+
+    let (tx, rx) = watch::channel(Strip::<STRIP_SIZE>::default());
+
+    tokio::spawn(async move {
+        while let Some(device) = rx_scan.recv().await {
+            bluetooth::connect(&device, 3).await?;
+            let char = bluetooth::get_char(&device, SERVICE_UUID, PIXEL_DATA_UUID).await?;
+            if let Some(char) = char {
+                let mut rx_device = rx.clone();
+                tokio::spawn(async move {
+                    println!("device connected : {}", &device.address());
+                    while rx_device.changed().await.is_ok() {
+                        let strip = *rx_device.borrow();
+                        if write_strip(&strip, &char).await.is_err() {
+                            break;
+                        };
+                    }
+                    println!("device {} disconnected", &device.address());
+                    // drop(rx_device);
+                });
+            }
+        }
+        bluer::Result::Ok(())
+    });
 
     let mut pixels = Vec::<PixelColor>::new();
-
     for _ in 0..STRIP_SIZE {
         pixels.push(PixelColor {
             red: 255,
@@ -30,43 +58,53 @@ async fn main() -> bluer::Result<()> {
         })
     }
 
-    let strip = Strip::<STRIP_SIZE> {
+    let mut _colorwipe = ColorWipe::<25> {
-        strip: <[PixelColor; 25]>::try_from(pixels).unwrap(),
+        current_iteration: 0,
+        color: PixelColor {
+            red: 0,
+            green: 255,
+            blue: 0,
+        },
+        infinite: true,
     };
 
-    let (tx, rx) = watch::channel(Strip::<STRIP_SIZE>::default());
+    let mut fade = Fade::<25> {
+        current_iteration: 0,
+        nbr_iterations: 25,
+        begin_color: PixelColor {
+            red: 255,
+            green: 0,
+            blue: 0,
+        },
+        end_color: PixelColor {
+            red: 0,
+            green: 0,
+            blue: 255,
+        },
+    };
 
-    for device in devices {
+    let mut pattern = Rainbow::<25> {
-        bluetooth::connect(&device, 3).await?;
+        current_iteration: 0,
-        let char = bluetooth::get_char(&device, SERVICE_UUID, PIXEL_DATA_UUID).await?;
+        max_iteration: None,
-        if let Some(char) = char {
+        step: Some(10),
-            let mut rx_device = rx.clone();
+    };
-            tokio::spawn(async move {
+
-                println!("device connected : {}", &device.address());
+    let mut strip = fade.next().unwrap();
-                while rx_device.changed().await.is_ok() {
+    tokio::time::sleep(Duration::from_secs(5)).await;
-                    println!("ok");
+    println!("starting");
-                    let strip = rx_device.borrow().clone();
+    while tx.send(strip).is_ok() {
-                    write_strip(&strip, &char).await.unwrap();
+        if let Some(value) = fade.next() {
-                }
+            strip = value;
-            });
+        } else {
-        }
-    }
-    loop {
-        match tx.send(strip) {
-            Ok(_) => {}
-            Err(_) => {
             break;
         }
+        tokio::time::sleep(Duration::from_millis(1000)).await;
     }
-        tokio::time::sleep(Duration::from_secs(1)).await;
+    println!("starting rainbow");
-        match tx.send(Strip::<STRIP_SIZE>::default()) {
+    while tx.send(pattern.next().unwrap()).is_ok() {
-            Ok(_) => {}
+        tokio::time::sleep(Duration::from_millis(100)).await;
-            Err(_) => {
-                break;
-            }
-        }
-        tokio::time::sleep(Duration::from_secs(1)).await;
     }
+    println!("error sending value");
     Ok(())
 }
 
@@ -96,7 +134,7 @@ pub async fn write_strip<const N: usize>(
     char: &Characteristic,
 ) -> bluer::Result<()> {
     let frame = [BASE_STRIP_DATA.to_vec(), data.to_array()].concat();
-    print!("{:?}", frame);
+    // print!("{:?}", frame);
     char.write(&*frame).await?;
     Ok(())
 }

src/patterns.rs

@@ -1,6 +1,6 @@
 use std::fmt;
 
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, Default)]
 pub struct PixelColor {
     pub(crate) red: u8,
     pub(crate) green: u8,
@@ -19,34 +19,28 @@ impl fmt::Display for PixelColor {
     }
 }
 
-impl Default for PixelColor {
-    fn default() -> Self {
-        PixelColor {
-            red: 0,
-            green: 0,
-            blue: 0,
-        }
-    }
-}
-
 #[derive(Copy, Clone)]
 pub struct Strip<const N: usize> {
     pub strip: [PixelColor; N],
 }
 
 impl<const N: usize> Strip<N> {
-    pub fn to_array(&self) -> Vec<u8> {
+    pub fn to_array(self) -> Vec<u8> {
         let mut data: Vec<u8> = vec![];
 
         for i in 0..N {
             data.append(&mut vec![
-                self.strip[i].red,
                 self.strip[i].green,
+                self.strip[i].red,
                 self.strip[i].blue,
             ]);
         }
         data
     }
+
+    pub fn fill(&mut self, color: PixelColor) {
+        self.strip = [color; N];
+    }
 }
 
 impl<const N: usize> Default for Strip<N> {
@@ -57,12 +51,15 @@ impl<const N: usize> Default for Strip<N> {
     }
 }
 
-pub struct RainbowPattern<const N: usize> {
+/// Rainbow pattern /////////////////////////////////////////////////
+
+pub struct Rainbow<const N: usize> {
     pub(crate) current_iteration: usize,
     pub(crate) max_iteration: Option<usize>,
+    pub(crate) step: Option<usize>,
 }
 
-impl<const N: usize> Iterator for RainbowPattern<N> {
+impl<const N: usize> Iterator for Rainbow<N> {
     type Item = Strip<N>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -72,12 +69,12 @@ impl<const N: usize> Iterator for RainbowPattern<N> {
             }
         }
         let mut strip = Strip::default();
-        let step = 255 / N;
+        let step = self.step.unwrap_or(255 / N);
         for i in 0..N {
             let pos = (i * step + self.current_iteration) as u8;
             strip.strip[i] = wheel(pos)
         }
-        self.current_iteration = self.current_iteration + 1;
+        self.current_iteration += 1;
         Some(strip)
     }
 }
@@ -100,11 +97,93 @@ fn wheel(index: u8) -> PixelColor {
         }
         _ => {
             let pos = pos - 170;
-            return PixelColor {
+            PixelColor {
                 red: pos * 3,
                 green: 255 - (pos * 3),
                 blue: 0,
-            };
             }
         }
     }
+}
+
+//////////////////////////////////////////////////////////////////////////
+/// Colorwipe pattern ////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////
+
+pub struct ColorWipe<const N: usize> {
+    pub(crate) current_iteration: usize,
+    pub(crate) color: PixelColor,
+    pub(crate) infinite: bool,
+}
+
+impl<const N: usize> Iterator for ColorWipe<N> {
+    type Item = Strip<N>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let mut strip = Strip::default();
+        if self.infinite {
+            self.current_iteration %= N;
+        } else if self.current_iteration >= N {
+            return None;
+        }
+
+        for i in 0..self.current_iteration {
+            strip.strip[i] = self.color;
+        }
+        self.current_iteration += 1;
+        Some(strip)
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////
+/// fade pattern ////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////
+
+pub struct Fade<const N: usize> {
+    pub(crate) current_iteration: usize,
+    pub(crate) nbr_iterations: usize,
+    pub(crate) begin_color: PixelColor,
+    pub(crate) end_color: PixelColor,
+}
+
+fn fade_value(value_start: u8, value_end: u8, index: usize, nbr_iter: usize) -> u8 {
+    ((value_start as usize * (nbr_iter - index) + value_end as usize * index) / nbr_iter) as u8
+}
+
+impl<const N: usize> Iterator for Fade<N> {
+    type Item = Strip<N>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let mut strip = Strip::default();
+
+        if self.current_iteration >= self.nbr_iterations {
+            return None;
+        }
+
+        let red = fade_value(
+            self.begin_color.red,
+            self.end_color.red,
+            self.current_iteration,
+            self.nbr_iterations,
+        );
+        let green = fade_value(
+            self.begin_color.green,
+            self.end_color.green,
+            self.current_iteration,
+            self.nbr_iterations,
+        );
+        let blue = fade_value(
+            self.begin_color.blue,
+            self.end_color.blue,
+            self.current_iteration,
+            self.nbr_iterations,
+        );
+
+        let current_color = PixelColor { red, green, blue };
+
+        strip.fill(current_color);
+
+        self.current_iteration += 1;
+        Some(strip)
+    }
+}