Implements Acclerometer trait

Author: rubberduck203

Cargo.toml

@@ -9,7 +9,7 @@ documentation = "https://docs.rs/crate/stm32f3-discovery"
 categories = ["embedded", "hardware-support", "no-std"]
 keywords = ["discovery", "stm32f3", "bsp", "arm"]
 license = "MIT OR Apache-2.0"
-version = "0.7.1"
+version = "0.7.2"
 exclude = [
     ".vscode/*",
 ]

README.md

@@ -61,6 +61,10 @@ dual licensed as above, without any additional terms or conditions.
 
 ## Changelog
 
+### 0.7.2
+
+Implements the [Accelerometer trait](https://docs.rs/accelerometer/latest/accelerometer/trait.Accelerometer.html) from the [Accelerometer crate](https://crates.io/crates/accelerometer).
+
 ### 0.7.1
 
 - Implements an `Iterator` for the `Leds` struct and introduced the [Leds::iter_mut()](https://docs.rs/stm32f3-discovery/0.7.1/stm32f3_discovery/leds/struct.Leds.html#method.iter_mut) method.

examples/compass.rs

@@ -7,7 +7,7 @@ use cortex_m::iprintln;
 use cortex_m::peripheral::syst::SystClkSource;
 use cortex_m_rt::{entry, exception};
 
-use stm32f3_discovery::accelerometer::RawAccelerometer;
+use accelerometer::{Accelerometer, RawAccelerometer};
 use stm32f3_discovery::compass::Compass;
 use stm32f3_discovery::stm32f3xx_hal::prelude::*;
 use stm32f3_discovery::stm32f3xx_hal::pac;
@@ -49,8 +49,13 @@ fn main() -> ! {
 
     loop {
         let accel = compass.accel_raw().unwrap();
+        iprintln!(stim, "RawAccel:{:?}", accel);
+
+        let normalized_accel = compass.accel_norm().unwrap();
+        iprintln!(stim, "G-Force:{:?}", normalized_accel);
+
         let mag = compass.mag_raw().unwrap();
-        iprintln!(stim, "Accel:{:?}; Mag:{:?}", accel, mag);
+        iprintln!(stim, "RawMag:{:?}", mag);
 
         wait_for_interrupt();
     }

src/compass.rs

@@ -1,5 +1,5 @@
-use accelerometer::vector::I16x3;
-use accelerometer::RawAccelerometer;
+use accelerometer::vector::{F32x3, I16x3};
+use accelerometer::{Accelerometer, RawAccelerometer};
 use stm32f3xx_hal::gpio;
 use stm32f3xx_hal::gpio::{gpiob, OpenDrain};
 use stm32f3xx_hal::i2c;
@@ -67,3 +67,59 @@ impl RawAccelerometer<I16x3> for Compass {
         Ok(I16x3::new(reading.x, reading.y, reading.z))
     }
 }
+
+/// Reads Accelerometer data in G-Force
+/// 
+/// # Warning
+/// This is hard coded for the default settings because the driver doesn't provide a way
+/// to read the necessary registers to calculate it based on current settings.
+/// If you take control of the underlying device driver and change settings,
+/// this will not calculate the correct G-Force values.
+impl Accelerometer for Compass {
+    type Error = i2c::Error;
+    fn accel_norm(&mut self) -> Result<F32x3, accelerometer::Error<Self::Error>> { 
+        let reading = self.accel_raw()?;
+        /*
+         * LA_FS (linear acceleration measurment range [full scale])
+         *  can be +/-2, +/-4, +/-8, or +/- 16 
+         * LA_So (Linear acceleration sensitivity) can be 1,2,4, or 12
+         *  and is measured in milli-G / LSB
+         * The driver provides a way to set the range/sensitivy,
+         * but no way to read it, so we just hard code the default settings here (for now?).
+         *
+         * At +/-2g, we get 1mg/LSB (1 mg/bit) resolution.
+         * The device returns a 16 bit result.
+         * magnitude g / (1 mg / bit) = 
+         * +/- 2g range = 4g magnitude
+         * 4g / 65535 bits = 4g/(1<<16) = 0.000061 g / bit
+         * 2g / 32768 bits = 2g/(1<<15) = 0.000061 g / bit
+         * 
+         * I _think_ the general equation is:
+         * scale_factor = magnitude / #of_bits * sensitivity
+         * scale_factor = (abs(range)*2) / #of_bits * sensitivity
+         * scale_factor = abs(range) / (#of_bits/2) * sensitivity
+         * sf(+/-2g)  =  4g / 65535 bits *  1mg/LSB = 0.000061 g
+         * sf(+/-4g)  =  8g / 65535 bits *  2mg/LSB = 0.000244 g
+         * sf(+/-8g)  = 16g / 65535 bits *  4mg/LSB = 0.000976 g
+         * sf(+/-16g) = 32g / 65535 bits * 12mg/LSB = 0.005859 g
+         *
+         * NOTE: This also does not account for temperature variance.
+         */
+        const MAGNITUDE: i32 = 4;
+        const NO_OF_BITS: i32 = 1 << 16;
+        const SENSITIVITY: i32 = 1;
+        const SCALE_FACTOR: f32 = (MAGNITUDE as f32 / NO_OF_BITS as f32) * SENSITIVITY as f32;
+        Ok(F32x3::new (
+            reading.x as f32 * SCALE_FACTOR,
+            reading.y as f32 * SCALE_FACTOR,
+            reading.z as f32 * SCALE_FACTOR,
+        ))
+    }
+
+    fn sample_rate(&mut self) -> Result<f32, accelerometer::Error<<Self as Accelerometer>::Error>> { 
+        // we don't expose a way to change this, so hard coded to 400Hz right now
+        // it should really be read from the device in case someone snags the raw lsm303dlhc struct,
+        // but the driver does't give us a way to read it back from the device
+        Ok(400.0)
+    }
+}