feat: adds Etherdream device

Cargo.toml

@@ -10,6 +10,7 @@ chrono = "0.4.26"
 config = "0.13.3"
 ctrlc = "3.4.0"
 env_logger = "0.10.0"
+ether-dream = "0.2.5"
 helios-dac = { version = "0.1", default-features = false, features = ["native"] }
 	   	       
 log = "0.4.18"

copyme.settings.toml

@@ -29,3 +29,8 @@ y = 2000
 [[transformers]]
 [transformers.replicate]
 Until = 48
+
+# Never remove this : this is mandatory
+[[transformers]]
+[transformers.intensity]
+

src/conf.rs

@@ -30,7 +30,7 @@ pub struct HeliosConf {
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct EtherDreamConf {
-    pub url: String
+    pub ip: String
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]

src/device.rs

@@ -1,6 +1,6 @@
-
 mod helios;
 mod dummy;
+mod etherdream;
 
 use std::fmt;
 use crate::conf::{Conf, DacFamily /*EtherDreamConf, HeliosConf*/};
@@ -9,6 +9,7 @@ use crate::device::dummy::DummyDevice;
 use crate::errors::LJResult;
 use crate::point::Point;
 use serde::Serialize;
+use crate::device::etherdream::EtherdreamDevice;
 
 /*
 self.protocol_version,
@@ -26,9 +27,11 @@ self.point_count
 #[derive(Debug, PartialEq, Serialize, Copy, Clone)]
 pub enum PlaybackState {
 	IDLE = 0,
-	PREPARE,
+	PREPARE = 1,
-	PLAYING,
+	PLAYING = 2,
+	UNKNOWN = 99,
 }
+
 impl fmt::Display for PlaybackState {
 	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 		write!(f, "{:?}", self)
@@ -41,7 +44,7 @@ pub struct Status {
 	pub properties: Vec<String>,
 	pub playback_state: PlaybackState,
 	pub capacity: u16,
-	pub lack: String
+	pub lack: String,
 }
 
 // /lstt/lasernumber       etherdream last_status.playback_state  (0: idle   1: prepare   2: playing)
@@ -49,7 +52,7 @@ pub struct Status {
 // /lack/lasernumber       "a": ACK   "F": Full  "I": invalid. 64 or 35 for no connection.
 
 pub trait Device {
-	fn status(&self) -> Status;
+	fn status(&mut self) -> Status;
 	fn draw(
 		&mut self,
 		frame: Vec<Point>,
@@ -60,9 +63,9 @@ pub trait Device {
 }
 
 pub fn device_factory(config: &Conf) -> LJResult<Box<dyn Device>> {
-	let device : Box<dyn Device> = match &config.dac {
+	let device: Box<dyn Device> = match &config.dac {
 		DacFamily::Helios(conf) => Box::new(HeliosDevice::new(conf)?),
-	    DacFamily::Etherdream(_conf) => todo!(),
+		DacFamily::Etherdream( conf) => Box::new( EtherdreamDevice::new(conf)?),
 		DacFamily::Dummy => Box::new(DummyDevice::new()?)
 	};
 	Ok(device)

src/device/dummy.rs

@@ -14,7 +14,7 @@ impl DummyDevice {
 }
 
 impl Device for DummyDevice {
-	fn status(&self) -> Status {
+	fn status(&mut self) -> Status {
 		Status {
 			last_traced_at: "never".to_string(),
 			properties: vec!["foo".to_string()],

src/device/etherdream.rs

@@ -0,0 +1,147 @@
+use std::time;
+use std::net::SocketAddr;
+use ether_dream::dac::stream::connect;
+use ether_dream::dac::Stream;
+
+use crate::conf::EtherDreamConf;
+use crate::device::{Device, Status, PlaybackState};
+use crate::errors::{LJError, LJResult};
+use crate::point::{Color, Point};
+use ether_dream::protocol::{DacBroadcast, DacStatus};
+use log::info;
+
+#[warn(dead_code)]
+pub struct EtherdreamDevice {
+	pub conf: EtherDreamConf,
+	dac: DacBroadcast,
+	// source_address: SocketAddr,
+	stream: Stream,
+	// sent_points: u16,
+	lack: String,
+	last_traced_at: String,
+}
+
+impl EtherdreamDevice {
+	pub fn new(conf: &EtherDreamConf) -> LJResult<Self> {
+		let (dac, _source_address, stream) = EtherdreamDevice::get_dac(conf)?;
+		// let (dac, source_address) = EtherdreamDevice::get_dac(conf)?;
+		Ok(Self {
+			conf: (*conf).clone(),
+			dac,
+			// source_address,
+			stream,
+			// sent_points: 0,
+			lack: "".to_string(),
+			last_traced_at: "1985-04-12T23:20:50.52Z".to_string(),
+		})
+	}
+	pub fn get_dac(conf: &EtherDreamConf) -> LJResult<(DacBroadcast, SocketAddr, Stream)> {
+		let ip = &conf.ip;
+		let dac_broadcast = ether_dream::recv_dac_broadcasts()?;
+		dac_broadcast.set_nonblocking(true)?;
+		dac_broadcast.set_timeout(Some(time::Duration::new(60, 30)))?;
+		let broadcast = dac_broadcast
+			.filter_map(|result| {
+				info!("Received new broadcast {:?}", result);
+				if result.is_err() { return None; }
+				let (dac, source_addr) = result.unwrap();
+				if source_addr.is_ipv6() { return None; }
+				if source_addr.ip().to_string() != ip.clone() { return None; }
+				info!("Valid broadcast");
+				Some(Ok((dac, source_addr)))
+			})
+			.next()
+			.ok_or(LJError::EtherdreamError("Failed to receive broadcast".to_string()))?;
+		match broadcast {
+			Err(err) => {
+				Err(Box::new(LJError::EtherdreamConnectError(err)))
+			}
+			Ok((dac, source_addr)) => {
+				let stream = EtherdreamDevice::get_tcp_stream(&dac, &source_addr)?;
+				Ok((dac, source_addr, stream))
+			}
+		}
+	}
+
+	pub fn get_tcp_stream(dac: &DacBroadcast, source_address: &SocketAddr) -> LJResult<Stream> {
+		// Establish the TCP connection.
+		let mut stream = connect(dac, source_address.ip())?;
+
+		// Prepare  stream
+		stream
+			.queue_commands()
+			.prepare_stream()
+			.submit()
+			.err()
+			.map(|err| {
+				eprintln!(
+					"err occurred when submitting PREPARE_STREAM \
+		                  command and listening for response: {}",
+					err
+				);
+			});
+
+		Ok(stream)
+	}
+
+
+	pub fn check_tcp_stream(&mut self) -> LJResult<()> {
+		// todo Reinit stream if needed
+		// self.stream = EtherdreamDevice::get_tcp_stream(&self.dac, &self.source_address)?
+		Ok(())
+	}
+
+	// Determine the number of points needed to fill the DAC.
+	fn points_to_generate(&self) -> usize {
+		self.dac.buffer_capacity as usize - 1 - self.dac.dac_status.buffer_fullness as usize
+	}
+}
+
+impl Device for EtherdreamDevice {
+	fn status(&mut self) -> Status {
+		let _ = self.check_tcp_stream();
+
+		// "a": ACK   "F": Full  "I": invalid. 64 or 35 for no connection.
+		let playback_state = match self.dac.dac_status.playback_state {
+			DacStatus::PLAYBACK_IDLE => PlaybackState::IDLE,
+			DacStatus::PLAYBACK_PREPARED => PlaybackState::PREPARE,
+			DacStatus::PLAYBACK_PLAYING => PlaybackState::PLAYING,
+			_ => PlaybackState::UNKNOWN
+		};
+
+		Status {
+			last_traced_at: self.last_traced_at.clone(),
+			properties: vec!["foo".to_string()],
+			playback_state,
+			capacity: self.dac.dac_status.buffer_fullness,
+			lack: String::from(&self.lack),
+		}
+	}
+
+	fn draw(&mut self,
+	        line: Vec<Point>,
+	        _speed: u32,
+	) -> LJResult<()> {
+		let n_points = self.points_to_generate();
+		self.stream
+			.queue_commands()
+			.data(line.into_iter().map(|point| point.into()).take(n_points))
+			.submit()?;
+		Ok(())
+	}
+
+	fn stop(&mut self) -> LJResult<()> {
+		self.stream
+			.queue_commands()
+			.stop()
+			.submit()
+			.expect("err occurred when submitting STOP command and listening for response");
+		Ok(())
+	}
+
+	fn grid(&mut self) -> Vec<Point> {
+		vec!(
+			Point { x: 0.0, y: 0.0, color: Color { r: 255, g: 255, b: 255 } }
+		)
+	}
+}

src/device/helios.rs

@@ -46,7 +46,7 @@ impl HeliosDevice {
 }
 
 impl Device for HeliosDevice {
-	fn status(&self) -> Status {
+	fn status(&mut self) -> Status {
 		let lack = self.lack.clone();
 		Status {
 			last_traced_at: self.last_traced_at.clone(),

src/errors.rs

@@ -1,5 +1,5 @@
 use std::error::Error;
-use std::fmt;
+use std::{fmt, io};
 use redis::RedisError;
 use config::ConfigError;
 
@@ -10,7 +10,9 @@ pub enum LJError {
 	Config(ConfigError),
 	RedisConnect(RedisError),
 	HeliosDeviceMissing,
-    BadEDH
+	BadEDH,
+	EtherdreamError(String),
+	EtherdreamConnectError(io::Error),
 }
 
 impl fmt::Display for LJError {
@@ -20,17 +22,22 @@ impl fmt::Display for LJError {
 		match self {
 			Config(err) => {
 				write!(f, "unable to load config file: {err}")
-	    },
+			}
-
 			RedisConnect(err) => {
 				write!(f, "unable to connect to redis server: {err}")
-	    },
+			}
 			HeliosDeviceMissing => {
 				write!(f, "helios device not found")
-	    },
+			}
 			BadEDH => {
 				write!(f, "EDH matrix is not a 3x3 matrix")
 			}
+			EtherdreamError(msg) => {
+				write!(f, "Unexpected Etherdream device error: {msg}")
+			}
+			EtherdreamConnectError(err) => {
+				write!(f, "Failed to retrieve Etherdream device: {err}")
+			}
 		}
 	}
 }

src/main.rs

@@ -114,7 +114,7 @@ fn run_all() -> LJResult<()> {
 				// 4 : Resampler Change (longs and shorts lsteps)
 				// 5 : Client Key Change        = reread redis key /clientkey
 				// 8 : color balance change     = reread redis keys /red /green /blue
-				// 9 : poweroff LJ				world_state.intensity = rs.get_int("intensity")?
+				// 9 : poweroff LJ
 				info!("Order: {:?}", order);
 			}
 		}
@@ -152,17 +152,15 @@ fn get_next_frame(
 
 	// Handle the grid case
 
-	let mut line: Vec<Point>;
+	let mut line: Vec<Point> = if world_state.draw_grid {
-	if world_state.draw_grid {
+		world_state.grid.clone()
-		line = world_state.grid.clone();
 	} else {
 		let redis_line = rs.get_line(&format_key)?;
-		line = redis_line.into_iter()
+		redis_line.into_iter()
 			.map(|tpl| tpl.into())
-			.collect();
+			.collect()
 	};
 
-
 	for transformer in transformers {
 		line = transformer.apply(&line, world_state);
 	}

src/point.rs

@@ -1,3 +1,5 @@
+use ether_dream::protocol::DacPoint;
+
 #[derive(Debug, Clone, Copy, Default, PartialEq)]
 pub struct Point {
 	pub x: f32,
@@ -41,3 +43,22 @@ impl From<Point> for helios_dac::Point {
 		}
 	}
 }
+
+impl From<Point> for DacPoint {
+	fn from(pt: Point) -> DacPoint {
+		let control = 0;
+		let (u1, u2) = (0, 0);
+		let i = 255;
+		DacPoint {
+			control,
+			x: pt.x as i16,
+			y: pt.y as i16,
+			i,
+			r: pt.color.r.into(),
+			g: pt.color.g.into(),
+			b: pt.color.b.into(),
+			u1,
+			u2,
+		}
+	}
+}

tests/settings/valid_etherdream.toml

@@ -12,4 +12,4 @@ redis_url = "redis://127.0.0.1:6379/"
 
 # For Etherdream. IP of the DAC
 [dac.etherdream]
-url = "192.168.1.68"
+ip = "192.168.1.68"

tests/test_conf.rs

@@ -28,7 +28,7 @@ fn it_finds_struct_fields() {
 fn it_finds_etherdream_fields() {
     let config = Conf::new("tests/settings/valid_etherdream").unwrap();
     assert!(match config.dac {
-        DacFamily::Etherdream(EtherDreamConf { url }) if url == "192.168.1.68" => true,
+        DacFamily::Etherdream(EtherDreamConf { ip }) if ip == "192.168.1.68" => true,
         _ => false,
     });
 }