max44009 0.2.0

Platform-agnostic Rust driver for the MAX44009 ambient light sensor.
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 embedded_hal_mock::i2c::Transaction as I2cTrans;
use max44009::{
    ConfigurationMode as CM, CurrentDivisionRatio as CDR, Error, IntegrationTime as IT,
    MeasurementMode as MM,
};
mod common;
use crate::common::{destroy, new, Register, DEV_BASE_ADDR};

fn assert_operation_not_available_error<T, E>(result: Result<T, Error<E>>) {
    match result {
        Err(Error::OperationNotAvailable) => (),
        _ => panic!("Did not return Error::OperationNotAvailable."),
    }
}

#[test]
fn can_enable_interrupt() {
    let mut dev = new(&[I2cTrans::write(
        DEV_BASE_ADDR,
        vec![Register::INT_ENABLE, 1],
    )]);
    dev.enable_interrupt().unwrap();
    destroy(dev);
}

#[test]
fn can_disable_interrupt() {
    let mut dev = new(&[I2cTrans::write(
        DEV_BASE_ADDR,
        vec![Register::INT_ENABLE, 0],
    )]);
    dev.disable_interrupt().unwrap();
    destroy(dev);
}

macro_rules! set_mode_test {
    ($test_name:ident, $method:ident, $enum:ident::$variant:ident, $expected:expr) => {
        #[test]
        fn $test_name() {
            let mut dev = new(&[I2cTrans::write(
                DEV_BASE_ADDR,
                vec![Register::CONFIGURATION, $expected],
            )]);
            dev.$method($enum::$variant).unwrap();
            destroy(dev);
        }
    };
}

set_mode_test!(
    can_set_measurement_mode_once_every_800ms,
    set_measurement_mode,
    MM::OnceEvery800ms,
    0
);
set_mode_test!(
    can_set_measurement_mode_continuous,
    set_measurement_mode,
    MM::Continuous,
    0b1000_0000
);

set_mode_test!(
    can_set_automatic_mode,
    set_configuration_mode,
    CM::Automatic,
    0b0000_0000
);
set_mode_test!(
    can_set_manual_mode,
    set_configuration_mode,
    CM::Manual,
    0b0100_0000
);

#[test]
fn cannot_set_current_division_ratio_in_automatic_mode() {
    let mut dev = new(&[]);
    assert_operation_not_available_error(dev.set_current_division_ratio(CDR::One));
    destroy(dev);
}

#[test]
fn cannot_set_integration_time_in_automatic_mode() {
    let mut dev = new(&[]);
    assert_operation_not_available_error(dev.set_integration_time(IT::_100ms));
    destroy(dev);
}

macro_rules! set_param_test {
    ($test_name:ident, $method:ident, $enum:ident::$variant:ident, $expected:expr) => {
        #[test]
        fn $test_name() {
            let mut dev = new(&[
                I2cTrans::write(DEV_BASE_ADDR, vec![Register::CONFIGURATION, 0b0100_0000]),
                I2cTrans::write(
                    DEV_BASE_ADDR,
                    vec![Register::CONFIGURATION, 0b0100_0000 | $expected],
                ),
            ]);
            dev.set_configuration_mode(CM::Manual).unwrap();
            dev.$method($enum::$variant).unwrap();
            destroy(dev);
        }
    };
}

set_param_test!(can_set_cdr_one, set_current_division_ratio, CDR::One, 0);
set_param_test!(
    can_set_cdr_one_eighth,
    set_current_division_ratio,
    CDR::OneEighth,
    8
);

set_param_test!(can_set_it_800ms, set_integration_time, IT::_800ms, 0);
set_param_test!(can_set_it_400ms, set_integration_time, IT::_400ms, 1);
set_param_test!(can_set_it_200ms, set_integration_time, IT::_200ms, 2);
set_param_test!(can_set_it_100ms, set_integration_time, IT::_100ms, 3);
set_param_test!(can_set_it_50ms, set_integration_time, IT::_50ms, 4);
set_param_test!(can_set_it_25ms, set_integration_time, IT::_25ms, 5);
set_param_test!(can_set_it_12_5ms, set_integration_time, IT::_12_5ms, 6);
set_param_test!(can_set_it_6_25ms, set_integration_time, IT::_6_25ms, 7);