wip

src/device.rs

@@ -0,0 +1,15 @@
+mod common;
+mod helios;
+
+use crate::conf::{Conf, DacFamily, EtherDreamConf, HeliosConf};
+use crate::device::common::Device;
+use crate::device::helios::HeliosDevice;
+
+pub fn device_factory(config: Conf) -> Box<dyn Device> {
+    let device = match config.dac {
+        DacFamily::Helios(conf) => Box::new(HeliosDevice { conf }),
+        DacFamily::Etherdream( conf) => todo!(),
+    };
+
+    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/helios.rs

@@ -0,0 +1,36 @@
+///
+/// Configure udev:
+/// https://github.com/Grix/helios_dac/blob/master/docs/udev_rules_for_linux.md
+///
+use helios_dac::NativeHeliosDacController;
+use helios_dac::{
+    // Coordinate,
+    Color,
+    DeviceStatus,
+    Frame,
+    Point,
+};
+use crate::conf::HeliosConf;
+use crate::device::common::{Device, Status};
+
+pub struct HeliosDevice {
+    pub conf: HeliosConf,
+}
+
+impl HeliosDevice {
+
+    pub fn new ( conf: HeliosConf) -> Self{
+        Self{ conf }
+    }
+
+}
+
+impl Device for HeliosDevice {
+    fn status(&self) -> Status {
+        return Status {
+            active: true,
+            last_traced_at: "now".to_string(),
+            properties: vec!["foo".to_string()],
+        };
+    }
+}

src/lib.rs

@@ -1,3 +1,4 @@
 pub mod conf;
 pub mod redis_ctrl;
 pub mod errors;
+pub mod device;

src/main.rs

@@ -7,6 +7,9 @@ mod conf;
 mod errors;
 mod point;
 mod transformer;
+mod device;
+
+use device::device_factory;
 
 use helios_dac::{
 	self,
@@ -17,20 +20,20 @@ use helios_dac::{
 };
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
-use redis_ctrl::{RedisCtrl,Order};
+use redis_ctrl::{RedisCtrl, Order};
 use conf::Conf;
-use errors::{LJError,LJResult};
+use errors::{LJError, LJResult};
 use point::Point;
-use transformer::{Transformers,Translate,Replicate};
+use transformer::{Transformers, Translate, Replicate};
-use log::{LevelFilter,info,/* warn, */ error};
+use log::{LevelFilter, info, /* warn, */ error};
 use env_logger::Builder;
 
-const DEFAULT_CONF_FILE : &str = "settings.toml";
+const DEFAULT_CONF_FILE: &str = "settings.toml";
-const CENTER : (f32,f32) = (2000.0, 2000.0);
+const CENTER: (f32, f32) = (2000.0, 2000.0);
 
 pub fn main() {
 	match run_all() {
-	Ok(()) => {},
+		Ok(()) => {}
 		Err(err) => {
 			error!("Error: {}", err);
 		}
@@ -57,12 +60,13 @@ fn run_all() -> LJResult<()> {
 
 	let mut device = get_helios_device()?;
 
-    let transformers : Vec<Box<dyn Transformers>> = vec![
+	let transformers: Vec<Box<dyn Transformers>> = vec![
 		Box::new(Translate::new(CENTER.0, CENTER.1)),
-	Box::new(Replicate::Until(48))
+		Box::new(Replicate::Until(48)),
 	];
 
 	while running.load(Ordering::SeqCst) {
+
 		let order = rs.get_order(config.laser_id)?;
 		if order != Order::Draw {
 			info!("Order: {:?}", order);
@@ -71,8 +75,7 @@ fn run_all() -> LJResult<()> {
 		let frame = get_next_frame(&config, 1000, &transformers,
 		                           &mut rs, order == Order::Black)?;
 
-	while let Ok(DeviceStatus::NotReady) = device.status() {
+		while let Ok(DeviceStatus::NotReady) = device.status() {}
-	}
 		device.write_frame(frame)?;
 	}
 
@@ -111,18 +114,16 @@ fn get_next_frame(
 	speed: u32,
 	transformers: &[Box<dyn Transformers>],
 	rs: &mut RedisCtrl,
-    _black: bool
+	_black: bool,
 ) -> LJResult<Frame> {
-
-    
 	let line = rs.get(&format!("/pl/{}/0", config.laser_id))?;
-    let mut line: Vec<Point> = line.into_iter().map(| tpl | tpl.into()).collect();
+	let mut line: Vec<Point> = line.into_iter().map(|tpl| tpl.into()).collect();
 	for transformer in transformers {
 		line = transformer.apply(&line);
 	}
 
 	info!("Line: {:?}", line);
 
-    let line2 : Vec<helios_dac::Point> = line.into_iter().map(| p | p.into()).collect();
+	let line2: Vec<helios_dac::Point> = line.into_iter().map(|p| p.into()).collect();
 	Ok(Frame::new(speed, line2))
 }