feat: (WIP) Add support to nannou_laser for lasercube devices

Cargo.toml

@@ -49,6 +49,7 @@ hrtf = "0.8"
 ilda-idtf = "0.1"
 image = { version = "0.25", default-features = false }
 isf = "0.1.0"
+lasercube = { path = "../lasercube/crates/lasercube" }
 lasy = "0.4"
 lyon = "1.0"
 noise = "0.7"

nannou_laser/Cargo.toml

@@ -16,6 +16,7 @@ crate-type = ["rlib", "staticlib", "cdylib"]
 [dependencies]
 ether-dream.workspace = true
 ilda-idtf = { workspace = true, optional = true }
+lasercube.workspace = true
 lasy.workspace = true
 thiserror.workspace = true
 

nannou_laser/src/dac.rs

@@ -1,5 +1,6 @@
 //! Items related to DACs and DAC detection.
 
+use crate::protocol;
 use std::io;
 use std::sync::atomic::{self, AtomicBool};
 use std::sync::mpsc;
@@ -15,17 +16,16 @@ impl<F> DetectedDacCallback for F where F: FnMut(io::Result<DetectedDac>) {}
 /// It should be possible to use this to uniquely identify the same DAC on different occasions.
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub enum Id {
-    EtherDream { mac_address: [u8; 6] },
+    EtherDream(protocol::etherdream::Id),
+    LaserCube(protocol::lasercube::Id),
 }
 
 /// An available DAC detected on the system.
 #[derive(Clone, Debug)]
 pub enum DetectedDac {
     /// An ether dream laser DAC discovered via the ether dream protocol broadcast message.
-    EtherDream {
-        broadcast: ether_dream::protocol::DacBroadcast,
-        source_addr: std::net::SocketAddr,
-    },
+    EtherDream(protocol::etherdream::DetectedDac),
+    LaserCube(protocol::lasercube::DetectedDac),
 }
 
 /// An iterator yielding laser DACs available on the system as they are discovered.
@@ -51,25 +51,28 @@ impl DetectedDac {
     /// The maximum point rate allowed by the DAC.
     pub fn max_point_hz(&self) -> u32 {
         match self {
-            DetectedDac::EtherDream { ref broadcast, .. } => broadcast.max_point_rate as _,
+            DetectedDac::EtherDream(dac) => dac.max_point_hz(),
+            DetectedDac::LaserCube(dac) => dac.max_point_hz(),
         }
     }
 
     /// The number of points that can be stored within the buffer.
     pub fn buffer_capacity(&self) -> u32 {
         match self {
-            DetectedDac::EtherDream { ref broadcast, .. } => broadcast.buffer_capacity as _,
+            DetectedDac::EtherDream(dac) => dac.buffer_capacity(),
+            DetectedDac::LaserCube(dac) => dac.buffer_capacity(),
         }
     }
 
-    /// A persistent, unique identifier associated with the DAC (like a MAC address).
+    /// A persistent, unique identifier associated with the DAC (like a MAC
+    /// address).
     ///
-    /// It should be possible to use this to uniquely identify the same DAC on different occasions.
+    /// It should be possible to use this to uniquely identify the same DAC on
+    /// different occasions.
     pub fn id(&self) -> Id {
         match self {
-            DetectedDac::EtherDream { ref broadcast, .. } => Id::EtherDream {
-                mac_address: broadcast.mac_address,
-            },
+            DetectedDac::EtherDream(dac) => Id::EtherDream(dac.id()),
+            DetectedDac::LaserCube(dac) => Id::LaserCube(dac.id()),
         }
     }
 }
@@ -108,10 +111,12 @@ impl Iterator for DetectDacs {
         let res = self.dac_broadcasts.next()?;
         match res {
             Err(err) => Some(Err(err)),
-            Ok((broadcast, source_addr)) => Some(Ok(DetectedDac::EtherDream {
-                broadcast,
-                source_addr,
-            })),
+            Ok((broadcast, source_addr)) => Some(Ok(DetectedDac::EtherDream(
+                protocol::etherdream::DetectedDac {
+                    broadcast,
+                    source_addr,
+                },
+            ))),
         }
     }
 }

nannou_laser/src/lib.rs

@@ -19,6 +19,7 @@ pub mod ffi;
 #[cfg(feature = "ilda-idtf")]
 pub mod ilda_idtf;
 pub mod point;
+pub mod protocol;
 pub mod stream;
 pub mod util;
 

nannou_laser/src/protocol.rs

@@ -0,0 +1,4 @@
+//! Implementations for each supported protocol (etherdream, lasercube).
+
+pub mod etherdream;
+pub mod lasercube;

nannou_laser/src/protocol/etherdream.rs

@@ -0,0 +1,29 @@
+// Represent etherdream device IDs by their MAC address.
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Id {
+    pub mac_address: [u8; 6],
+}
+
+/// An ether dream laser DAC discovered via the ether dream protocol broadcast
+/// message.
+#[derive(Clone, Debug)]
+pub struct DetectedDac {
+    pub broadcast: ether_dream::protocol::DacBroadcast,
+    pub source_addr: std::net::SocketAddr,
+}
+
+impl DetectedDac {
+    pub fn max_point_hz(&self) -> u32 {
+        self.broadcast.max_point_rate as u32
+    }
+
+    pub fn buffer_capacity(&self) -> u32 {
+        self.broadcast.buffer_capacity as u32
+    }
+
+    pub fn id(&self) -> Id {
+        Id {
+            mac_address: self.broadcast.mac_address,
+        }
+    }
+}

nannou_laser/src/protocol/lasercube.rs

@@ -0,0 +1,28 @@
+// Represent lasercube device IDs by their serial number.
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Id {
+    pub serial_number: [u8; 6],
+}
+
+/// A lasercube discovered via a `GET_FULL_INFO` response.
+#[derive(Clone, Debug)]
+pub struct DetectedDac {
+    info: lasercube::core::LaserInfo,
+    source_addr: std::net::SocketAddr,
+}
+
+impl DetectedDac {
+    pub fn max_point_hz(&self) -> u32 {
+        self.info.header.max_dac_rate
+    }
+
+    pub fn buffer_capacity(&self) -> u32 {
+        self.info.header.rx_buffer_size as u32
+    }
+
+    pub fn id(&self) -> Id {
+        Id {
+            serial_number: self.info.header.serial_number,
+        }
+    }
+}

nannou_laser/src/stream/raw.rs

@@ -7,7 +7,7 @@ use std::time::Duration;
 use thiserror::Error;
 
 use crate::util::{clamp, map_range};
-use crate::Inner as ApiInner;
+use crate::{protocol, Inner as ApiInner};
 use crate::{DetectedDac, RawPoint};
 
 /// The function that will be called when a `Buffer` of points is requested.
@@ -649,11 +649,14 @@ where
     F: RenderFn<M>,
 {
     // Currently only ether dream is supported, so retrieve the broadcast and addr.
+    // TODO: Refactor this into the protocol/etherdream.rs submodule, add
+    // similar implementation for `lasercube` inspired by `circle.rs` example.
     let (broadcast, src_addr) = match dac {
-        DetectedDac::EtherDream {
+        DetectedDac::EtherDream(protocol::etherdream::DetectedDac {
             broadcast,
             source_addr,
-        } => (broadcast, source_addr),
+        }) => (broadcast, source_addr),
+        _ => todo!("Implement lasercube handling"),
     };
 
     // A buffer for collecting model updates.