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"

README.md

@@ -1,16 +0,0 @@
-# LJ rust 
-
-## Crashcourse
-
-```shell
-
-# Copy and edit the settings file 
-$ cp copyme.settings.toml settings.toml
-
-# Populate the redis database 
-$ cargo run --example populate_redis
-
-# Run 
-$ cargo run --release 
-
-```

copyme.settings.toml

@@ -1,4 +1,4 @@
-# file: settings.toml
+# file: Settings.toml
 # Rename me !
 
 # The main key of your laser in LJ
@@ -12,26 +12,20 @@ redis_url = "redis://127.0.0.1:6379/"
 
 # Either Helios or Etherdream
 # For Helios. USB Device Id of the DAC 
-#[dac.helios]
+[dac.helios]
-#id = 0
+id = 0
 
 # For dummy dac:
- [dac.dummy]
+# [dac.dummy]
 
 # For Etherdream. IP of the DAC
 # [dac.etherdream]
-# ip = "192.168.1.68"
+# url = "192.168.1.68"
 
 [[transformers]]
 [transformers.translate]
 x = 2000
 y = 2000
-
 [[transformers]]
 [transformers.replicate]
 Until = 48
-
-# Never remove this : this is mandatory
-[[transformers]]
-[transformers.intensity]
-

examples/populate_redis.rs

@@ -1,24 +0,0 @@
-///
-/// $ cargo run --example populate_redis
-///
-
-use redis::{
-    //RedisResult,
-    Client,
-    Commands,
-    Connection,
-};
-
-fn do_something() -> redis::RedisResult<()> {
-    let client = Client::open("redis://127.0.0.1/")?;
-    let mut con: Connection = client.get_connection()?;
-
-	let _ = con.set("/clientkey", "/pl/0/")?;
-	let _ = con.set("/EDH/0", "[[1.0, 0.0, 0.0],\n [ 0.0, 1.0, 0.0],\n [ 0.0, 0.0, 1.0]]")?;
-	let _ = con.set("/kpps/0", "5000")?;
-	let _ = con.set("/intensity/0", "255")?;
-    Ok(())
-}
-fn main() {
-    _ = do_something();
-}

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,
+	PREPARE,
-	PLAYING = 2,
+	PLAYING,
-	UNKNOWN = 99,
 }
-
 impl fmt::Display for PlaybackState {
-	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-		write!(f, "{:?}", self)
+        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,21 +49,20 @@ 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>,
 		speed: u32,
 	) -> LJResult<()>;
 	fn stop(&mut self) -> LJResult<()>;
-	fn grid(&mut self) -> Vec<Point>;
 }
 
 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::Helios(conf) => Box::new(HeliosDevice::new(conf)?),
-		DacFamily::Etherdream( conf) => Box::new( EtherdreamDevice::new(conf)?),
+	    DacFamily::Etherdream(_conf) => todo!(),
-		DacFamily::Dummy => Box::new(DummyDevice::new()?)
+	    DacFamily::Dummy => Box::new(DummyDevice::new()?)
 	};
 	Ok(device)
 }

src/device/common.rs

@@ -0,0 +1,31 @@
+
+/*
+self.protocol_version,
+self.le_state,
+self.playback_state,
+self.source,
+self.le_flags,
+self.playback_flags,
+self.source_flags,
+self.fullness,
+self.point_rate,
+self.point_count
+*/
+
+pub struct Status {
+    pub active: bool,
+    pub last_traced_at: String,
+    pub properties: Vec<String>
+}
+
+pub trait Device {
+    /**
+    fn intersect(&self, orig : &Vec3, dir : &Vec3) -> Option<Float>;
+    fn get_surface(&self, v : &Vec3) -> Vec3;
+    fn get_normal(&self, v : &Vec3) -> Vec3;
+    fn get_material(&self) -> &dyn Material;
+    **/
+
+    fn status( &self ) -> Status;
+
+}

src/device/dummy.rs

@@ -1,6 +1,6 @@
 use crate::device::{Device, Status, PlaybackState};
 use crate::errors::LJResult;
-use crate::point::{Color, Point};
+use crate::point::Point;
 use log::debug;
 
 pub struct DummyDevice {
@@ -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()],
@@ -35,9 +35,4 @@ impl Device for DummyDevice {
 	fn stop(&mut self) -> LJResult<()> {
 		Ok(())
 	}
-	fn grid(&mut self) -> Vec<Point> {
-		vec!(
-			Point{ x: 0 as f32, y: 0 as f32, color:Color{ r: 0, g: 0, b: 0 }}
-		)
-	}
 }

src/device/etherdream.rs

