remove serde_json as it's useless

examples/populate_redis.rs

@@ -1,4 +1,3 @@
-use std::io::_print;
 /**
 
 # Populate Redis Example
@@ -7,7 +6,6 @@ use std::io::_print;
 
 $ cargo run --example populate_redis
  **/
-
 use redis::{
     //RedisResult,
     Client,
@@ -19,7 +17,10 @@ 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(
+        "/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")?;
     let _ = con.set("/pl/0/0", "[(1000, 2000, 0), (1000, 1000, 65535), (2000, 1000, 65535), (2000, 2000, 65535), (1000, 2000, 65535)]")?;
@@ -29,6 +30,6 @@ fn do_something() -> redis::RedisResult<()> {
 fn main() {
     match do_something() {
         Err(err) => println!("Something wrong occured: {:?}", err),
-		Ok(..)                  => println!("Successfully inserted content in Redis")
+        Ok(..) => println!("Successfully inserted content in Redis"),
     }
 }

examples/simple_client.rs

@@ -1,15 +1,16 @@
 ///
 /// $ cargo run --example simple_client
 ///
-
 use redis::{
     //RedisResult,
     Client,
     Commands,
     Connection,
 };
+use std::thread::sleep;
+use std::time::{Duration, Instant};
 
-use std::time::Instant;
+const SCALE: f32 = 20.0;
 
 fn do_something() -> redis::RedisResult<()> {
     let client = Client::open("redis://127.0.0.1/")?;
@@ -18,25 +19,22 @@ fn do_something() -> redis::RedisResult<()> {
 
     loop {
         let elapsed = start.elapsed();
-	let time = 60.0 * elapsed.as_millis() as f32 / 1000.0;
+        let time = 60.0 * elapsed.as_millis() as f32 / 5_000.0;
 
-	let mut v : Vec<(f32,f32,u32)> = vec![];
+        let mut v: Vec<(f32, f32, u32)> = vec![];
 
         for i in 0..128 {
             let a = (time + i as f32) / 128.0 * std::f32::consts::PI * 2.0;
-	    let r = 1200.0 + (a*5.0).cos() * (500.0 * (time/5.0).cos());
+            let r = 24.0 * SCALE + (a * 5.0).cos() * (10.0 * SCALE * (time / 5.0).cos());
 
             let x = a.cos() * r;
             let y = a.sin() * r;
-	    let col = if i % 8 < 4 {
+            let col = if i % 8 < 4 { 0x000000ff } else { 0x00ff0000 };
-		0x000000ff
+            v.push((x, y, col));
-	    } else {
-		0x00ff0000
-	    };
-	    v.push((x,y,col));
         }
         // println!("{:?}", v);
         let _ = con.set("/pl/0/0", format!("{:?}", v))?;
+        sleep(Duration::from_millis(100));
     }
     // Ok(())
 }

src/device.rs

@@ -1,15 +1,15 @@
-mod helios;
 mod dummy;
 mod etherdream;
+mod helios;
 
-use std::fmt;
 use crate::conf::{Conf, DacFamily /*EtherDreamConf, HeliosConf*/};
-use crate::device::helios::HeliosDevice;
 use crate::device::dummy::DummyDevice;
+use crate::device::etherdream::EtherdreamDevice;
+use crate::device::helios::HeliosDevice;
 use crate::errors::LJResult;
 use crate::point::Point;
 use serde::Serialize;
-use crate::device::etherdream::EtherdreamDevice;
+use std::fmt;
 
 /*
 self.protocol_version,
@@ -28,7 +28,7 @@ self.point_count
 pub enum PlaybackState {
     IDLE = 0,
     PREPARE = 1,
-	PLAYING = 2
+    PLAYING = 2,
 }
 
 impl fmt::Display for PlaybackState {
@@ -52,11 +52,7 @@ pub struct Status {
 
 pub trait Device {
     fn status(&mut self) -> Status;
-	fn draw(
+    fn draw(&mut self, frame: Vec<Point>, speed: u32) -> LJResult<()>;
-		&mut self,
-		frame: Vec<Point>,
-		speed: u32,
-	) -> LJResult<()>;
     fn stop(&mut self) -> LJResult<()>;
     fn grid(&mut self) -> Vec<Point>;
 }
@@ -64,8 +60,8 @@ 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::Etherdream(conf) => Box::new(EtherdreamDevice::new(conf)?),
-		DacFamily::Dummy => Box::new(DummyDevice::new()?)
+        DacFamily::Dummy => Box::new(DummyDevice::new()?),
     };
     Ok(device)
 }

src/device/etherdream.rs

@@ -1,24 +1,23 @@
 #[warn(unused_imports)]
-use log::{ debug, info, warn};
+use log::{debug, info, warn};
 
+use chrono::{DateTime, Utc};
+use ether_dream::dac::stream::{connect, CommunicationError};
+use ether_dream::dac::{Playback, Stream};
 use std::net::SocketAddr;
 use std::thread::sleep;
-use ether_dream::dac::stream::{CommunicationError, connect};
-use ether_dream::dac::{Playback, Stream};
-use chrono::{DateTime, Utc};
 use std::time;
 use std::time::{Duration, SystemTime};
 
 use crate::conf::EtherDreamConf;
-use crate::device::{Device, Status, PlaybackState};
+use crate::device::{Device, PlaybackState, Status};
 use crate::errors::{LJError, LJResult};
 use crate::point::{Color, Point};
 use ether_dream::protocol::{DacBroadcast, DacResponse};
 
-
 #[warn(dead_code)]
 pub struct EtherdreamDevice {
-	pub conf: EtherDreamConf,
+    conf: EtherDreamConf,
     dac: DacBroadcast,
     stream: Stream,
 
@@ -34,16 +33,22 @@ pub struct EtherdreamDevice {
     //     pub const NAK_STOP_CONDITION: u8 = 0x21;
     // }
     dac_response: u8,
+    chunk_size: usize,
+    cool_down: Duration, // in milisecs
 }
 
 impl EtherdreamDevice {
     pub fn new(conf: &EtherDreamConf) -> LJResult<Self> {
         let (dac, _source_address, stream) = EtherdreamDevice::connect(conf)?;
+
+        let chunk_size = dac.buffer_capacity / 10;
         Ok(Self {
             conf: (*conf).clone(),
             dac,
             stream,
             dac_response: DacResponse::ACK,
+            chunk_size: chunk_size.into(),
+            cool_down: Duration::from_millis(20),
         })
     }
     fn connect(conf: &EtherDreamConf) -> LJResult<(DacBroadcast, SocketAddr, Stream)> {
@@ -53,11 +58,10 @@ impl EtherdreamDevice {
         info!("Attempting to get DAC broadcast...");
         let broadcast = dac_broadcast
             .take(3)
-			.filter_map(|result| {
+            .filter_map(|result| match result {
-				match result {
                 Err(err) => {
-						warn!( "Failed to find a valid DAC via broadcast. Error: {:?}", err);
+                    warn!("Failed to find a valid DAC via broadcast. Error: {:?}", err);
-						info!( "Retrying...");
+                    info!("Retrying...");
                     None
                 }
                 Ok((dac, source_addr)) => {
@@ -73,14 +77,11 @@ impl EtherdreamDevice {
                     }
                     Some(Ok((dac, source_addr)))
                 }
-				}
             })
             .next()
             .expect("Failed to receive broadcast.");
         match broadcast {
-			Err(err) => {
+            Err(err) => Err(Box::new(LJError::EtherdreamConnectError(err))),
-				Err(Box::new(LJError::EtherdreamConnectError(err)))
-			}
             Ok((dac, source_addr)) => {
                 info!("Trying to open TCP stream...");
                 let stream = EtherdreamDevice::get_tcp_stream(&dac, &source_addr)?;
@@ -117,9 +118,10 @@ impl EtherdreamDevice {
             .data(sine_wave.by_ref().take(400))
             // .data(begin_list.into_iter().take(400 as usize))
             .begin(0, points_per_second)
-			.submit() {
+            .submit()
-			Err(err) => warn!("err occurred when submitting first data: {}",err),
+        {
-			Ok(_) => info!("Sent first data to Etherdream.")
+            Err(err) => warn!("err occurred when submitting first data: {}", err),
+            Ok(_) => info!("Sent first data to Etherdream."),
         }
 
         Ok(stream)
@@ -130,14 +132,14 @@ impl EtherdreamDevice {
         Determine the number of points needed to fill the DAC.
          ***/
         // Fixme thread 'main' panicked at 'attempt to subtract with overflow', src/device/etherdream.rs:144:24
-		let n_points = self.dac.buffer_capacity as usize - self.stream.dac().dac.status.buffer_fullness as usize - 1;
+        let n_points = self.dac.buffer_capacity as i64
-		n_points
+            - self.stream.dac().dac.status.buffer_fullness as i64
+            - 1;
+        n_points.max(0) as usize
     }
 
     fn ping(&mut self) -> LJResult<()> {
-
         Ok(self.stream.queue_commands().ping().submit()?)
-
     }
 }
 
@@ -165,69 +167,76 @@ impl Device for EtherdreamDevice {
         // status
     }
 
-	fn draw(&mut self,
+    fn draw(&mut self, line: Vec<Point>, _speed: u32) -> LJResult<()> {
-	        line: Vec<Point>,
-	        _speed: u32,
-	) -> LJResult<()> {
-		let chunk_size = 64;
         let points_iter = line.into_iter();
-		for chunk in  points_iter.as_slice().chunks(chunk_size){
+        for chunk in points_iter.as_slice().chunks(self.chunk_size) {
             debug!("New chunk length: {:?}", chunk.len());
-			loop {
+            debug!("Point Cap: {}", self.points_capacity());
-				let capacity = self.points_capacity();
-				if chunk.len() > capacity {
-					debug!("Sleep, capacity : {:?}", capacity);
-					// Sleep for 1/100th of a sec
-					sleep(Duration::new( 0,     10000000));
-					self.ping()?;
-				} else {
-					break;
-				}
-			}
             debug!("drawing");
-			match self.stream
+            let mut cool_down = self.cool_down;
+            let mut i = 0;
+            while self.points_capacity() < chunk.len() {
+                debug!(
+                    "Buffer full, waiting... (Point Cap: {}), cool_down: {:?}",
+                    self.points_capacity(),
+                    self.cool_down
+                );
+                sleep(cool_down);
+                self.ping()?;
+                if i > 0 {
+                    cool_down *= 2;
+                }
+                i += 1;
+            }
+            if i > 1 {
+                info!(
+                    "Cool_down adjusted from {:?} to {:?}",
+                    self.cool_down, cool_down
+                );
+                self.cool_down = cool_down;
+            }
+
+            match self
+                .stream
                 .queue_commands()
                 .data(
-					chunk.iter()
+                    chunk
+                        .iter()
                         .map(|point| (*point).into())
-						.take(chunk_size)
+                        .take(self.chunk_size),
                 )
-				.submit() {
+                .submit()
+            {
                 Err(err) => {
                     // We should account for
                     // 'Broken pipe (os error 32)'
                     // Connection reset by peer (os error 104)
                     self.dac_response = match err {
                         CommunicationError::Io(err) => {
-							warn!("IO ERROR while drawing: '{}'",err);
+                            warn!("IO ERROR while drawing: '{}'", err);
                             DacResponse::ACK
                         }
                         CommunicationError::Protocol(err) => {
-							warn!("Protocol ERROR while drawing: '{}'",err);
+                            warn!("Protocol ERROR while drawing: '{}'", err);
                             DacResponse::ACK
                         }
                         CommunicationError::Response(err) => {
-							warn!("Response ERROR while drawing: '{}'",err);
+                            warn!("Response ERROR while drawing: '{}'", err);
                             err.response.response
                         }
                     };
                 }
                 Ok(_) => {
                     self.dac_response = DacResponse::ACK;
-					// debug!("Draw is ok");
                 }
-			};
+            }
         }
         Ok(())
     }
 
     fn stop(&mut self) -> LJResult<()> {
         info!("Stopping Etherdream device...");
-		match self.stream
+        match self.stream.queue_commands().stop().submit() {
-			.queue_commands()
-			.stop()
-			.submit()
-		{
             Err(err) => {
                 warn!("Failed to stop EtherDream device with error {:?}", err);
                 Err(Box::new(err))
@@ -243,21 +252,73 @@ impl Device for EtherdreamDevice {
         let dim_mid = 16000.0;
         let dim_max = 32000.0;
         let col_min = Color { r: 0, g: 0, b: 0 };
-		let col_max = Color { r: 255, g: 255, b: 255 };
+        let col_max = Color {
+            r: 255,
+            g: 255,
+            b: 255,
+        };
 
         vec![
-			Point { x: -dim_max, y: dim_max, color: col_min },
+            Point {
-			Point { x: -dim_max, y: dim_max, color: col_max },
+                x: -dim_max,
-			Point { x: dim_max, y: dim_max, color: col_max },
+                y: dim_max,
-			Point { x: dim_max, y: -dim_max, color: col_max },
+                color: col_min,
-			Point { x: -dim_max, y: -dim_max, color: col_max },
+            },
-			Point { x: -dim_max, y: -dim_mid, color: col_min },
+            Point {
-			Point { x: -dim_mid, y: dim_mid, color: col_min },
+                x: -dim_max,
-			Point { x: -dim_mid, y: dim_mid, color: col_max },
+                y: dim_max,
-			Point { x: dim_mid, y: dim_mid, color: col_max },
+                color: col_max,
-			Point { x: dim_mid, y: -dim_mid, color: col_max },
+            },
-			Point { x: -dim_mid, y: -dim_mid, color: col_max },
+            Point {
-			Point { x: -dim_mid, y: -dim_mid, color: col_min },
+                x: dim_max,
+                y: dim_max,
+                color: col_max,
+            },
+            Point {
+                x: dim_max,
+                y: -dim_max,
+                color: col_max,
+            },
+            Point {
+                x: -dim_max,
+                y: -dim_max,
+                color: col_max,
+            },
+            Point {
+                x: -dim_max,
+                y: -dim_mid,
+                color: col_min,
+            },
+            Point {
+                x: -dim_mid,
+                y: dim_mid,
+                color: col_min,
+            },
+            Point {
+                x: -dim_mid,
+                y: dim_mid,
+                color: col_max,
+            },
+            Point {
+                x: dim_mid,
+                y: dim_mid,
+                color: col_max,
+            },
+            Point {
+                x: dim_mid,
+                y: -dim_mid,
+                color: col_max,
+            },
+            Point {
+                x: -dim_mid,
+                y: -dim_mid,
+                color: col_max,
+            },
+            Point {
+                x: -dim_mid,
+                y: -dim_mid,
+                color: col_min,
+            },
         ]
     }
 }

src/device/helios.rs

@@ -1,9 +1,8 @@
-use std::time::SystemTime;
+use crate::conf::HeliosConf;
-///
+use crate::device::{Device, PlaybackState, Status};
-/// Configure udev:
+use crate::errors::{LJError, LJResult};
-/// https://github.com/Grix/helios_dac/blob/master/docs/udev_rules_for_linux.md
+use crate::point::{Color, Point};
-///
+use chrono::{DateTime, Utc};
-use helios_dac::{NativeHeliosDac, NativeHeliosDacController};
 use helios_dac::{
     // Coordinate,
     // Color,
@@ -11,12 +10,14 @@ use helios_dac::{
     Frame,
     // Point as HeliosPoint,
 };
-use crate::conf::HeliosConf;
+///
-use crate::device::{Device, Status, PlaybackState};
+/// Configure udev:
-use crate::errors::{LJError, LJResult};
+/// https://github.com/Grix/helios_dac/blob/master/docs/udev_rules_for_linux.md
-use crate::point::{Color, Point};
+///
-use chrono::{DateTime, Utc};
+use helios_dac::{NativeHeliosDac, NativeHeliosDacController};
+use std::time::SystemTime;
 
+#[allow(dead_code)]
 pub struct HeliosDevice {
     pub conf: HeliosConf,
     dac: NativeHeliosDac,
@@ -62,10 +63,7 @@ impl Device for HeliosDevice {
         }
     }
 
-	fn draw(&mut self,
+    fn draw(&mut self, line: Vec<Point>, speed: u32) -> LJResult<()> {
-	        line: Vec<Point>,
-	        speed: u32,
-	) -> LJResult<()> {
         self.state = PlaybackState::IDLE;
         while let Ok(DeviceStatus::NotReady) = self.dac.status() {}
         self.state = PlaybackState::PLAYING;
@@ -88,21 +86,73 @@ impl Device for HeliosDevice {
         let dim_mid = 2047.0;
         let dim_max = 4095.0;
         let col_min = Color { r: 0, g: 0, b: 0 };
-		let col_max = Color { r: 255, g: 255, b: 255 };
+        let col_max = Color {
+            r: 255,
+            g: 255,
+            b: 255,
+        };
 
         vec![
-			Point { x: dim_min, y: dim_max, color: col_min },
+            Point {
-			Point { x: dim_min, y: dim_max, color: col_max },
+                x: dim_min,
-			Point { x: dim_max, y: dim_max, color: col_max },
+                y: dim_max,
-			Point { x: dim_max, y: dim_min, color: col_max },
+                color: col_min,
-			Point { x: dim_min, y: dim_min, color: col_max },
+            },
-			Point { x: dim_min, y: dim_min, color: col_min },
+            Point {
-			Point { x: dim_min, y: dim_mid, color: col_min },
+                x: dim_min,
-			Point { x: dim_min, y: dim_mid, color: col_max },
+                y: dim_max,
-			Point { x: dim_mid, y: dim_mid, color: col_max },
+                color: col_max,
-			Point { x: dim_mid, y: dim_min, color: col_max },
+            },
-			Point { x: dim_min, y: dim_min, color: col_max },
+            Point {
-			Point { x: dim_min, y: dim_min, color: col_min },
+                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/main.rs

@@ -1,28 +1,29 @@
+mod conf;
+mod device;
+mod errors;
+mod framerate;
+mod point;
 ///
 /// Configure udev:
 /// https://github.com/Grix/helios_dac/blob/master/docs/udev_rules_for_linux.md
 ///
 mod redis_ctrl;
-mod conf;
-mod errors;
-mod point;
 mod transformer;
-mod device;
 mod worldstate;
-mod framerate;
 
+use conf::Conf;
 use device::device_factory;
+use env_logger::Builder;
+use errors::LJResult;
+use framerate::Framerate;
+use log::{/* warn, */ error, info, LevelFilter};
+use point::{Color, Point};
+use redis_ctrl::{Order, RedisCtrl};
+use std::io::Read;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
-use redis_ctrl::{RedisCtrl, Order};
-use conf::Conf;
-use errors::LJResult;
-use point::{Point, Color};
 use transformer::Transformers;
-use log::{LevelFilter, info, /* warn, */ error};
-use env_logger::Builder;
 use worldstate::WorldState;
-use framerate::Framerate;
 
 const DEFAULT_CONF_FILE: &str = "settings.toml";
 
@@ -35,7 +36,6 @@ pub fn main() {
     }
 }
 
-
 fn run_all() -> LJResult<()> {
     // Setup handler for interrupt Signals
     let running = Arc::new(AtomicBool::new(true));
@@ -45,13 +45,33 @@ fn run_all() -> LJResult<()> {
     })?;
 
     // Setup configuration file and set up logs
-	let filename = std::env::args().nth(1).unwrap_or_else(|| {
+    let filename = std::env::args()
-		DEFAULT_CONF_FILE.to_string()
+        .nth(1)
-	});
+        .unwrap_or_else(|| DEFAULT_CONF_FILE.to_string());
 
-	let config = Conf::new(&filename);
+    // read conf from stdin?
+    let config = if filename == "-" {
+        println!("Awaiting JSON config on standard input...");
+        let mut buff = String::new();
+        loop {
+            let mut buff2: Vec<u8> = vec![0; 4096];
+            let Ok(n) = std::io::stdin().read(&mut buff2) else {
+                panic!("read failled");
+            };
+            let s = std::str::from_utf8(&buff2[0..n]).unwrap();
+            buff.push_str(&s);
+
+            if n == 0 || buff2[n - 1] == 0 {
+                let config = toml::from_str(&buff[0..buff.len() - 1])?;
+                break Ok(config);
+            }
+        }
+    } else {
+        Conf::new(&filename)
+    };
     init_logging(&config);
     let config = config?;
+
     info!("*** Starting up ***");
 
     info!("{:?}", config);
@@ -62,7 +82,6 @@ fn run_all() -> LJResult<()> {
     let mut world_state = rs.init_world_state().unwrap();
     info!("WorldState: {:?}", world_state);
 
-
     // Setup Laser Device based on conf
     let mut tracer = device_factory(&config)?;
     world_state.grid = tracer.grid();
@@ -85,19 +104,13 @@ fn run_all() -> LJResult<()> {
                 // 3 : Draw GRID point list
                 world_state.draw_black = order == Order::Black;
                 world_state.draw_grid = order == Order::Grid;
-				let frame = get_next_frame(
+                let frame = get_next_frame(&config, &transformers, &mut rs, &world_state)?;
-					&config,
-					&transformers,
-					&mut rs,
-					&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")?
+                world_state.intensity = rs.get_int("intensity")?.try_into()?;
-					.try_into()?;
             }
             Order::Edh => {
                 // 1 : Get the new EDH          = reread redis key /EDH/lasernumber
@@ -117,9 +130,9 @@ fn run_all() -> LJResult<()> {
             Order::Resampler => {
                 world_state.resampler = rs.get_resampler()?;
             }
-			_ => {
+            Order::PowerOff => {
-				// 9 : poweroff LJ
+                info!("PowerOff command recieved.");
-				info!("Order: {:?}", order);
+                break;
             }
         }
     }
@@ -137,9 +150,7 @@ fn init_logging(config: &LJResult<Conf>) {
             LevelFilter::Info
         };
         let mut builder = Builder::from_default_env();
-		builder
+        builder.filter(None, level).init();
-			.filter(None, level)
-			.init();
         info!("Debug mode enabled from configuration file");
         return;
     }
@@ -153,9 +164,7 @@ fn get_next_frame(
     rs: &mut RedisCtrl,
     world_state: &WorldState,
 ) -> LJResult<Vec<Point>> {
-	let format_key = format!("{}{}",
+    let format_key = format!("{}{}", world_state.client_key, config.laser_id);
-	                         world_state.client_key,
-	                         config.laser_id);
 
     // Handle the grid case
 
@@ -163,9 +172,7 @@ fn get_next_frame(
         world_state.grid.clone()
     } else {
         let redis_line = rs.get_line(&format_key)?;
-		redis_line.into_iter()
+        redis_line.into_iter().map(|tpl| tpl.into()).collect()
-			.map(|tpl| tpl.into())
-			.collect()
     };
 
     for transformer in transformers {
@@ -176,7 +183,8 @@ fn get_next_frame(
     // info!("Draw Grid -> {}", world_state.draw_grid);
 
     // LIMITER and BLACK
-	line = line.into_iter()
+    line = line
+        .into_iter()
         .map(|p| {
             let color = if world_state.draw_black {
                 Color { r: 0, g: 0, b: 0 }
@@ -187,14 +195,10 @@ fn get_next_frame(
                     b: p.color.b.min(world_state.intensity),
                 }
             };
-			Point {
+            Point { color, ..p }
-				color,
-				..p
-			}
         })
         .collect();
 
     //info!("Line: {:?}", line);
     Ok(line)
 }
-

src/redis_ctrl.rs

@@ -1,8 +1,8 @@
-use redis::{Client, Commands, Connection};
-use ron::de::from_str;
 use crate::device::Status;
 use crate::errors::{LJError, LJResult};
 use crate::worldstate::{WorldState, EDH};
+use redis::{Client, Commands, Connection};
+use ron::de::from_str;
 // use log::info;
 
 #[repr(u8)]
@@ -17,7 +17,7 @@ pub enum Order {
     Intensity,
     Kpps,
     ColorBalance,
-	PowerOff
+    PowerOff,
 }
 
 impl TryFrom<u8> for Order {
@@ -26,7 +26,7 @@ impl TryFrom<u8> for Order {
     fn try_from(value: u8) -> Result<Self, Self::Error> {
         use Order::*;
 
-		if value > 8 {
+        if value > 9 {
             return Err("order out of range".to_string());
         }
 
@@ -41,27 +41,29 @@ impl TryFrom<u8> for Order {
             7 => Kpps,
             8 => ColorBalance,
             9 => PowerOff,
-			_ => unreachable!()
+            _ => unreachable!(),
         })
     }
 }
 
 pub type Line = Vec<(f32, f32, u32)>;
-pub type Resampler = Vec<Vec<(f32,f32)>>;
+pub type Resampler = Vec<Vec<(f32, f32)>>;
 
 pub struct RedisCtrl {
-	pub client: Client,
+    //pub client: Client,
     pub connection: Connection,
     laser_id: u8,
 }
 
 impl RedisCtrl {
     pub fn new(url: &str, laser_id: &u8) -> LJResult<Self> {
-		let client = Client::open(url)
+        let client = Client::open(url).map_err(LJError::RedisConnect)?;
-			.map_err(LJError::RedisConnect)?;
+        let connection = client.get_connection().map_err(LJError::RedisConnect)?;
-		let connection = client.get_connection()
+        Ok(RedisCtrl {
-			.map_err(LJError::RedisConnect)?;
+            //client,
-		Ok(RedisCtrl { client, connection, laser_id: *laser_id })
+            connection,
+            laser_id: *laser_id,
+        })
     }
 
     pub fn get_line(&mut self, key: &str) -> LJResult<Line> {
@@ -128,9 +130,11 @@ impl RedisCtrl {
         ))
     }
 
-	pub fn get_resampler(&mut self ) -> LJResult<Resampler> {
+    pub fn get_resampler(&mut self) -> LJResult<Resampler> {
-		let val: String = self.connection.get(format!("/resampler/{}", self.laser_id))?;
+        let val: String = self
-		let resampler : Resampler = from_str(&val)?;
+            .connection
+            .get(format!("/resampler/{}", self.laser_id))?;
+        let resampler: Resampler = from_str(&val)?;
         Ok(resampler)
     }
 

src/transformer/intensity.rs

@@ -1,28 +1,27 @@
-use log::debug;
-use crate::transformer::Transformers;
 use crate::point::Point;
+use crate::transformer::Transformers;
 use crate::worldstate::WorldState;
+use log::debug;
 
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
 
 /// Converts helios Geometry to Helios
 #[allow(dead_code)]
 #[derive(Serialize, Deserialize, Debug, Clone, Copy)]
-pub struct Intensity {
+pub struct Intensity {}
-}
 
 impl Transformers for Intensity {
     fn apply(&self, point_list: &[Point], ws: &WorldState) -> Vec<Point> {
         // debug!("list helios {:?}", point_list);
-		let out = point_list.iter().map(|pt| {
+        let out = point_list
-			Point {
+            .iter()
+            .map(|pt| Point {
                 x: pt.x,
                 y: pt.y,
-				color: pt.color * ws.intensity
+                color: pt.color * ws.intensity,
-			}
+            })
-		}).collect();
+            .collect();
-		debug!("list intensity {:?}", out);
+        //debug!("list intensity {:?}", out);
         out
     }
 }
-