Cargo.toml

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

src/device/dummy.rs

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

src/device/etherdream.rs

@@ -1,147 +0,0 @@
-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(&mut self) -> Status {
+	fn status(&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, io};
+use std::fmt;
 use redis::RedisError;
 use config::ConfigError;
 
@@ -7,48 +7,41 @@ pub type LJResult<T> = Result<T, Box<dyn std::error::Error>>;
 
 #[derive(Debug)]
 pub enum LJError {
-	Config(ConfigError),
-	RedisConnect(RedisError),
-	HeliosDeviceMissing,
-	BadEDH,
-	EtherdreamError(String),
-	EtherdreamConnectError(io::Error),
+    Config(ConfigError),
+    RedisConnect(RedisError),
+    HeliosDeviceMissing,
+    BadEDH
 }
 
 impl fmt::Display for LJError {
-	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-		use LJError::*;
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+	use LJError::*;
+	
+	match self {
+	    Config(err) => {
+		write!(f, "unable to load config file: {err}")
+	    },
 
-		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}")
-			}
-		}
+	    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")
+	    }
 	}
+    }
 }
 
 impl Error for LJError {
-	fn source(&self) -> Option<&(dyn Error + 'static)> {
-		use LJError::*;
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+	use LJError::*;
 
-		match self {
-			RedisConnect(err) => Some(err),
-			_ => None
-		}
+	match self {
+	    RedisConnect(err) => Some(err),
+	    _ => None
 	}
+    }
 }

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
+				// 9 : poweroff LJ				world_state.intensity = rs.get_int("intensity")?
 				info!("Order: {:?}", order);
 			}
 		}
@@ -152,15 +152,17 @@ fn get_next_frame(
 
 	// Handle the grid case
 
-	let mut line: Vec<Point> = if world_state.draw_grid {
-		world_state.grid.clone()
+	let mut line: Vec<Point>;
+	if world_state.draw_grid {
+		line = world_state.grid.clone();
 	} else {
 		let redis_line = rs.get_line(&format_key)?;
-		redis_line.into_iter()
+		line = redis_line.into_iter()
 			.map(|tpl| tpl.into())
-			.collect()
+			.collect();
 	};
 
+
 	for transformer in transformers {
 		line = transformer.apply(&line, world_state);
 	}

src/point.rs

@@ -1,5 +1,3 @@
-use ether_dream::protocol::DacPoint;
-
 #[derive(Debug, Clone, Copy, Default, PartialEq)]
 pub struct Point {
 	pub x: f32,
@@ -43,22 +41,3 @@ 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]
-ip = "192.168.1.68"
+url = "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 { ip }) if ip == "192.168.1.68" => true,
+        DacFamily::Etherdream(EtherDreamConf { url }) if url == "192.168.1.68" => true,
         _ => false,
     });
 }