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

/// Configuration parameter to set the resolution used to convert an analogue value.
///
/// **Default:** 12 bits
///
/// # See also
/// [`Configuration`], [`Channel`], [`Gain`], [`ConversionTime`]
///
/// [`Configuration`]: crate::Configuration
/// [`Channel`]: crate::Channel
/// [`Gain`]: crate::Gain
/// [`ConversionTime`]: crate::ConversionTime
///
#[derive(Copy, Clone, Default)]
#[cfg_attr(any(feature = "fmt", test), derive(Debug))]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Resolution {
    /// A resolution of 12 bits results in a sampling rate of 240 samples per second.
    #[default]
    TwelveBits,
    /// A resolution of 14 bits results in a sampling rate of 60 samples per second.
    FourteenBits,
    /// A resolution of 16 bits results in a sampling rate of 15 samples per second.
    SixteenBits,
    /// A resolution of 18 bits results in a sampling rate of 3.75 samples per second.
    EighteenBits,
}

impl Resolution {

    /// Returns the number of bytes required for a sample.
    pub(crate) const fn bytes(&self) -> usize {
        match self {
            Resolution::TwelveBits |
            Resolution::FourteenBits |
            Resolution::SixteenBits => 2,
            Resolution::EighteenBits => 3,
        }
    }

    /// Returns the number of bits used to sample a value.
    pub(crate) const fn bits(&self) -> usize {
        match self {
            Resolution::TwelveBits => 12,
            Resolution::FourteenBits => 14,
            Resolution::SixteenBits => 16,
            Resolution::EighteenBits => 18,
        }
    }

    pub(crate) const fn mask(&self) -> u8 {
        match self {
            Resolution::TwelveBits => 0b00,
            Resolution::FourteenBits => 0b01,
            Resolution::SixteenBits => 0b10,
            Resolution::EighteenBits => 0b11,
        }
    }

    pub(crate) const fn sign_bit(&self) -> u32 {
        match self {
            Resolution::TwelveBits => 0x800,
            Resolution::FourteenBits => 0x2000,
            Resolution::SixteenBits => 0x8000,
            Resolution::EighteenBits => 0x20000,
        }
    }

    pub(crate) const fn sign_extend(&self) -> u32 {
        match self {
            Resolution::TwelveBits => 0xFFFFF000,
            Resolution::FourteenBits => 0xFFFFC000,
            Resolution::SixteenBits => 0xFFFF0000,
            Resolution::EighteenBits => 0xFFFC0000,
        }
    }

    /// Returns the minimum output codes
    pub(crate) const fn min(&self) -> i32 {
        match self {
            Resolution::TwelveBits => -2048,
            Resolution::FourteenBits => -8192,
            Resolution::SixteenBits => -32768,
            Resolution::EighteenBits => -131072,
        }
    }

    /// Returns the maximum output codes
    pub(crate) const fn max(&self) -> i32 {
        match self {
            Resolution::TwelveBits => 2047,
            Resolution::FourteenBits => 8191,
            Resolution::SixteenBits => 32767,
            Resolution::EighteenBits => 131071,
        }
    }

    /// Returns the time required for an A/D conversion in μs.
    pub(crate) const fn conversion_time_us(&self) -> u32 {
        match self {
            Resolution::TwelveBits =>   4167,  // 240 SPS
            Resolution::FourteenBits => 16667, // 60 SPS
            Resolution::SixteenBits =>  66667, // 15 SPS
            Resolution::EighteenBits => 266667 // 3.75 SPS
        }
    }
}