refatoring errors

src/conf.rs

@@ -21,8 +21,6 @@ pub fn load_config(path: &str) -> Result<Conf, Box<dyn std::error::Error>> {
         .add_source(config::File::with_name(path))
 	.build()?;
             
-    let conf = settings.try_deserialize::<Conf>()?;
-
-    
+    let conf : Conf = settings.try_deserialize()?;
     Ok(conf)
 }

src/errors.rs

@@ -0,0 +1,36 @@
+use std::error::Error;
+use std::fmt;
+use redis::RedisError;
+
+#[derive(Debug)]
+pub enum LJError {
+    ConfigFileMissing,
+    RedisConnect(RedisError)
+}
+
+impl fmt::Display for LJError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+	use LJError::*;
+	
+	match self {
+	    ConfigFileMissing => {
+		write!(f, "first argument must be a TOML config file \
+			   (see copyme.Settings.toml)")
+	    },
+	    RedisConnect(err) => {
+		write!(f, "unable to connect to redis server: {err}")
+	    }
+	}
+    }
+}
+
+impl Error for LJError {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+	use LJError::*;
+
+	match self {
+	    ConfigFileMissing => None,
+	    RedisConnect(err) => Some(err)
+	}
+    }
+}

src/lib.rs

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

src/main.rs

@@ -1,9 +1,10 @@
-mod conf;
 ///
 /// Configure udev:
 /// https://github.com/Grix/helios_dac/blob/master/docs/udev_rules_for_linux.md
 ///
 mod redis_ctrl;
+mod conf;
+mod errors;
 
 use helios_dac::NativeHeliosDacController;
 use helios_dac::{
@@ -15,43 +16,41 @@ use helios_dac::{
 };
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
-
+use redis_ctrl::{RedisCtrl,Order};
 use conf::{load_config,Conf};
-use redis_ctrl::{Order, RedisCtrl};
+use errors::LJError;
 
 const CENTER : (u16,u16) = (2000, 2000);
 
 pub fn main() {
-    let config = match load_config("Settings") {
-        Ok(c) => c,
+    match run_all() {
+	Ok(()) => {},
 	Err(err) => {
-            panic!("Unable to load config file: {:?}", err)
+	    println!("Error: {}", err);
 	}
+    }
+}
+
+fn run_all() -> Result<(), Box<dyn std::error::Error>> {
+    let Some(filename) = std::env::args().nth(1) else {
+	return Err(Box::new(LJError::ConfigFileMissing));
     };    
+    let config = load_config(&filename)?;    
+    let rs = RedisCtrl::new()?;
     
-    let rs = match RedisCtrl::new() {
-        Ok(rs) => rs,
-        Err(err) => {
-            panic!("Unable to connect to redis: {:?}", err);
-        }
-    };
-
-    match run_dac(config, rs) {
-        Ok(()) => {}
-        Err(err) => {
-            panic!("Error: {:?}", err)
-        }
-    }
+    run_dac(config, rs)
 }
 
-fn run_dac(config: Conf, mut rs: RedisCtrl) -> Result<(), Box<dyn std::error::Error>> {
+fn run_dac(
+    config: Conf,
+    mut rs: RedisCtrl
+) -> Result<(), Box<dyn std::error::Error>> {
     let running = Arc::new(AtomicBool::new(true));
     let r = running.clone();
 
     ctrlc::set_handler(move || {
         r.store(false, Ordering::SeqCst);
-    })
-    .expect("Error setting Ctrl-C handler");
+    })?;
 
     let controller = NativeHeliosDacController::new()?;
     let devices = controller.list_devices()?;
@@ -64,14 +63,16 @@ fn run_dac(config: Conf, mut rs: RedisCtrl) -> Result<(), Box<dyn std::error::Er
     let mut device = device.open()?;
     
     while running.load(Ordering::SeqCst) {
-        let order = rs.get_order(0)?;
+	let order = rs.get_order(config.laser_id)?;
 	if order != Order::Draw {
 	    println!("{:?}", order);
 	}
 
-        let frame = get_next_frame(1000, &mut rs)?;
+	let frame = get_next_frame(&config, 1000,
+				   &mut rs, order == Order::Black)?;
 	
-        while let Ok(DeviceStatus::NotReady) = device.status() {}
+	while let Ok(DeviceStatus::NotReady) = device.status() {
+	}
         device.write_frame(frame)?;
     }
 
@@ -80,8 +81,14 @@ fn run_dac(config: Conf, mut rs: RedisCtrl) -> Result<(), Box<dyn std::error::Er
     Ok(())
 }
 
-fn get_next_frame(speed: u32, rs: &mut RedisCtrl) -> Result<Frame, Box<dyn std::error::Error>> {
-    let line = rs.get("/pl/0/0")?;
+fn get_next_frame(
+    config: &Conf,
+    speed: u32,
+    rs: &mut RedisCtrl,
+    _black: bool
+) -> Result<Frame, Box<dyn std::error::Error>> {
+    
+    let line = rs.get(&format!("/pl/{}/0", config.laser_id))?;
     let line: Vec<Point> = line.iter().map(tuple_to_point).collect();
 
     let mut line2 = vec![];
@@ -91,6 +98,8 @@ fn get_next_frame(speed: u32, rs: &mut RedisCtrl) -> Result<Frame, Box<dyn std::
         }
     }
 
+    println!("{:?}", line2);
+
     Ok(Frame::new(speed, line2))
 }
 
@@ -101,8 +110,8 @@ fn tuple_to_point(tpl: &(f32, f32, u32)) -> Point {
     let g = ((col >> 8) & 255) as u8 ;
     let b = (col & 255) as u8 ;
     
-    let x = CENTER.0 + *x as u16;
-    let y = CENTER.1 + *y as u16;
+    let x = CENTER.0 + *x as u16 * 2;
+    let y = CENTER.1 + *y as u16 * 2;
 
     if x >= 4096 || y >= 4096 {
         println!("WARN: coordinate out of range: {} {}", x, y);

src/redis_ctrl.rs

@@ -1,5 +1,6 @@
 use redis::{Client, Commands, Connection};
 use ron::de::from_str;
+use crate::errors::LJError;
 
 #[repr(u8)]
 #[derive(Debug, PartialEq)]
@@ -35,7 +36,7 @@ impl TryFrom<u8> for Order {
 	    6 => Intensity,
 	    7 => Kpps,
 	    8 => ColorBalance,
-            _ => panic!("Can't be there"),
+	    _ => unreachable!()
 	})
     }
 }
@@ -49,8 +50,10 @@ pub struct RedisCtrl {
 
 impl RedisCtrl {
     pub fn new() -> Result<Self, Box<dyn std::error::Error>> {
-        let client = Client::open("redis://127.0.0.1/")?;
-        let connection = client.get_connection()?;
+        let client = Client::open("redis://127.0.0.1/")
+	    .map_err(| err | LJError::RedisConnect(err))?;
+        let connection = client.get_connection()
+	    .map_err(| err | LJError::RedisConnect(err))?;
         Ok(RedisCtrl { client, connection })
     }