luxafor 0.3.0

Library, and CLI, for Luxafor lights via either USB or webhooks.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

#[allow(unused_imports)]
#[macro_use]
extern crate log;

use luxafor::usb_hid::USBDeviceDiscovery;
use luxafor::{webhook, Device, Pattern, SolidColor, Wave};
use std::error::Error;
use structopt::StructOpt;

#[derive(Debug, StructOpt)]
#[structopt(name = "lux", about = "CLI for Luxafor lights")]
pub(crate) struct CommandLine {
    /// The level of logging to perform; from off to trace
    #[structopt(long, short = "v", parse(from_occurrences))]
    verbose: i8,

    /// The device identifier
    #[structopt(long, short, env = "LUX_DEVICE")]
    device: String,

    #[structopt(subcommand)]
    cmd: SubCommand,
}

#[derive(Debug, StructOpt)]
pub(crate) enum SubCommand {
    /// Set the light to a to a solid color
    Solid {
        /// The color to set
        #[structopt(name = "COLOR")]
        color: SolidColor,
    },
    /// Set the light to a to a strobing/blinking color
    Strobe {
        /// The color to set
        #[structopt(name = "COLOR")]
        color: SolidColor,

        /// The speed of each strobe cycle
        #[structopt(long, short, default_value = "10")]
        speed: u8,

        /// The number of times to repeat the strobe
        #[structopt(long, short, default_value = "255")]
        repeat: u8,
    },
    /// Set the light to fade from the current to a new color
    Fade {
        /// The color to set
        #[structopt(name = "COLOR")]
        color: SolidColor,

        /// The speed of each strobe cycle
        #[structopt(long, short, default_value = "60")]
        fade_duration: u8,
    },
    /// Set the light to a to a pre-defined wave pattern
    Wave {
        /// The color to set
        #[structopt(name = "COLOR")]
        color: SolidColor,

        /// The pattern to set
        #[structopt(default_value = "short")]
        pattern: Wave,

        /// The speed of each wave cycle
        #[structopt(long, short, default_value = "30")]
        speed: u8,

        /// The number of times to repeat the pattern
        #[structopt(long, short, default_value = "255")]
        repeat: u8,
    },
    /// Set the light to a to a pre-defined pattern
    Pattern {
        /// The pattern to set
        pattern: Pattern,

        /// The number of times to repeat the pattern
        #[structopt(long, short, default_value = "255")]
        repeat: u8,
    },
    /// Turn the light off
    Off,
}

const DEVICE_CONNECTION_USB: &str = "usb";

fn main() -> Result<(), Box<dyn Error>> {
    let args = CommandLine::from_args();

    pretty_env_logger::formatted_builder()
        .filter_level(match args.verbose {
            0 => log::LevelFilter::Off,
            1 => log::LevelFilter::Error,
            2 => log::LevelFilter::Warn,
            3 => log::LevelFilter::Info,
            4 => log::LevelFilter::Debug,
            _ => log::LevelFilter::Trace,
        })
        .init();

    if args.device == DEVICE_CONNECTION_USB {
        let discovery = USBDeviceDiscovery::new()?;
        let device = discovery.device()?;
        debug!("USB device: '{}'", device.id());
        set_lights(args, device)
    } else {
        let device_id = args.device.clone();
        set_lights(args, webhook::new_device_for(&device_id)?)
    }
}

fn set_lights(args: CommandLine, device: impl Device) -> Result<(), Box<dyn Error>> {
    match args.cmd {
        SubCommand::Solid { color } => device.set_solid_color(color),
        SubCommand::Fade {
            color,
            fade_duration,
        } => device.set_fade_to_color(color, fade_duration),
        SubCommand::Strobe {
            color,
            speed,
            repeat,
        } => device.set_color_strobe(color, speed, repeat),
        SubCommand::Wave {
            color,
            pattern,
            speed,
            repeat,
        } => device.set_color_wave(color, pattern, speed, repeat),
        SubCommand::Pattern { pattern, repeat } => device.set_pattern(pattern, repeat),
        SubCommand::Off => device.turn_off(),
    }?;

    Ok(())
}