create recovery timer mechanism

boards/recovery/src/data_manager.rs

@@ -1,10 +1,12 @@
 use crate::app::{fire_drogue, fire_main};
 use crate::state_machine::RocketStates;
+use atsamd_hal::timer::TimerCounter2;
 use common_arm::{spawn, HydraError};
 use defmt::info;
 use heapless::HistoryBuffer;
 use messages::sensor::{Air, EkfNav1, EkfNav2, EkfQuat, GpsVel, Imu1, Imu2, UtcTime};
 use messages::Message;
+use crate::app::recovery_counter_tick;
 
 const MAIN_HEIGHT: f32 = 876.0; // meters ASL
 const HEIGHT_MIN: f32 = 600.0; // meters ASL
@@ -18,6 +20,7 @@
     pub gps_vel: Option<GpsVel>,
     pub historical_barometer_altitude: HistoryBuffer<(f32, u32), 8>,
     pub current_state: Option<RocketStates>,
+    pub recovery_counter: u8,
 }
 
 impl DataManager {
@@ -32,6 +35,7 @@
             gps_vel: None,
             historical_barometer_altitude,
             current_state: None,
+            recovery_counter: 0
         }
     }
     /// Returns true if the rocket is descending
@@ -79,7 +83,7 @@
             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 +103,13 @@
                 match avg_sum / 7.0 {
                     // inclusive range
                     x if (-0.25..=0.25).contains(&x) => {
-                        return true;
+                        if (self.recovery_counter >= 15) {
+                            return true;
+                        }
+                        spawn!(recovery_counter_tick);
                     }
                     _ => {
-                        // continue
+                        self.recovery_counter = 0;
                     }
                 }
             }

boards/recovery/src/main.rs

@@ -49,6 +49,7 @@
         led_green: Pin<PB16, PushPullOutput>,
         led_red: Pin<PB17, PushPullOutput>,
         state_machine: StateMachine,
+        recovery_timer: hal::timer::TimerCounter2,
     }
 
     #[monotonic(binds = SysTick, default = true)]
@@ -78,7 +79,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 +105,12 @@
         /* 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();
@@ -125,6 +132,7 @@
                 led_green,
                 led_red,
                 state_machine,
+                recovery_timer,
             },
             init::Monotonics(mono),
         )
@@ -133,9 +141,31 @@
     /// Idle task for when no other tasks are running.
     #[idle]
     fn idle(_: idle::Context) -> ! {
         loop {}
     }
 
+    // handle recovery counter
+    // start a counter
+    #[task(local = [recovery_timer])]
+    fn recovery_counter_tick(mut cx: recovery_counter_tick::Context) {
+        let timer = cx.local.recovery_timer;
+        // should probably check if timer is already running
+        // to avoid resetting it
+
+        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);
+    }
+
+    // interrupt handler for when counter is finished
+    #[task(binds=TC2, shared=[data_manager])]
+    fn recovery_counter_finish(mut cx: recovery_counter_finish::Context) {
+        cx.shared.data_manager.lock(|data| {
+            data.recovery_counter += 1;
+        });
+    }
+
     #[task(priority = 3, local = [fired: bool = false], shared=[gpio, &em])]
     fn fire_drogue(mut cx: fire_drogue::Context) {
         cx.shared.em.run(|| {