relay8x 0.1.1

control a specific 8x relaise card via serial / USB
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

extern crate docopt;
extern crate env_logger;
extern crate relay8x;
extern crate serde;
#[macro_use]
extern crate serde_derive;
// #[macro_use]
// extern crate failure;

use docopt::Docopt;
use std::{io, thread::sleep, time::Duration};

use relay8x::{CardIndex, Relay8x, RelayIndex};

const USAGE: &'static str = "
relay8x

Usage:
  relay8x set --dev=<dev> [--card=<card> ...] [--relay=<relay> ...] <state>
  relay8x toggle --dev=<dev> [--card=<card> ...] [--relay=<relay> ...]
  relay8x reset --dev=<dev> [--card=<card> ...] [--relay=<relay> ...]
  relay8x (-h | --help)
  relay8x (-v | --version)
  
Commands:
  set   set specified relay 'on' or 'off', if no relay number is given all relays are set
  toggle    toggle specified relay,  if no relay number is given all relays are toggeled
  reset switch all or just one relay off to reach defined state again

Options:
  -h --help         Show this screen.
  -v --version      Show version.
  --dev=<dev>       path to serial device, e.g. /dev/ttyUSB0
  --relay=<relay>   number of relays (1..8), one flag per relay [default: 1 2 3 4 5 6 7 8]
  --card=<card>     number of card (1..x), one flag per card [default: 0]
";

#[derive(Debug, Deserialize)]
struct Args {
    cmd_set: bool,
    cmd_toggle: bool,
    cmd_reset: bool,
    flag_dev: String,
    flag_version: bool,
    flag_help: bool,
    flag_relay: Option<RelayIndex>,
    flag_card: Option<CardIndex>,
    arg_state: String,
}

const VERSION: &'static str = env!("CARGO_PKG_VERSION");
const NAME: &'static str = env!("CARGO_PKG_NAME");

fn main() -> io::Result<()> {
    env_logger::init();

    let args: Args = Docopt::new(USAGE)
        .and_then(|d| d.deserialize())
        .unwrap_or_else(|e| e.exit());

    // check arguments
    if args.flag_version {
        println!("{}: {}", NAME, VERSION);
        Ok(())
    } else if args.flag_help {
        println!("{}", USAGE);
        Ok(())
    } else if args.cmd_set {
        // open device, address of relay is always 1 as for now
        let mut relay = Relay8x::new(args.flag_dev.as_str(), 1)?;
        relay.configure_device()?;
        // if flag_relay is none, all relays should be set
        let relay_numbers = args.flag_relay.unwrap_or_default();
        // if flag_card is none, all cards should be set
        let card_numbers = args.flag_card.unwrap_or_default();
        // map state argument to set or reset
        match args.arg_state.as_ref() {
            "on" => relay.set_relays(card_numbers, relay_numbers)?,
            "off" => relay.reset_relays(card_numbers, relay_numbers)?,
            _ => {
                return Err(io::Error::new(
                    io::ErrorKind::Other,
                    "Failed to determine state, use 'on' or 'off'.",
                ))
            }
        };
        Ok(())
    } else if args.cmd_toggle {
        // open device
        let mut relay = Relay8x::new(args.flag_dev.as_str(), 1)?;
        relay.configure_device()?;
        // wait to give cards time to answer
        sleep(Duration::from_millis(10));
        // if flag is none, all relays should be toggeled
        let relay_numbers = args.flag_relay.unwrap_or_default();
        // if flag_card is none, all cards should be set
        let card_numbers = args.flag_card.unwrap_or_default();
        // do the toggle
        relay.toggle_relays(card_numbers, relay_numbers)?;
        Ok(())
    } else if args.cmd_reset {
        // open device
        let mut relay = Relay8x::new(args.flag_dev.as_str(), 1)?;
        relay.configure_device()?;
        // wait to give cards time to answer
        sleep(Duration::from_millis(10));
        // if flag is none, all relays should be reset
        let relay_numbers = args.flag_relay.unwrap_or_default();
        // if flag_card is none, all cards should be set
        let card_numbers = args.flag_card.unwrap_or_default();
        // do the switching, false = off
        relay.reset_relays(card_numbers, relay_numbers)?;
        Ok(())
    } else {
        println!("I don't know what you want to do..");
        Ok(())
    }
}