@@ -1,153 +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};
-
-#[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_timeout(Some(time::Duration::new(10, 0)))?;
-		info!("Attempting to get DAC broadcast...");
-		let broadcast = dac_broadcast
-			.filter_map(|result| {
-				match result {
-					Err(err) => {
-						warn!( "Failed to find a valid DAC via broadcast. Error: {:?}", err);
-						info!( "Retrying...");
-						None
-					},
-					Ok((dac, source_addr)) => {
-						if source_addr.is_ipv6() { return None; }
-						if &source_addr.ip().to_string() != ip { return None; }
-						info!("Valid broadcast");
-						Some(Ok((dac, source_addr)))
-					}
-				}
-			})
-			.next()
-			.expect("Failed to receive broadcast.");
-		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

@@ -13,7 +13,7 @@ use helios_dac::{
 use crate::conf::HeliosConf;
 use crate::device::{Device, Status, PlaybackState};
 use crate::errors::{LJError, LJResult};
-use crate::point::{Color, Point};
+use crate::point::Point;
 use chrono::Utc;
 
 pub struct HeliosDevice {
@@ -22,7 +22,7 @@ pub struct HeliosDevice {
 	sent_points: u16,
 	state: PlaybackState,
 	lack: String,
-	last_traced_at: String,
+	last_traced_at : String
 }
 
 impl HeliosDevice {
@@ -40,16 +40,17 @@ impl HeliosDevice {
 			sent_points: 0,
 			state: PlaybackState::PREPARE,
 			lack: "".to_string(),
-			last_traced_at: "1985-04-12T23:20:50.52Z".to_string(),
+			last_traced_at: "1985-04-12T23:20:50.52Z".to_string()
 		})
 	}
 }
 
 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(),
+			last_traced_at:  self.last_traced_at.clone(),
 			properties: vec!["foo".to_string()],
 			playback_state: self.state,
 			capacity: self.sent_points,
@@ -77,27 +78,4 @@ impl Device for HeliosDevice {
 		self.dac.stop()?;
 		Ok(())
 	}
-
-	fn grid(&mut self) -> Vec<Point> {
-		let dim_min = 0 as f32;
-		let dim_mid = 2047 as f32;
-		let dim_max = 4095 as f32;
-		let col_min = Color { r: 0, g: 0, b: 0 };
-		let col_max = Color { r: 255, g: 255, b: 255 };
-
-		vec![
-			Point { x: dim_min, y: dim_max, color: col_min },
-			Point { x: dim_min, y: dim_max, color: col_max },
-			Point { x: dim_max, y: dim_max, color: col_max },
-			Point { x: dim_max, y: dim_min, color: col_max },
-			Point { x: dim_min, y: dim_min, color: col_max },
-			Point { x: dim_min, y: dim_min, color: col_min },
-			Point { x: dim_min, y: dim_mid, color: col_min },
-			Point { x: dim_min, y: dim_mid, color: col_max },
-			Point { x: dim_mid, y: dim_mid, color: col_max },
-			Point { x: dim_mid, y: dim_min, color: col_max },
-			Point { x: dim_min, y: dim_min, color: col_max },
-			Point { x: dim_min, y: dim_min, color: col_min },
-		]
-	}
 }

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,44 +7,41 @@ pub type LJResult<T> = Result<T, Box<dyn std::error::Error>>;
 
 #[derive(Debug)]
 pub enum LJError {
-	Config(ConfigError),
+    Config(ConfigError),
-	RedisConnect(RedisError),
+    RedisConnect(RedisError),
-	HeliosDeviceMissing,
+    HeliosDeviceMissing,
-	BadEDH,
+    BadEDH
-	EtherdreamConnectError(io::Error),
 }
 
 impl fmt::Display for LJError {
-	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-		use LJError::*;
+	use LJError::*;
+	
+	match self {
+	    Config(err) => {
+		write!(f, "unable to load config file: {err}")
+	    },
 
-		match self {
+	    RedisConnect(err) => {
-			Config(err) => {
+		write!(f, "unable to connect to redis server: {err}")
-				write!(f, "unable to load config file: {err}")
+	    },
-			}
+	    HeliosDeviceMissing => {
-			RedisConnect(err) => {
+		write!(f, "helios device not found")
-				write!(f, "unable to connect to redis server: {err}")
+	    },
-			}
+	    BadEDH => {
-			HeliosDeviceMissing => {
+		write!(f, "EDH matrix is not a 3x3 matrix")
-				write!(f, "helios device not found")
+	    }
-			}
-			BadEDH => {
-				write!(f, "EDH matrix is not a 3x3 matrix")
-			}
-			EtherdreamConnectError(err) => {
-				write!(f, "Failed to retrieve Etherdream device: {err}")
-			}
-		}
 	}
+    }
 }
 
 impl Error for LJError {
-	fn source(&self) -> Option<&(dyn Error + 'static)> {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
-		use LJError::*;
+	use LJError::*;
 
-		match self {
+	match self {
-			RedisConnect(err) => Some(err),
+	    RedisConnect(err) => Some(err),
-			_ => None
+	    _ => None
-		}
 	}
+    }
 }

