tmag5170 0.1.0

A platform agnostic driver to interface with the TMAG5170-Q1 (3D hall 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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178

/// Enable Angle calculation using two axis data
pub enum AngleEn {
    /// No angle calculation (default)
    NoAngle = 0x00,

    /// X-Y-angle calculation enabled
    Xy = 0x01,

    /// Y-Z-angle calculation enabled
    Yz = 0x02,

    /// Z-X-angle calculation enabled
    Zx = 0x03,
}

/// Selects the time spent in low power mode between conversions
/// when OPERATING_MODE =010b (OperatingMode::Active)
pub enum SleepTime {
    /// 1ms
    Ms1 = 0x00,

    /// 5ms
    Ms5 = 0x01,

    /// 10ms
    Ms10 = 0x02,

    /// 15ms
    Ms15 = 0x03,

    /// 20ms
    Ms20 = 0x04,

    /// 30ms
    Ms30 = 0x05,

    /// 50ms
    Ms50 = 0x06,

    /// 100ms
    Ms100 = 0x07,

    /// 500ms
    Ms500 = 0x08,

    /// 1000ms
    Ms1000 = 0x09,
}

/// Enables data acquisition of the magnetic axis channel(s)
#[allow(non_camel_case_types)]
pub enum MagChEn {
    /// All magnetic channels of OFF
    Off = 0x00,

    /// X channel enabled
    X = 0x01,

    /// Y channel enabled
    Y = 0x02,

    /// XY channel enabled
    Xy = 0x03,

    /// Z channel enabled
    Z = 0x04,

    /// ZX channel enabled
    Zx = 0x05,

    /// YZ channel enabled
    Yz = 0x06,

    /// XYZ channel enabled
    Xyz = 0x07,

    /// XYX channel enabled
    Xyx = 0x08,

    /// YXY channel enabled
    Yxy = 0x09,

    /// YZY channel enabled
    Yzy = 0x0a,

    /// ZYZ channel enabled
    Zyz = 0x0b,

    /// ZXZ channel enabled
    Zxz = 0x0c,

    /// XZX channel enabled
    Xzx = 0x0d,

    /// XYZYX channel enabled
    Xyzyx = 0x0e,

    /// XYZZYX channel enabled
    Xyzzyx = 0x0f,
}

/// Enables different magnetic ranges
#[allow(non_camel_case_types)]
pub enum Range {
    /// ±50mT (TMAG5170A1) / ±200mT(TMAG5170A2)
    A1_50mT_A2_200mT = 0x00,

    /// ±25mT (TMAG5170A1) / ±133mT(TMAG5170A2)
    A1_25mT_A2_133mT = 0x01,

    /// ±100mT (TMAG5170A1) / ±300mT(TMAG5170A2)
    A1_100mT_A2_300mT = 0x02,
}

/// Configure Device Operation Modes - SENSOR_CONFIG
pub struct SensorConfig {
    config: u16,
}

impl SensorConfig {
    /// Creates default config
    pub fn new() -> Self {
        let config = 0x00;
        SensorConfig { config }
    }

    /// Creates config from u16 value
    pub fn form_u16(config: u16) -> Self {
        SensorConfig { config }
    }

    /// Convert config to u16 value
    pub fn to_u16(&self) -> u16 {
        self.config
    }

    /// Set AngleEn field
    pub fn set_angle_en(mut self, angle_en: AngleEn) -> Self {
        self.config = self.config & !(0b11 << 14) | ((angle_en as u16) << 14);
        self
    }

    /// Set SleepTime field
    pub fn set_sleep_time(mut self, sleep_time: SleepTime) -> Self {
        self.config = self.config & !(0b1111 << 10) | ((sleep_time as u16) << 10);
        self
    }

    /// Set AngleEn field
    pub fn set_mag_ch_en(mut self, mag_ch_en: MagChEn) -> Self {
        self.config = self.config & !(0b1111 << 6) | ((mag_ch_en as u16) << 6);
        self
    }

    /// Set Z Range field
    pub fn set_z_range(mut self, z_range: Range) -> Self {
        self.config = self.config & !(0b11 << 4) | ((z_range as u16) << 4);
        self
    }

    /// Set Y Range field
    pub fn set_y_range(mut self, y_range: Range) -> Self {
        self.config = self.config & !(0b11 << 2) | ((y_range as u16) << 2);
        self
    }

    /// Set X Range field
    pub fn set_x_range(mut self, x_range: Range) -> Self {
        self.config = self.config & !(0b11) | (x_range as u16);
        self
    }
}

impl Default for SensorConfig {
    fn default() -> Self {
        SensorConfig::new()
    }
}