create recovery timer mechanism

boards/recovery/src/data_manager.rs

@@ -8,6 +8,8 @@ use messages::Message;
 
 const MAIN_HEIGHT: f32 = 876.0; // meters ASL
 const HEIGHT_MIN: f32 = 600.0; // meters ASL
+const RECOVERY_DATA_POINTS: u8 = 8; // number of barometric altitude readings held by the recovery
+                                    // algorithm
 
 pub struct DataManager {
     pub air: Option<Air>,
@@ -18,6 +20,8 @@ pub struct DataManager {
     pub gps_vel: Option<GpsVel>,
     pub historical_barometer_altitude: HistoryBuffer<(f32, u32), 8>,
     pub current_state: Option<RocketStates>,
+    // each tick represents a minute that passed
+    pub recovery_counter: u8,
 }
 
 impl DataManager {
@@ -32,11 +36,12 @@ impl DataManager {
             gps_vel: None,
             historical_barometer_altitude,
             current_state: None,
+            recovery_counter: 0,
         }
     }
     /// Returns true if the rocket is descending
     pub fn is_falling(&self) -> bool {
-        if self.historical_barometer_altitude.len() < 8 {
+        if (self.historical_barometer_altitude.len() as u8) < RECOVERY_DATA_POINTS {
             return false;
         }
         let mut buf = self.historical_barometer_altitude.oldest_ordered();
@@ -56,7 +61,7 @@ impl DataManager {
                     avg_sum += slope;
                     prev = i;
                 }
-                match avg_sum / 7.0 {
+                match avg_sum / (RECOVERY_DATA_POINTS as f32 - 1.0) {
                     // 7 because we have 8 points.
                     // exclusive range
                     x if !(-100.0..=-5.0).contains(&x) => {
@@ -79,7 +84,7 @@ impl DataManager {
             None => false,
         }
     }
-    pub fn is_landed(&self) -> bool {
+    pub fn is_landed(&mut self) -> bool {
         if self.historical_barometer_altitude.len() < 8 {
             return false;
         }
@@ -99,10 +104,12 @@ impl DataManager {
                 match avg_sum / 7.0 {
                     // inclusive range
                     x if (-0.25..=0.25).contains(&x) => {
-                        return true;
+                        if self.recovery_counter >= 15 {
+                            return true;
+                        }
                     }
                     _ => {
-                        // continue
+                        self.recovery_counter = 0;
                     }
                 }
             }

boards/recovery/src/main.rs

@@ -19,6 +19,7 @@
 use gpio_manager::GPIOManager;
 use hal::gpio::{Pin, Pins, PushPullOutput, PB16, PB17};
 use hal::prelude::*;
+use hal::timer::TimerCounter2;
 use mcan::messageram::SharedMemory;
 use messages::*;
 use state_machine::{StateMachine, StateMachineContext};
@@ -42,6 +43,7 @@
         data_manager: DataManager,
         can0: communication::CanDevice0,
         gpio: GPIOManager,
+        recovery_timer: TimerCounter2,
     }
 
     #[local]
@@ -78,7 +80,7 @@
 
         // SAFETY: Misusing the PAC API can break the system.
         // This is safe because we only steal the MCLK.
-        let (_, _, _, _mclk) = unsafe { clocks.pac.steal() };
+        let (_, _, _, mut mclk) = unsafe { clocks.pac.steal() };
 
         /* CAN config */
         let (pclk_can, gclk0) = Pclk::enable(tokens.pclks.can0, gclk0);
@@ -104,6 +106,13 @@
         /* State Machine config */
         let state_machine = StateMachine::new();
 
+        /* Recovery Timer config */
+        let (pclk_tc2tc3, gclk0) = Pclk::enable(tokens.pclks.tc2_tc3, gclk0);
+        let timerclk: hal::clock::v1::Tc2Tc3Clock = pclk_tc2tc3.into();
+        let mut recovery_timer =
+            hal::timer::TimerCounter2::tc2_(&timerclk, peripherals.TC2, &mut mclk);
+        recovery_timer.enable_interrupt();
+
         /* Spawn tasks */
         run_sm::spawn().ok();
         state_send::spawn().ok();
@@ -120,6 +129,7 @@
                 data_manager: DataManager::new(),
                 can0,
                 gpio,
+                recovery_timer,
             },
             Local {
                 led_green,
@@ -133,9 +143,27 @@
     /// Idle task for when no other tasks are running.
     #[idle]
     fn idle(_: idle::Context) -> ! {
         loop {}
     }
 
+    // interrupt handler for recovery counter
+    #[task(binds=TC2, shared=[data_manager, recovery_timer])]
+    fn recovery_counter_tick(mut cx: recovery_counter_tick::Context) {
+        cx.shared.recovery_timer.lock(|timer| {
+            if timer.wait().is_ok() {
+                cx.shared.data_manager.lock(|data| {
+                    data.recovery_counter += 1;
+                });
+            }
+            // restart timer after interrupt
+            let duration_mins = atsamd_hal::fugit::MinutesDurationU32::minutes(1);
+            // timer requires specific duration format
+            let timer_duration: atsamd_hal::fugit::Duration<u32, 1, 1000000000> = duration_mins.convert();
+            timer.enable_interrupt(); // clear interrupt
+            timer.start(timer_duration);
+        });
+    }
+
     #[task(priority = 3, local = [fired: bool = false], shared=[gpio, &em])]
     fn fire_drogue(mut cx: fire_drogue::Context) {
         cx.shared.em.run(|| {
@@ -175,7 +203,7 @@
 
     /// Runs the state machine.
     /// This takes control of the shared resources.
-    #[task(priority = 3, local = [state_machine], shared = [can0, gpio, data_manager, &em])]
+    #[task(priority = 3, local = [state_machine], shared = [can0, gpio, data_manager, &em, recovery_timer])]
     fn run_sm(mut cx: run_sm::Context) {
         cx.local.state_machine.run(&mut StateMachineContext {
             shared_resources: &mut cx.shared,

boards/recovery/src/state_machine/mod.rs

@@ -12,11 +12,13 @@
 use messages::state;
 use rtic::Mutex;
 pub use states::Initializing;
+use atsamd_hal::timer::TimerCounter2;
 
 pub trait StateMachineSharedResources {
     fn lock_can(&mut self, f: &dyn Fn(&mut CanDevice0));
     fn lock_data_manager(&mut self, f: &dyn Fn(&mut DataManager));
     fn lock_gpio(&mut self, f: &dyn Fn(&mut GPIOManager));
+    fn lock_recovery_timer(&mut self, f: &dyn Fn(&mut TimerCounter2));
 }
 
 impl<'a> StateMachineSharedResources for crate::app::__rtic_internal_run_smSharedResources<'a> {
@@ -29,6 +31,9 @@
     fn lock_gpio(&mut self, fun: &dyn Fn(&mut GPIOManager)) {
         self.gpio.lock(fun)
     }
+    fn lock_recovery_timer(&mut self, fun: &dyn Fn(&mut TimerCounter2)) {
+        self.recovery_timer.lock(fun)
+    }
 }
 
 pub struct StateMachineContext<'a, 'b> {
@@ -69,7 +74,7 @@
 
 // All events are found here
 pub enum RocketEvents {
     DeployDrogue,
     DeployMain,
 }
 
@@ -103,7 +108,7 @@
     }
 }
 // Linter: an implementation of From is preferred since it gives you Into<_> for free where the reverse isn't true
 impl Into<state::StateData> for RocketStates {
     fn into(self) -> state::StateData {
         match self {
             RocketStates::Initializing(_) => state::StateData::Initializing,

boards/recovery/src/state_machine/states/terminal_descent.rs

@@ -1,12 +1,14 @@
 use super::Descent;
 use crate::app::fire_main;
 use crate::state_machine::{
-    RocketStates, State, StateMachineContext, TransitionInto, WaitForRecovery,
+    RocketStates, State, StateMachineContext, StateMachineSharedResources, TransitionInto, WaitForRecovery
 };
 use crate::{no_transition, transition};
+use atsamd_hal::timer_traits::InterruptDrivenTimer;
 use common_arm::spawn;
 use defmt::{write, Format, Formatter};
 use rtic::mutex::Mutex;
+use atsamd_hal::prelude::_embedded_hal_timer_CountDown;
 
 #[derive(Debug, Clone)]
 pub struct TerminalDescent {}
@@ -17,6 +19,14 @@
             spawn!(fire_main)?;
             Ok(())
         });
+        // context.shared_resources.
+        context.shared_resources.recovery_timer.lock(|timer| {
+            timer.enable_interrupt();
+            let duration_mins = atsamd_hal::fugit::MinutesDurationU32::minutes(1);
+            // timer requires specific duration format
+            let timer_duration: atsamd_hal::fugit::Duration<u32, 1, 1000000000> = duration_mins.convert();
+            timer.start(timer_duration);
+        });
     }
     fn step(&mut self, context: &mut StateMachineContext) -> Option<RocketStates> {
         context.shared_resources.data_manager.lock(|data| {

boards/recovery/src/state_machine/states/wait_for_recovery.rs

@@ -8,6 +8,7 @@ use messages::command::{Command, PowerDown, RadioRate, RadioRateChange};
 use messages::sender::Sender::SensorBoard;
 use messages::Message;
 use rtic::mutex::Mutex;
+use atsamd_hal::prelude::_atsamd_hal_timer_traits_InterruptDrivenTimer;
 
 #[derive(Debug, Clone)]
 pub struct WaitForRecovery {}
@@ -32,6 +33,9 @@ impl State for WaitForRecovery {
                 })
             });
         }
+        context.shared_resources.recovery_timer.lock(|timer| {
+            timer.disable_interrupt();
+        })
     }
     fn step(&mut self, _context: &mut StateMachineContext) -> Option<RocketStates> {
         no_transition!() // this is our final resting place. We should also powerdown this board.