src/main.rs

@@ -16,7 +16,7 @@ use std::sync::Arc;
 use redis_ctrl::{RedisCtrl, Order};
 use conf::Conf;
 use errors::LJResult;
-use point::{Point, Color};
+use point::{Point,Color};
 use transformer::Transformers;
 use log::{LevelFilter, info, /* warn, */ error};
 use env_logger::Builder;
@@ -50,9 +50,9 @@ fn run_all() -> LJResult<()> {
 	// Setup Redis Service
 	let mut rs = RedisCtrl::new(&config.redis_url, &config.laser_id)?;
 
-	let mut world_state = rs.init_world_state().unwrap();
+	let mut world_state = rs.init_world_state()?;
-	info!("WorldState: {:?}", world_state);
+        info!("WorldState: {:?}", world_state);
-
+    
 	// Setup handler for interrupt Signals
 	let running = Arc::new(AtomicBool::new(true));
 	let r = running.clone();
@@ -62,7 +62,6 @@ fn run_all() -> LJResult<()> {
 
 	// Setup Laser Device based on conf
 	let mut tracer = device_factory(&config)?;
-	world_state.grid = tracer.grid();
 
 	// can't work, but we can add + Debug to Device to make it work...
 	//dbg!(tracer);
@@ -75,46 +74,46 @@ fn run_all() -> LJResult<()> {
 		rs.set_status(tracer.status())?;
 
 		let order = rs.get_order(config.laser_id)?;
+		// 0 : Draw Normal point list
+		// 2 : Draw BLACK point list
+		// 3 : Draw GRID point list
 
+		// /worldstate.rs
+		// /edh.rs
 
+		// 1 : Get the new EDH          = reread redis key /EDH/lasernumber
+		// 4 : Resampler Change (longs and shorts lsteps)
+		// 5 : Client Key Change        = reread redis key /clientkey
+		// 6 : Max Intensity Change     = reread redis key /intensity
+		// 7 : kpps change              = reread redis key /kpps
+		// 8 : color balance change     = reread redis keys /red /green /blue
 		match order {
-			Order::Draw | Order::Black | Order::Grid => {
+		    Order::Draw | Order::Black => {
-				// 0 : Draw Normal point list
+			world_state.black = order == Order::Black;
-				// 2 : Draw BLACK point list
+			
-				// 3 : Draw GRID point list
-				world_state.draw_black = order == Order::Black;
-				world_state.draw_grid = order == Order::Grid;
 				let frame = get_next_frame(
 					&config,
 					&transformers,
-					&mut rs,
+					&mut rs, 
-					&world_state,
+					&world_state
 				)?;
 				// For now, draw all the time
 				tracer.draw(frame, world_state.kpps)?;
-			}
-			Order::Intensity => {
-				// 6 : Max Intensity Change     = reread redis key /intensity
-				world_state.intensity = rs.get_int("intensity")?
-					.try_into()?;
-			}
-			Order::Edh => {
-				// 1 : Get the new EDH          = reread redis key /EDH/lasernumber
-				world_state.edh = rs.get_edh()?;
-			}
-			Order::Kpps => {
-				// 7 : kpps change              = reread redis key /kpps
-				world_state.kpps = rs.get_int("kpps")?;
-			}
-			Order::ClientKey => {
-				world_state.client_key = rs.get_client_key()?;
 			},
+		        Order::Intensity => {
+			    world_state.intensity = rs.get_int("intensity")?
+				.try_into()?;
+		        },
+			Order::Edh => {
+				world_state.edh = rs.get_edh()?;
+			},
+			Order::Kpps => {
+				world_state.kpps = rs.get_int("kpps")?;
+			},
+
+			// Order::ClientKey => rs.client_key(),
 			// Order::ColorBalance => {},
 			_ => {
-				// 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
 				info!("Order: {:?}", order);
 			}
 		}
@@ -144,50 +143,42 @@ fn get_next_frame(
 	config: &Conf,
 	transformers: &[Box<dyn Transformers>],
 	rs: &mut RedisCtrl,
-	world_state: &WorldState,
+	world_state : &WorldState
 ) -> LJResult<Vec<Point>> {
-	let format_key = format!("{}{}",
+    let format_key = format!("{}{}",
-	                         world_state.client_key,
+			     world_state.client_key,
-	                         config.laser_id);
+			     config.laser_id);
+    let line = rs.get_line(&format_key)?;
+    let mut line: Vec<Point> = line.into_iter()
+	.map(|tpl| tpl.into())
+	.collect();
+    
+    for transformer in transformers {
+	line = transformer.apply(&line, world_state);
+    }
 
-	// Handle the grid case
+    info!("-> {}", world_state.black);
-
+    
-	let mut line: Vec<Point> = if world_state.draw_grid {
+    // LIMITER and BLACK
-		world_state.grid.clone()
+    line = line.into_iter()
-	} else {
+	.map(| p | {
-		let redis_line = rs.get_line(&format_key)?;
+	    
-		redis_line.into_iter()
+	    let color = if world_state.black {
-			.map(|tpl| tpl.into())
+		Color { r: 0, g: 0, b: 0 }
-			.collect()
+	    } else {
-	};
+		Color {
-
+		    r: p.color.r.min(world_state.intensity),
-	for transformer in transformers {
+		    g: p.color.g.min(world_state.intensity),
-		line = transformer.apply(&line, world_state);
+		    b: p.color.b.min(world_state.intensity)
-	}
+		}
-
+	    };
-	info!("Draw Black -> {}", world_state.draw_black);
+	    Point { color,
-	info!("Draw Grid -> {}", world_state.draw_grid);
+		    ..p
-
+	    }
-	// LIMITER and BLACK
+	})
-	line = line.into_iter()
+	.collect();
-		.map(|p| {
+    
-			let color = if world_state.draw_black {
+    //info!("Line: {:?}", line);
-				Color { r: 0, g: 0, b: 0 }
+    Ok(line)
-			} else {
-				Color {
-					r: p.color.r.min(world_state.intensity),
-					g: p.color.g.min(world_state.intensity),
-					b: p.color.b.min(world_state.intensity),
-				}
-			};
-			Point {
-				color,
-				..p
-			}
-		})
-		.collect();
-
-	//info!("Line: {:?}", line);
-	Ok(line)
 }
 

src/point.rs

@@ -1,64 +1,34 @@
-use ether_dream::protocol::DacPoint;
+#[derive(Debug,Clone,Copy,Default,PartialEq)]
-
-#[derive(Debug, Clone, Copy, Default, PartialEq)]
 pub struct Point {
-	pub x: f32,
+    pub x: f32,
-	pub y: f32,
+    pub y: f32,
-	pub color: Color,
+    pub color: Color
 }
 
-#[derive(Debug, Clone, Copy, Default, PartialEq)]
+#[derive(Debug,Clone,Copy,Default,PartialEq)]
 pub struct Color {
-	pub r: u8,
+    pub r: u8,
-	pub g: u8,
+    pub g: u8,
-	pub b: u8,
+    pub b: u8
 }
 
-impl From<Color> for u32 {
+impl From<(f32,f32,u32)> for Point {
-	fn from(value: Color) -> Self {
+    fn from((x, y, color) : (f32, f32, u32)) -> Point {
-		let r = value.r as u32;
+	let r = (color >> 16) as u8 ;
-		let g = value.g as u32;
+	let g = ((color >> 8) & 255) as u8 ;
-		let b = (value.b) as u32;
+	let b = (color & 255) as u8 ;
-		(r << 16) + (g << 8) + b
+	Point { x, y, color: Color { r, g, b } }
-	}
+    }
-}
-
-impl From<(f32, f32, u32)> for Point {
-	fn from((x, y, color): (f32, f32, u32)) -> Point {
-		let r = (color >> 16) as u8;
-		let g = ((color >> 8) & 255) as u8;
-		let b = (color & 255) as u8;
-		Point { x, y, color: Color { r, g, b } }
-	}
 }
 
 impl From<Point> for helios_dac::Point {
-	fn from(pt: Point) -> helios_dac::Point {
+    fn from(pt: Point) -> helios_dac::Point {
-		let x = pt.x.clamp(0.0, 4095.0) as u16;
+	let x = pt.x.clamp(0.0, 4095.0) as u16;
-		let y = pt.y.clamp(0.0, 4095.0) as u16;
+	let y = pt.y.clamp(0.0, 4095.0) as u16;
-		helios_dac::Point {
+	helios_dac::Point {
-			coordinate: (x, y).into(),
+	    coordinate: (x, y).into(),
-			color: helios_dac::Color::new(pt.color.r, pt.color.g, pt.color.b),
+	    color: helios_dac::Color::new(pt.color.r, pt.color.g, pt.color.b),
-			intensity: 0xFF,
+	    intensity: 0xFF
-		}
-	}
-}
-
-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,
-		}
 	}
+    }
 }

src/redis_ctrl.rs

@@ -101,10 +101,10 @@ impl RedisCtrl {
 
 	pub fn init_world_state( &mut self) -> LJResult<WorldState>{
 	    Ok(WorldState {
-		client_key: self.get_client_key().unwrap(),
+		client_key: self.connection.get("/clientkey")?,
-		edh: self.get_edh().unwrap(),
+		edh: self.get_edh()?,
-		kpps: self.get_int("kpps").unwrap().try_into().unwrap(),
+		kpps: self.get_int("kpps")?.try_into()?,
-		intensity: self.get_int("intensity").unwrap().try_into().unwrap(),
+		intensity: self.get_int("intensity")?.try_into()?,
 		..WorldState::default()
 	    })
 	}
@@ -118,11 +118,6 @@ impl RedisCtrl {
 	    Ok(edh)
 	}
 
-	pub fn get_client_key( &mut self ) -> LJResult<String> {
-	    let key : String = self.connection.get("/clientkey")?;
-	    Ok(key)
-	}
-
 	pub fn get_int(&mut self, key: &str ) -> LJResult<u32> {
 	    // Get new Int
 	    let fmt = format!("/{key}/{}", self.laser_id);

src/worldstate.rs

@@ -1,52 +1,52 @@
-use crate::point::{Point, Color};
+use crate::point::{Point,Color};
-use nalgebra::base::{Matrix3, Matrix1x3};
+use nalgebra::base::{Matrix3,Matrix1x3};
-use crate::errors::{LJError, LJResult};
+use crate::errors::{LJError,LJResult};
 use log::debug;
 
 #[derive(Debug, Default)]
 pub struct EDH {
-	pub matrix: Matrix3<f32>,
+	pub matrix: Matrix3<f32>
 }
 
 impl EDH {
-	pub fn new(vec: Vec<Vec<f32>>) -> LJResult<EDH> {
+    pub fn new(vec: Vec<Vec<f32>>) -> LJResult<EDH> {
-		if vec.len() != 3 ||
+	if vec.len() != 3 ||
-			vec[0].len() != 3 ||
+	    vec[0].len() != 3 ||
-			vec[1].len() != 3 ||
+	    vec[1].len() != 3 ||
-			vec[2].len() != 3 {
+	    vec[2].len() != 3 {
-			return Err(Box::new(LJError::BadEDH));
+		return Err(Box::new(LJError::BadEDH));
-		}
+	    }
 
-		// this is the matrix already transposed.
+	// this is the matrix already transposed.
-		let matrix = Matrix3::new(vec[0][0], vec[1][0], vec[2][0],
+	let matrix = Matrix3::new(vec[0][0], vec[1][0], vec[2][0],
-		                          vec[0][1], vec[1][1], vec[2][1],
+				  vec[0][1], vec[1][1], vec[2][1],
-		                          vec[0][2], vec[1][2], vec[2][2]);
+				  vec[0][2], vec[1][2], vec[2][2]);
 
-		Ok(EDH { matrix })
+	Ok(EDH { matrix })
-	}
+    }
 
-	pub fn apply(&self, point: &Point) -> Point {
+    pub fn apply(&self, point: &Point) -> Point {
-		let p = Matrix1x3::new(point.x, point.y, 1.0);
+	let p = Matrix1x3::new(point.x, point.y, 1.0);
-		let p = p * self.matrix;
+	let p = p * self.matrix;
-		let new_p = Point { x: p[0] / p[2], y: p[1] / p[2], ..*point };
+	let new_p = Point { x: p[0] / p[2], y: p[1] / p[2], ..*point };
-
+	
-		debug!("{:?} => {:?}", point, new_p);
+	debug!("{:?} => {:?}", point, new_p);
-
+	
-		new_p
+	new_p
-	}
+    }
 }
 
 #[derive(Debug, Default)]
 pub struct WorldState {
 	pub edh: EDH,
 	pub resampler: Vec<f32>,
-	pub client_key: String,
+	pub client_key: String, //u8,
 	pub intensity: u8,
 	pub kpps: u32,
-	pub color: Color,
+        pub color: Color,
-	pub draw_black: bool,
+        pub black: bool
-	pub draw_grid: bool,
-	pub grid: Vec<Point>,
 }
 
-impl WorldState {}
+impl WorldState {
+
+}

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,
     });
 }