My solution

  1. #![deny(unsafe_code)]
  2. #![no_main]
  3. #![no_std]
  5. #[allow(unused_imports)]
  6. use aux16::{entry, iprint, iprintln, prelude::*, I16x3, Sensitivity};
  7. use m::Float;
  9. #[entry]
  10. fn main() -> ! {
  11.     const SENSITIVITY: f32 = 12. / (1 << 14) as f32;
  12.     const THRESHOLD: f32 = 0.5;
  14.     let (mut lsm303dlhc, mut delay, mono_timer, mut itm) = aux16::init();
  16.     lsm303dlhc.set_accel_sensitivity(Sensitivity::G12).unwrap();
  18.     let measurement_time = mono_timer.frequency().0; // 1 second in ticks
  19.     let mut instant = None;
  20.     let mut max_g = 0.;
  21.     loop {
  22.         let g_x = f32::from(lsm303dlhc.accel().unwrap().x).abs() * SENSITIVITY;
  24.         match instant {
  25.             None => {
  26.                 // If acceleration goes above a threshold, we start measuring
  27.                 if g_x > THRESHOLD {
  28.                     iprintln!(&mut itm.stim[0], "START!");
  30.                     max_g = g_x;
  31.                     instant = Some(mono_timer.now());
  32.                 }
  33.             }
  34.             // Still measuring
  35.             Some(ref instant) if instant.elapsed() < measurement_time => {
  36.                 if g_x > max_g {
  37.                     max_g = g_x;
  38.                 }
  39.             }
  40.             _ => {
  41.                 // Report max value
  42.                 iprintln!(&mut itm.stim[0], "Max acceleration: {}g", max_g);
  44.                 // Measurement done
  45.                 instant = None;
  47.                 // Reset
  48.                 max_g = 0.;
  49.             }
  50.         }
  52.         delay.delay_ms(50_u8);
  53.     }
  54. }