212 lines
5.7 KiB
Rust
212 lines
5.7 KiB
Rust
use rs_ws281x::RawColor;
|
|
use std::{
|
|
vec::Vec,
|
|
string::String
|
|
};
|
|
use std::sync::RwLockWriteGuard;
|
|
|
|
pub type ParseError = Box<dyn std::error::Error>;
|
|
|
|
pub trait Pattern: Send {
|
|
fn execute(&self, values: &mut RwLockWriteGuard<'_, [RawColor; crate::LED_SIZE]>, ticks: u64);
|
|
fn parse(args: Vec<String>) -> Result<Self, ParseError> where Self: Sized;
|
|
}
|
|
|
|
impl TryFrom<Vec<String>> for Box<dyn Pattern> {
|
|
type Error = ParseError;
|
|
fn try_from(s: Vec<String>) -> Result<Self, Self::Error> {
|
|
match s[0].as_str() {
|
|
"unit" => Ok(Box::new(Unit::parse(s).unwrap()) as Box<dyn Pattern>),
|
|
"val" => Ok(Box::new(Value::parse(s).unwrap()) as Box<dyn Pattern>),
|
|
"rand" => Ok(Box::new(Random::parse(s).unwrap()) as Box<dyn Pattern>),
|
|
_ => Err("No Match".into())
|
|
}
|
|
}
|
|
}
|
|
|
|
struct Unit;
|
|
impl Pattern for Unit {
|
|
fn execute(&self, _values: &mut RwLockWriteGuard<'_, [RawColor; crate::LED_SIZE]>, _ticks: u64) {}
|
|
fn parse(_args: Vec<String>) -> Result<Self, ParseError> {
|
|
Ok(Unit {})
|
|
}
|
|
}
|
|
|
|
struct Value {
|
|
r: Option<u8>,
|
|
g: Option<u8>,
|
|
b: Option<u8>
|
|
}
|
|
|
|
impl Pattern for Value {
|
|
fn execute(&self, values: &mut RwLockWriteGuard<'_, [RawColor; crate::LED_SIZE]>, _ticks: u64) {
|
|
for i in 0..crate::LED_SIZE {
|
|
let mut color: RawColor = (*values)[i];
|
|
if self.r.is_some() {
|
|
color[2] = self.r.unwrap();
|
|
}
|
|
if self.g.is_some() {
|
|
color[1] = self.g.unwrap();
|
|
}
|
|
if self.b.is_some() {
|
|
color[0] = self.b.unwrap();
|
|
}
|
|
(*values)[i] = color;
|
|
}
|
|
}
|
|
fn parse(args: Vec<String>) -> Result<Self, ParseError> {
|
|
let param1 = if args.len() > 1 {
|
|
match args[1].parse::<u8>() {
|
|
Ok(i) => Some(i),
|
|
Err(_) => None
|
|
}
|
|
} else {
|
|
None
|
|
};
|
|
let param2 = if args.len() > 2 {
|
|
match args[2].parse::<u8>() {
|
|
Ok(i) => Some(i),
|
|
Err(_) => None
|
|
}
|
|
} else {
|
|
None
|
|
};
|
|
let param3 = if args.len() > 3 {
|
|
match args[3].parse::<u8>() {
|
|
Ok(i) => Some(i),
|
|
Err(_) => None
|
|
}
|
|
} else {
|
|
None
|
|
};
|
|
if param1.is_some() && param2.is_some() && param3.is_some() {
|
|
Ok(Value{
|
|
r: param1,
|
|
g: param2,
|
|
b: param3
|
|
})
|
|
}
|
|
else if args.len() >= 2 {
|
|
match param2 {
|
|
Some(i) => match args[1].as_str() {
|
|
"r" => {
|
|
Ok(Value {
|
|
r: Some(i),
|
|
g: None,
|
|
b: None
|
|
})
|
|
},
|
|
"g" => {
|
|
Ok(Value {
|
|
r: None,
|
|
g: Some(i),
|
|
b: None
|
|
})
|
|
},
|
|
"b" => {
|
|
Ok(Value {
|
|
r: None,
|
|
g: None,
|
|
b: Some(i)
|
|
})
|
|
}
|
|
_ => Err("no rgb".into())
|
|
},
|
|
None => Err("no param2".into())
|
|
}
|
|
}
|
|
else {
|
|
Err("incorrect number of arguments".into())
|
|
}
|
|
}
|
|
}
|
|
|
|
struct Random {
|
|
r: bool,
|
|
g: bool,
|
|
b: bool,
|
|
min: u8,
|
|
max: u8
|
|
}
|
|
|
|
impl Pattern for Random {
|
|
fn execute(&self, values: &mut RwLockWriteGuard<'_, [RawColor; crate::LED_SIZE]>, _ticks: u64) {
|
|
use rand::prelude::*;
|
|
let mut rng = rand::thread_rng();
|
|
for x in 0..values.len() {
|
|
let mut color = (*values)[x];
|
|
if self.r {
|
|
let y: f64 = rng.gen();
|
|
color[2] = ((y * (max - min))+min) as u8;
|
|
}
|
|
if self.g {
|
|
let y: f64 = rng.gen();
|
|
color[1] = ((y * (max - min))+min) as u8;
|
|
}
|
|
if self.b {
|
|
let y: f64 = rng.gen();
|
|
color[0] = ((y * (max - min))+min) as u8;
|
|
}
|
|
}
|
|
}
|
|
fn parse(args: Vec<String>) -> Result<Self, ParseError> {
|
|
let end = args.len() - 1;
|
|
let e = args[end].parse::<u8>();
|
|
let en = args[end-1].parse::<u8>();
|
|
let mut r = false;
|
|
let mut g = false;
|
|
let mut b = false;
|
|
let (min, max) = match en {
|
|
Ok(i) => {
|
|
match e {
|
|
Ok(j) => (i, j),
|
|
Err(_) => (0, 255)
|
|
}
|
|
},
|
|
Err(_) => {
|
|
match e {
|
|
Ok(i) => (0, i),
|
|
Err(_) => (0, 255)
|
|
}
|
|
}
|
|
};
|
|
for x in 1..end {
|
|
match args[x].as_str() {
|
|
"r" => {r = true;},
|
|
"g" => {g = true;},
|
|
"b" => {b = true;},
|
|
_ => {}
|
|
}
|
|
}
|
|
Ok(Random {
|
|
r: r,
|
|
g: g,
|
|
b: b,
|
|
min: min,
|
|
max: max
|
|
})
|
|
}
|
|
}
|
|
|
|
struct Rainbow {
|
|
offset_r: Option<usize>,
|
|
offset_g: Option<usize>,
|
|
offset_b: Option<usize>
|
|
}
|
|
// todo
|
|
|
|
pub fn parse_line(v: Vec<String>) -> Result<Box<dyn Pattern>, ParseError> {
|
|
println!("{:?}", v);
|
|
v.try_into()
|
|
}
|
|
|
|
pub fn format_multiline(input: &str) -> Vec<Vec<String>> {
|
|
input.lines()
|
|
.map(|x: &str|
|
|
x.split_whitespace()
|
|
.map(|y| String::from(y))
|
|
.collect::<Vec<String>>()
|
|
)
|
|
.collect()
|
|
}
|