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 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366
pub const MMA845X_BASE_ADDR: u8 = 0x1C; /// All possible errors in this crate #[derive(Debug)] pub enum Error<E> { /// I²C bus error I2C(E), } /// All possible errors in this crate #[derive(Debug)] pub struct ModeChangeError<E, DEV> { /// I²C bus error pub error: Error<E>, /// Original device without mode changed pub dev: DEV, } /// IC markers pub mod ic { /// MMA8451 IC marker pub struct Mma8451; /// MMA8452 IC marker pub struct Mma8452; /// MMA8453 IC marker pub struct Mma8453; /// MMA8652 IC marker pub struct Mma8652; /// MMA8653 IC marker pub struct Mma8653; } /// Mode markers pub mod mode { /// Standby mode pub struct Standby; /// Active mode pub struct Active; } /// Unscaled acceleration measurement #[derive(Debug, Default, Clone, PartialEq)] pub struct UnscaledMeasurement { /// X-axis acceleration. pub x: i16, /// Y-axis acceleration. pub y: i16, /// Z-axis acceleration. pub z: i16, } /// Acceleration measurement scaled to configured G range #[derive(Debug, Default, Clone)] pub struct Measurement { /// X-axis acceleration. pub x: f32, /// Y-axis acceleration. pub y: f32, /// Z-axis acceleration. pub z: f32, } /// G scale #[derive(Debug, Clone, Copy, PartialEq)] pub enum GScale { /// Range: +/-2g G2, /// Range: +/-4g G4, /// Range: +/-8g G8, } /// Read mode #[derive(Debug, Clone, Copy, PartialEq)] pub enum ReadMode { /// Normal read mode (default) Normal, /// Fast read mode Fast, } /// Output data rate #[derive(Debug, Clone, Copy, PartialEq)] pub enum OutputDataRate { /// 800 Hz (default) Hz800, /// 400 Hz Hz400, /// 200 Hz Hz200, /// 100 Hz Hz100, /// 50 Hz Hz50, /// 12.5 Hz Hz12_5, /// 6.25 Hz Hz6_25, /// 1.56 Hz Hz1_56, } /// Sampling rate used in auto-sleep/wake mode #[derive(Debug, Clone, Copy, PartialEq)] pub enum AutoSleepDataRate { /// 50 Hz (default) Hz50, /// 12.5 Hz Hz12_5, /// 6.25 Hz Hz6_25, /// 1.56 Hz Hz1_56, } /// Power mode #[derive(Debug, Clone, Copy, PartialEq)] pub enum PowerMode { /// Normal (default) Normal, /// Low noise low power LowNoiseLowPower, /// High resolution HighResolution, ///Low power LowPower, } /// Current system mode #[derive(Debug, Clone, Copy, PartialEq)] pub enum SystemMode { /// Standby mode Standby, /// Wake mode Wake, /// Sleep mode Sleep, } /// Current data status #[derive(Debug, Default, Clone, Copy, PartialEq)] pub struct DataStatus { /// X,Y,Z-axis data overwrite pub xyz_overwrite: bool, /// X-axis data overwrite pub x_overwrite: bool, /// Y-axis data overwrite pub y_overwrite: bool, /// Z-axis data overwrite pub z_overwrite: bool, /// X,Y,Z-axis new data ready pub xyz_new_data: bool, /// X-axis data overwrite pub x_new_data: bool, /// Y-axis data overwrite pub y_new_data: bool, /// Z-axis data overwrite pub z_new_data: bool, } /// Portrait/landscape debounce counter mode #[derive(Debug, Clone, Copy, PartialEq)] pub enum DebounceCounterMode { /// Decrements debounce whenever the condition of interest is no longer valid. Decrement, /// Clears the counter whenever the condition of interest is no longer valid. (default) Clear, } /// Current portrait/landscape status #[derive(Debug, Default, Clone, Copy, PartialEq)] pub struct PortraitLandscapeStatus { /// True if any of the other fields changed pub something_changed: bool, /// Z-tilt angle lookout detected pub z_tilt_angle_lookout: bool, /// Portrait/Landscape orientation pub portrait_landscape: PortraitLandscapeOrientation, /// Front/Back orientation pub front_back: FrontBackOrientation, } /// Portrait/Landscape orientation #[derive(Debug, Clone, Copy, PartialEq)] pub enum PortraitLandscapeOrientation { /// Equipment is standing vertically in the normal orientation (default) PortraitUp, /// Equipment is standing vertically in the inverted orientation PortraitDown, /// Equipment is standing in landscape mode to the right LandscapeRight, /// Equipment is standing in landscape mode to the left LandscapeLeft, } impl Default for PortraitLandscapeOrientation { fn default() -> Self { PortraitLandscapeOrientation::PortraitUp } } /// Front/Back orientation #[derive(Debug, Clone, Copy, PartialEq)] pub enum FrontBackOrientation { /// Equipment is in front-facing orientation (default) Front, /// Equipment is in back-facing orientation Back, } impl Default for FrontBackOrientation { fn default() -> Self { FrontBackOrientation::Front } } /// Current interrupt status #[derive(Debug, Default, Clone, Copy, PartialEq)] pub struct InterruptStatus { /// Auto-sleep/wake interrupt occurred pub auto_sleep: bool, /// FIFO interrupt occurred pub fifo: bool, /// Acceleration transient value greater than user specified threshold has occurred pub transient: bool, /// Portrait/landscape orientation interrupt occurred pub portrait_landscape: bool, /// Single and/or double pulse interrupt occurred pub pulse: bool, /// Freefall/motion interrupt occurred pub freefall_motion: bool, /// New data ready and/or data overrun interrupt occurred pub data_ready: bool, } /// Interrupt source enable/disable /// /// Unavailable interrupt sources on a device are ignored. #[derive(Debug, Default, Clone, Copy, PartialEq)] pub struct EnabledInterrupts { /// Auto-sleep/wake interrupt enabled pub auto_sleep: bool, /// FIFO interrupt enabled pub fifo: bool, /// Acceleration transient interrupt enabled pub transient: bool, /// Portrait/landscape orientation interrupt enabled pub portrait_landscape: bool, /// Single and/or double pulse detection interrupt enabled pub pulse: bool, /// Freefall/motion interrupt enabled pub freefall_motion: bool, /// Data ready interrupt enabled pub data_ready: bool, } /// Physical interrupt pin polarity #[derive(Debug, Clone, Copy, PartialEq)] pub enum InterruptPinPolarity { /// Low state when active (default) ActiveLow, /// High state when active ActiveHigh, } /// Physical interrupt pin configuration #[derive(Debug, Clone, Copy, PartialEq)] pub enum InterruptPinConfiguration { /// Push-pull configuration (default) PushPull, /// Open drain configuration OpenDrain, } /// Interrupt source pin route #[derive(Debug, Clone, Copy, PartialEq)] pub enum InterruptSourcePinRoute { /// Source is routed to pin INT1 Int1, /// Source is routed to pin INT2 (default) Int2, } impl Default for InterruptSourcePinRoute { fn default() -> Self { InterruptSourcePinRoute::Int2 } } /// Interrupt source pin route /// /// Unavailable interrupt sources on a device are ignored. #[derive(Debug, Default, Clone, Copy, PartialEq)] pub struct InterruptPinRoutes { /// Auto-sleep/wake interrupt pin route (INT1/INT2) pub auto_sleep: InterruptSourcePinRoute, /// FIFO interrupt pin route (INT1/INT2) pub fifo: InterruptSourcePinRoute, /// Acceleration transient interrupt pin route (INT1/INT2) pub transient: InterruptSourcePinRoute, /// Portrait/landscape orientation interrupt pin route (INT1/INT2) pub portrait_landscape: InterruptSourcePinRoute, /// Single and/or double pulse detection interrupt pin route (INT1/INT2) pub pulse: InterruptSourcePinRoute, /// Freefall/motion interrupt pin route (INT1/INT2) pub freefall_motion: InterruptSourcePinRoute, /// Data ready interrupt pin route (INT1/INT2) pub data_ready: InterruptSourcePinRoute, } /// Interrupts that wake the device from sleep #[derive(Debug, Default, Clone, Copy, PartialEq)] pub struct WakeInterrupts { /// Acceleration transient interrupt pub transient: bool, /// Portrait/landscape orientation interrupt pub portrait_landscape: bool, /// Single and/or double pulse detection interrupt pub pulse: bool, /// Freefall/motion interrupt pub freefall_motion: bool, } /// Possible slave addresses #[derive(Debug, Clone, Copy)] pub enum SlaveAddr { /// Default slave address Default, /// Alternative slave address providing bit value for A0 Alternative(bool), } impl Default for SlaveAddr { /// Default slave address fn default() -> Self { SlaveAddr::Default } } impl SlaveAddr { pub(crate) fn addr(self, default: u8) -> u8 { match self { SlaveAddr::Default => default, SlaveAddr::Alternative(a0) => default | a0 as u8, } } } #[cfg(test)] mod tests { use super::MMA845X_BASE_ADDR as BASE_ADDR; use super::*; #[test] fn can_get_default_address() { let addr = SlaveAddr::default(); assert_eq!(BASE_ADDR, addr.addr(BASE_ADDR)); } #[test] fn can_generate_alternative_addresses() { assert_eq!(BASE_ADDR, SlaveAddr::Alternative(false).addr(BASE_ADDR)); assert_eq!(BASE_ADDR | 1, SlaveAddr::Alternative(true).addr(BASE_ADDR)); } }