.gitignore

@@ -9,4 +9,3 @@ target/
 **/*.rs.bk
 
 .idea/
-*.iml

src/bluetooth.rs

@@ -1,15 +1,17 @@
-use bluer::gatt::remote::Characteristic;
+use std::collections::HashSet;
+use std::sync::mpsc::{channel, Sender};
+use std::time::Duration;
 use bluer::{Adapter, AdapterEvent, Address, Device, Result, Uuid};
 use futures::{pin_mut, StreamExt};
-use std::collections::HashSet;
+use tokio::task::spawn_blocking;
-use std::time::Duration;
 use tokio::sync::mpsc;
 
 // const CONNECT_RETRIES: u8 = 3;
 // const SERVICE_UUID: bluer::Uuid = bluer::Uuid::from_u128(0xadaf0900c33242a893bd25e905756cb8);
 // const PIXEL_DATA_UUID: bluer::Uuid = bluer::Uuid::from_u128(0xadaf0903c33242a893bd25e905756cb8);
 
-pub(crate) async fn create_session() -> Result<Adapter> {
+pub(crate) async fn create_session() -> Result<Adapter>
+{
     let session = bluer::Session::new().await?;
     let adapter_names = session.adapter_names().await?;
     let adapter_name = adapter_names.first().expect("no Bluetooth adapter found");
@@ -20,9 +22,10 @@ pub(crate) async fn create_session() -> Result<Adapter> {
 }
 
 async fn has_service(device: &Device, uuid: &Uuid) -> Result<bool> {
+
     let uuids = device.uuids().await?.unwrap_or_default();
     if uuids.contains(uuid) {
-        return Ok(true);
+        return Ok(true)
     }
     Ok(false)
 }
@@ -35,6 +38,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!("device adress {}", addr);
                 if already_scanned.contains(&addr) {
                     continue;
                 }
@@ -43,68 +47,40 @@ async fn bluetooth_scan(tx: mpsc::Sender<Device>, adapter: Adapter, uuid: Uuid)
                 match has_service(&device, &uuid).await {
                     Ok(service_found) => {
                         if service_found {
-                            tx.send(device).await.unwrap();
+                            tx.send(device).await;
                             println!("found service in device {}", addr);
                         }
                     }
-                    Err(_) => continue,
+                    Err(_) => { continue }
                 }
             }
             _ => {}
         }
     }
+
+    println!("ended");
     Ok(())
 }
 
-pub(crate) async fn scan_devices(adapter: Adapter, uuid: Uuid) -> Vec<Device> {
-    let (tx, mut rx) = mpsc::channel(4);
 
-    let timeout = tokio::time::timeout(Duration::from_secs(30), bluetooth_scan(tx, adapter, uuid));
+pub(crate) async fn scan_devices(adapter: Adapter, uuid: Uuid) -> Vec<Device> {
+    println!("start scanning devices");
+    let (tx, mut rx) = mpsc::channel(4);
+;
+    let timeout = tokio::time::timeout(Duration::from_secs(30), bluetooth_scan(tx, adapter, uuid)).await;
     let scan = tokio::spawn(timeout);
+    println!("good");
     let mut devices: Vec<Device> = Vec::new();
-    while let Some(device) = rx.recv().await {
+    while let Some(device)= rx.recv().await {
+        println!("new device received {}", device.address());
         devices.push(device);
+        println!("len {}", devices.len());
         if devices.len() >= 2 {
+            println!("drop");
             drop(scan);
             break;
         }
     }
 
     devices
-}
+}
-
-pub async fn connect(device: &Device, retries: u8) -> bluer::Result<()> {
-    if device.is_connected().await? {
-        return Ok(());
-    }
-    for i in 0..retries {
-        match device.connect().await {
-            Ok(()) => return Ok(()),
-            Err(_) => {
-                println!("connection error ({}), retry…", i);
-            }
-        }
-    }
-
-    Err(bluer::Error {
-        kind: bluer::ErrorKind::ConnectionAttemptFailed,
-        message: "all attempts fail".parse().unwrap(),
-    })
-}
-
-pub async fn get_char(
-    device: &Device,
-    service_uuid: Uuid,
-    char_uuid: Uuid,
-) -> Result<Option<Characteristic>> {
-    for service in device.services().await? {
-        if service_uuid == service.uuid().await? {
-            for char in service.characteristics().await? {
-                if char_uuid == char.uuid().await? {
-                    return Ok(Some(char));
-                }
-            }
-        }
-    }
-    Ok(None)
-}

src/main.rs

@@ -1,67 +1,35 @@
-mod bluetooth;
 mod patterns;
+mod bluetooth;
 
-use std::convert::TryFrom;
+use patterns::{PixelColor, Strip};
-use std::thread::sleep;
+use bluer::Device;
-use std::time::Duration;
 use bluer::gatt::remote::Characteristic;
-use patterns::Strip;
+use std::time::Duration;
-use tokio::sync::watch;
+use tokio::time::sleep;
-use crate::patterns::PixelColor;
+use crate::patterns::RainbowPattern;
 
 const SERVICE_UUID: bluer::Uuid = bluer::Uuid::from_u128(0xadaf0900c33242a893bd25e905756cb8);
 const PIXEL_DATA_UUID: bluer::Uuid = bluer::Uuid::from_u128(0xadaf0903c33242a893bd25e905756cb8);
 const STRIP_SIZE: usize = 25;
-const BASE_STRIP_DATA: [u8; 3] = [0x00, 0x00, 0x01];
+const BASE_STRIP_DATA : [u8; 3] = [0x00, 0x00, 0x01];
+
 
 #[tokio::main(flavor = "current_thread")]
 async fn main() -> bluer::Result<()> {
+
     let adapter = bluetooth::create_session().await?;
 
     let devices = bluetooth::scan_devices(adapter, SERVICE_UUID).await;
 
-    let mut pixels = Vec::<PixelColor>::new();
-
-    for _ in 0..STRIP_SIZE{
-        pixels.push(PixelColor{
-            red: 255, green: 0, blue:0
-        })
-    }
-
-
-    let strip  = Strip::<STRIP_SIZE> {
-        strip : <[PixelColor; 25]>::try_from(pixels).unwrap()
-    };
-
-    let (tx, rx) = watch::channel(Strip::<STRIP_SIZE>::default());
-
-
     for device in devices {
-        bluetooth::connect(&device, 3).await?;
+        println!("{:?}", device);
-        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() {
-                    println!("ok");
-                    let strip = rx_device.borrow().clone();
-                    write_strip(&strip, &char).await.unwrap();
-                }
-            });
-        }
     }
-    loop {
 
-        tx.send(strip);
-        tokio::time::sleep(Duration::from_secs(1)).await;
-        tx.send(Strip::<STRIP_SIZE>::default());
-        tokio::time::sleep(Duration::from_secs(1)).await;
 
-    }
+
+    Ok(())
 }
 
-// fn create_pattern_list() -> Vec<patterns>
 // async fn send_seq(char: &Characteristic) -> bluer::Result<()> {
 //     println!("  Characteristic flags : {:?}, ", char.flags().await?);
 //
@@ -82,15 +50,32 @@ async fn main() -> bluer::Result<()> {
 //     Ok(())
 // }
 
-pub async fn write_strip<const N: usize>(
+// pub async fn write_strip<const N: usize>(data: Strip<N>, char: &Characteristic) -> bluer::Result<()> {
-    data: &Strip<N>,
+//     let frame = [BASE_STRIP_DATA.to_vec(), data.to_array()].concat();
-    char: &Characteristic,
+//     print!("{:?}",frame);
-) -> bluer::Result<()> {
+//     char.write(&*frame).await?;
-    let frame = [BASE_STRIP_DATA.to_vec(), data.to_array()].concat();
+//     Ok(())
-    print!("{:?}", frame);
+// }
-    char.write(&*frame).await?;
+
-    Ok(())
+// async fn connect(device: &Device, retries: u8) -> bluer::Result<()> {
-}
+//     if device.is_connected().await? {
+//         return Ok(())
+//     }
+//     for i in 0..retries {
+//         match device.connect().await {
+//             Ok(()) => return Ok(()),
+//             Err(_) => {
+//                 println!("connection error ({}), retry…", i);
+//             }
+//         }
+//
+//     }
+//
+//     Err(bluer::Error {
+//         kind: bluer::ErrorKind::ConnectionAttemptFailed,
+//         message: "all attempts fail".parse().unwrap(),
+//     })
+// }
 
 // async fn find_neopixel_service(device: &Device) -> bluer::Result<Option<Characteristic>> {
 //     let addr = device.address();
@@ -123,4 +108,4 @@ pub async fn write_strip<const N: usize>(
 //     }
 //
 //     Ok(None)
-// }
+// }

src/patterns.rs

@@ -1,113 +1,33 @@
-use std::fmt;
+use bluer::gatt::remote::Characteristic;
 
-#[derive(Clone, Copy, Debug)]
+const BASE_STRIP_DATA : [u8; 5] = [0x0, 0x0, 0x0, 0x0, 0x1];
-pub struct PixelColor {
+
+#[derive(Clone, Copy)]
+pub(crate) struct PixelColor {
     pub(crate) red: u8,
     pub(crate) green: u8,
     pub(crate) blue: u8,
 }
 
-impl PixelColor {
-    fn new() -> Self {
-        Default::default()
-    }
-}
 
-impl fmt::Display for PixelColor {
+pub(crate) struct Strip<const N: usize> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "[{},{},{}]", self.red, self.green, self.blue)
-    }
-}
-
-
-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> {
-        let mut data: Vec<u8> = vec![];
+        let mut data : Vec<u8> = vec![];
 
         for i in 0..N {
-            data.append(&mut vec![
+            data.append(&mut vec![self.strip[i].red, self.strip[i].green, self.strip[i].blue]);
-                self.strip[i].red,
-                self.strip[i].green,
-                self.strip[i].blue,
-            ]);
         }
         data
     }
 }
 
-impl<const N: usize> Default for Strip<N> {
+async fn write_strip<const N: usize>(data: Strip<N>, char: Characteristic) -> bluer::Result<()> {
-    fn default() -> Self {
+    let mut frame= BASE_STRIP_DATA.to_vec();
-        Strip {
+    frame.append(&mut data.to_array());
-            strip: [PixelColor::new(); N],
+    char.write(&*frame).await?;
-        }
+    Ok(())
-    }
-}
-
-pub struct RainbowPattern<const N: usize> {
-    pub(crate) current_iteration: usize,
-    pub(crate) max_iteration: Option<usize>,
-}
-
-impl<const N: usize> Iterator for RainbowPattern<N> {
-    type Item = Strip<N>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        if let Some(nbr_iteration) = self.max_iteration {
-            if nbr_iteration == self.current_iteration {
-                return None;
-            }
-        }
-        let mut strip = Strip::default();
-        let step = 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;
-        Some(strip)
-    }
-}
-
-fn wheel(index: u8) -> PixelColor {
-    let pos = 255 - index;
-    match pos {
-        0..=85 => PixelColor {
-            red: 255 - (pos * 3),
-            green: 0,
-            blue: pos * 3,
-        },
-        86..=170 => {
-            let pos = pos - 85;
-            PixelColor {
-                red: 0,
-                green: pos * 3,
-                blue: 255 - (pos * 3),
-            }
-        }
-        _ => {
-            let pos = pos - 170;
-            return PixelColor {
-                red: pos * 3,
-                green: 255 - (pos * 3),
-                blue: 0,
-            };
-        }
-    }
 }