brewdrivers 0.17.0

Brewkit drivers
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

use brewdrivers::{
    controllers::Controller,
    drivers::InstrumentError,
    model::{Device, RTU},
    state::BinaryState,
};

// This isn't a conventional test. I want to make sure that the timeout/command retries are
// happening, which takes several seconds depending on the config. This test will usually not be
// run in the normal test suite.
#[allow(unused)]
// #[tokio::test]
async fn test_retry_command_delay() -> Result<(), InstrumentError> {
    // RUST_LOG=trace cargo test test_retry_command_delay -- --nocapture
    env_logger::init();
    let mut device: Device = serde_yaml::from_str(
        r#"
            id: wsrelay0
            name: Waveshare Relay
            command_retries: 5
            retry_delay: 400
            conn:
              port: /dev/ttyUSB1
              baudrate: 38400
              timeout: 40
              controller: WaveshareV2
              controller_addr: 1
              addr: 0
        "#,
    )
    .unwrap();

    let result = device.update().await;
    assert!(result.is_err());
    Ok(())
}

#[tokio::test]
async fn test_generate_and_update_device_state() -> Result<(), InstrumentError> {
    // This generates an RTU state from the config file and updates all state
    // values in all devices. It's like taking a snapshot of all state values for the whole RTU.
    let res = RTU::generate(Some(brewdrivers::defaults::test_config_file()));
    assert!(res.is_ok());
    let mut rtu = res.unwrap();
    assert!(rtu.devices.len() > 0);

    let relay = rtu
        .devices
        .iter_mut()
        .find(|dev| *dev.conn.controller() == Controller::WaveshareV2);

    if let Some(device) = relay {
        // All state values start as None
        assert!(device.state.relay_state.is_none());
        assert!(device.state.pv.is_none());
        assert!(device.state.sv.is_none());

        device.update().await?;

        assert!(device.state.relay_state.is_some());
        assert!(device.state.pv.is_none());
        assert!(device.state.sv.is_none());
    }

    let pid = rtu
        .devices
        .iter_mut()
        .find(|dev| *dev.conn.controller() == Controller::CN7500);

    if let Some(device) = pid {
        // All state values start as None
        assert!(device.state.relay_state.is_none());
        assert!(device.state.pv.is_none());
        assert!(device.state.sv.is_none());

        device.update().await?;

        assert!(device.state.relay_state.is_some());
        assert!(device.state.pv.is_some());
        assert!(device.state.sv.is_some());
    }

    Ok(())
}

#[tokio::test]
async fn test_device_enact() -> Result<(), InstrumentError> {
    // There does exist an RTU::enact() method, but we try not to use it
    // because it will try to write to every device. This takes a long time.
    let res = RTU::generate(Some(brewdrivers::defaults::test_config_file()));
    assert!(res.is_ok());
    let mut rtu = res.unwrap();
    assert!(rtu.devices.len() > 0);

    let relay = rtu
        .devices
        .iter_mut()
        .find(|dev| *dev.conn.controller() == Controller::WaveshareV2);

    // All state values start as None
    if let Some(device) = relay {
        assert!(device.state.relay_state.is_none());
        assert!(device.state.pv.is_none());
        assert!(device.state.sv.is_none());
        device.state.relay_state = Some(BinaryState::On);
        device.enact().await?;
    }

    let relay_again = rtu
        .devices
        .iter_mut()
        .find(|dev| *dev.conn.controller() == Controller::WaveshareV2);
    if let Some(device) = relay_again {
        assert_eq!(device.state.relay_state, Some(BinaryState::On));
        assert!(device.state.pv.is_none());
        assert!(device.state.sv.is_none());

        device.state.relay_state = Some(BinaryState::Off);
        device.enact().await?;
    }

    Ok(())
}