mcp3424 0.3.0

Async Rust driver for the MCP3422/3/4 ADC.
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
139
140
141
142

use crate::{Channel, Gain, Resolution};

/// Mode independent user configuration.
///
/// A [`Configuration`] specifies the following device parameters:
/// * [`Channel`]: The device's input channel.
/// * [`Resolution`]: The resolution and sampling rate.
/// * [`Gain`]: The on-board programmable gain amplifier (PGA).
///
/// The MCP342[2/3/4] provides a constant conversion time only depending on the configured
/// [`Resolution`]. To tweak timings when reading the device's output buffer the driver's assumed
/// [`ConversionTime`] can be adjusted.
///
#[derive(Clone)]
#[cfg_attr(any(feature = "fmt", test), derive(Debug))]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub struct Configuration {
    pub channel: Channel,
    pub resolution: Resolution,
    pub gain: Gain,
    pub conversion_time: ConversionTime,
}

impl Configuration {

    pub fn new(channel: Channel, resolution: Resolution, gain: Gain, conversion_time: ConversionTime) -> Self {
        Self { channel, resolution, gain, conversion_time }
    }

    pub fn with_channel(mut self, channel: Channel) -> Self {
        self.channel = channel;
        self
    }

    pub fn with_resolution(mut self, resolution: Resolution) -> Self {
        self.resolution = resolution;
        self
    }

    pub fn with_gain(mut self, gain: Gain) -> Self {
        self.gain = gain;
        self
    }

    pub fn with_conversion_time(mut self, conversion_time: ConversionTime) -> Self {
        self.conversion_time = conversion_time;
        self
    }

    pub fn conversion_time_us(&self) -> u32 {
        match self.conversion_time {
            ConversionTime::Absolute(value) => value,
            ConversionTime::Offset(value) => self.resolution.conversion_time_us().saturating_add_signed(value)
        }
    }
}

impl Default for Configuration {
    fn default() -> Self {
        Self {
            channel: Channel::Channel1,
            resolution: Resolution::TwelveBits,
            gain: Gain::X1,
            conversion_time: ConversionTime::Offset(0)
        }
    }
}

/// Configuration parameter to adjust the driver's assumed conversion time.
///
/// **Default:** `ConversionTime::Offset(0)`
///
/// # See also
/// [`Configuration`], [`Channel`], [`Gain`], [`Resolution`]
///
#[derive(Copy, Clone)]
#[cfg_attr(any(feature = "fmt", test), derive(Debug))]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum ConversionTime {
    /// Sets conversion time in µs to the specified value.
    Absolute(u32),
    /// Applies an offset in µs to the driver's assumed conversion time.
    Offset(i32)
}

impl Default for ConversionTime {
    fn default() -> Self {
        ConversionTime::Offset(0)
    }
}

#[cfg(test)]
#[allow(non_snake_case)]
mod tests {

    use googletest::prelude::*;
    use rstest::rstest;
    use crate::config::{Configuration, ConversionTime};
    use crate::Resolution;

    #[rstest]
    fn conversion_time_us_should_return_an_absolute_value() -> Result<()> {

        let configuration = Configuration {
            conversion_time: ConversionTime::Absolute(42),
            ..Configuration::default()
        };

        verify_that!(configuration.conversion_time_us(), eq(42))?;

        Ok(())
    }

    #[rstest]
    fn conversion_time_us_should_return_a_relative_value() -> Result<()> {

        let mut configuration = Configuration {
            resolution: Resolution::TwelveBits,
            ..Configuration::default()
        };

        verify_that!(configuration.conversion_time_us(), eq(4167))?;

        configuration.conversion_time = ConversionTime::Offset(1337);

        verify_that!(configuration.conversion_time_us(), eq(5504))?;

        configuration.conversion_time = ConversionTime::Offset(0);

        verify_that!(configuration.conversion_time_us(), eq(4167))?;

        configuration.conversion_time = ConversionTime::Offset(-2167);

        verify_that!(configuration.conversion_time_us(), eq(2000))?;

        configuration.conversion_time = ConversionTime::Offset(-5000);

        verify_that!(configuration.conversion_time_us(), eq(0))?;

        Ok(())
    }
}