fix: format using rustfmt

src/conf.rs

@@ -1,32 +1,28 @@
-
 use config::Config;
 use serde::Deserialize;
 
-
+#[derive(Deserialize, Debug)]
-#[derive(Deserialize,Debug)]
 pub enum DacFamily {
     Helios,
-    Etherdream
+    Etherdream,
-    }
-
-#[derive(Deserialize,Debug)]
-pub struct Conf {
-    laser_id : u8,
-    debug : bool,
-    redis_url : String,
-    dac_family: DacFamily,
-    dac_id : Option<u8>,
-    dac_url : Option<String>
 }
 
+#[derive(Deserialize, Debug)]
+pub struct Conf {
+    laser_id: u8,
+    debug: bool,
+    redis_url: String,
+    dac_family: DacFamily,
+    dac_id: Option<u8>,
+    dac_url: Option<String>,
+}
 
-pub fn load_config( path : &str )-> Result<Conf, Box<dyn std::error::Error>> { 
+pub fn load_config(path: &str) -> Result<Conf, Box<dyn std::error::Error>> {
     let settings = Config::builder()
         .add_source(config::File::with_name(path))
-	.build()?;
+        .build()?;
 
-    let conf = settings
+    let conf = settings.try_deserialize::<Conf>()?;
-            .try_deserialize::<Conf>()?;
 
     Ok(conf)
 }

src/main.rs

@@ -1,60 +1,57 @@
+mod conf;
 ///
 /// Configure udev:
 /// https://github.com/Grix/helios_dac/blob/master/docs/udev_rules_for_linux.md
 ///
-
 mod redis_ctrl;
-mod conf;
 
-use helios_dac::{Frame,
-		 Point,
-		 DeviceStatus,
-		 // Coordinate,
-		 Color};
 use helios_dac::NativeHeliosDacController;
+use helios_dac::{
+    // Coordinate,
+    Color,
+    DeviceStatus,
+    Frame,
+    Point,
+};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 
-use redis_ctrl::{RedisCtrl,Order};
+use conf::{load_config, Conf};
-use conf::{load_config,Conf};
+use redis_ctrl::{Order, RedisCtrl};
 
-
+const CENTER: (u16, u16) = (2000, 2000);
-const CENTER : (u16,u16) = (2000, 2000);
 
 pub fn main() {
-
     let config = match load_config("Settings") {
-	Ok(c) => c,
+        Ok(c) => c,
-	Err(err) => {
+        Err(err) => {
-	    panic!("Unable to load config file: {:?}", err)
+            panic!("Unable to load config file: {:?}", err)
-	}
+        }
     };
 
     let rs = match RedisCtrl::new() {
-	Ok(rs) => rs,
+        Ok(rs) => rs,
-	Err(err) => {
+        Err(err) => {
-	    panic!("Unable to connect to redis: {:?}", err);
+            panic!("Unable to connect to redis: {:?}", err);
-	}
+        }
     };
 
     match run_dac(config, rs) {
-	Ok(()) => {},
+        Ok(()) => {}
-	Err(err) => {
+        Err(err) => {
-	    panic!("Error: {:?}", err)
+            panic!("Error: {:?}", err)
-	}
+        }
     }
 }
 
-fn run_dac(
+fn run_dac(config: Conf, mut rs: RedisCtrl) -> Result<(), Box<dyn std::error::Error>> {
-    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");
+    })
+    .expect("Error setting Ctrl-C handler");
 
     let controller = NativeHeliosDacController::new()?;
     let devices = controller.list_devices()?;
@@ -67,15 +64,14 @@ fn run_dac(
     let mut device = device.open()?;
 
     while running.load(Ordering::SeqCst) {
-	let order = rs.get_order(0)?;
+        let order = rs.get_order(0)?;
-	if order != Order::Draw {
+        if order != Order::Draw {
-	    println!("{:?}", order);
+            println!("{:?}", order);
-	}
+        }
 
-	let frame = get_next_frame(1000, &mut rs)?;
+        let frame = get_next_frame(1000, &mut rs)?;
 
-	while let Ok(DeviceStatus::NotReady) = device.status() {
+        while let Ok(DeviceStatus::NotReady) = device.status() {}
-	}
         device.write_frame(frame)?;
     }
 
@@ -84,38 +80,32 @@ fn run_dac(
     Ok(())
 }
 
-fn get_next_frame(
+fn get_next_frame(speed: u32, rs: &mut RedisCtrl) -> Result<Frame, Box<dyn std::error::Error>> {
-    speed: u32,
-    rs: &mut RedisCtrl
-) -> Result<Frame, Box<dyn std::error::Error>> {
-
     let line = rs.get("/pl/0/0")?;
-    let line : Vec<Point> = line.iter()
+    let line: Vec<Point> = line.iter().map(tuple_to_point).collect();
-	.map(tuple_to_point)
-	.collect();
 
     let mut line2 = vec![];
     while line2.len() < 48 {
-	for p in &line {
+        for p in &line {
-	    line2.push(*p);
+            line2.push(*p);
-	}
+        }
     }
 
     Ok(Frame::new(speed, line2))
 }
 
-fn tuple_to_point(tpl: &(f32,f32,u32)) -> Point {
+fn tuple_to_point(tpl: &(f32, f32, u32)) -> Point {
     let (x, y, col) = tpl;
 
-    let r = (col >> 16) as u8 ;
+    let r = (col >> 16) as u8;
-    let g = ((col >> 8) & 255) as u8 ;
+    let g = ((col >> 8) & 255) as u8;
-    let b = (col & 255) as u8 ;
+    let b = (col & 255) as u8;
 
     let x = CENTER.0 + *x as u16;
     let y = CENTER.1 + *y as u16;
 
     if x >= 4096 || y >= 4096 {
-	println!("WARN: coordinate out of range: {} {}", x, y);
+        println!("WARN: coordinate out of range: {} {}", x, y);
     }
     let x = x.clamp(0, 4095);
     let y = y.clamp(0, 4095);
@@ -123,6 +113,6 @@ fn tuple_to_point(tpl: &(f32,f32,u32)) -> Point {
     Point {
         coordinate: (x, y).into(),
         color: Color::new(r, g, b),
-        intensity: 0xFF
+        intensity: 0xFF,
     }
 }

src/redis_ctrl.rs

@@ -1,12 +1,8 @@
-use redis::{
+use redis::{Client, Commands, Connection};
-    Client,
-    Connection,
-    Commands
-};
 use ron::de::from_str;
 
 #[repr(u8)]
-#[derive(Debug,PartialEq)]
+#[derive(Debug, PartialEq)]
 pub enum Order {
     Draw = 0,
     Edh, //homography
@@ -16,71 +12,62 @@ pub enum Order {
     ClientKey,
     Intensity,
     Kpps,
-    ColorBalance
+    ColorBalance,
 }
 
 impl TryFrom<u8> for Order {
     type Error = String;
 
     fn try_from(value: u8) -> Result<Self, Self::Error> {
-	use Order::*;
+        use Order::*;
 
-	if value > 8 {
+        if value > 8 {
-	    return Err("order out of range".to_string());
+            return Err("order out of range".to_string());
-	}
+        }
 
-	Ok(match value {
+        Ok(match value {
-	    0 => Draw,
+            0 => Draw,
-	    1 => Edh,
+            1 => Edh,
-	    2 => Black,
+            2 => Black,
-	    3 => Grid,
+            3 => Grid,
-	    4 => Resampler,
+            4 => Resampler,
-	    5 => ClientKey,
+            5 => ClientKey,
-	    6 => Intensity,
+            6 => Intensity,
-	    7 => Kpps,
+            7 => Kpps,
-	    8 => ColorBalance,
+            8 => ColorBalance,
-	    _ => panic!("Can't be there")
+            _ => panic!("Can't be there"),
-	})
+        })
     }
 }
 
-pub type Line = Vec<(f32,f32,u32)>;
+pub type Line = Vec<(f32, f32, u32)>;
 
 pub struct RedisCtrl {
     pub client: Client,
-    pub connection: Connection
+    pub connection: Connection,
 }
 
 impl RedisCtrl {
-
     pub fn new() -> Result<Self, Box<dyn std::error::Error>> {
-	let client = Client::open("redis://127.0.0.1/")?;
+        let client = Client::open("redis://127.0.0.1/")?;
-	let connection = client.get_connection()?;
+        let connection = client.get_connection()?;
-	Ok(RedisCtrl { client, connection })
+        Ok(RedisCtrl { client, connection })
     }
 
-    pub fn get(
+    pub fn get(&mut self, key: &str) -> Result<Line, Box<dyn std::error::Error>> {
-	&mut self,
+        let val: String = self.connection.get(key)?;
-	key: &str
+        let line: Line = from_str(&val)?;
-    ) -> Result<Line, Box<dyn std::error::Error>> {
+        Ok(line)
-	let val : String = self.connection.get(key)?;
-	let line : Line = from_str(&val)?;
-	Ok(line)
     }
 
-    pub fn get_order(
+    pub fn get_order(&mut self, id: u8) -> Result<Order, Box<dyn std::error::Error>> {
-	&mut self,
+        let path = format!("/order/{id}");
-	id: u8
+        let val: u8 = self.connection.get(path.clone())?;
-    ) -> Result<Order, Box<dyn std::error::Error>> {
-	let path = format!("/order/{id}");
-	let val : u8 = self.connection.get(path.clone())?;
 
-	if val == 1 || val >= 4 {
+        if val == 1 || val >= 4 {
-	    self.connection.set(path, 0)?;
+            self.connection.set(path, 0)?;
-	}
+        }
 
-	Ok(val.try_into()?)
+        Ok(val.try_into()?)
     }
-
 }
-