fix build errors

boards/recovery/src/data_manager.rs

@@ -1,4 +1,3 @@
-use crate::app::recovery_counter_tick;
 use crate::app::{fire_drogue, fire_main};
 use crate::state_machine::RocketStates;
 use common_arm::{spawn, HydraError};

boards/recovery/src/main.rs

@@ -146,27 +146,21 @@ mod app {
         loop {}
     }
 
-    // handle recovery counter
-    // start a counter
-    #[task(local = [recovery_timer])]
-    fn recovery_counter_tick(cx: recovery_counter_tick::Context) {
-        let timer = cx.local.recovery_timer;
-        // only start timer if it is not already running
-        if timer.wait().is_ok() {
+    // 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?
+            let timer_duration: atsamd_hal::fugit::Duration<u32, 1, 1000000000> = duration_mins.convert();
+            timer.enable_interrupt(); // clear interrupt
             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;
         });
     }
 
@@ -209,7 +203,7 @@ mod app {
 
     /// 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,12 +12,13 @@ use enum_dispatch::enum_dispatch;
 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_timer(&mut self, f: &dyn Fn(&mut TimerCounter2));
+    fn lock_recovery_timer(&mut self, f: &dyn Fn(&mut TimerCounter2));
 }
 
 impl<'a> StateMachineSharedResources for crate::app::__rtic_internal_run_smSharedResources<'a> {
@@ -30,7 +31,7 @@ impl<'a> StateMachineSharedResources for crate::app::__rtic_internal_run_smShare
     fn lock_gpio(&mut self, fun: &dyn Fn(&mut GPIOManager)) {
         self.gpio.lock(fun)
     }
-    fn lock_timer(&mut self, fun: &dyn Fn(&mut TimerCounter2)) {
+    fn lock_recovery_timer(&mut self, fun: &dyn Fn(&mut TimerCounter2)) {
         self.recovery_timer.lock(fun)
     }
 }

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,8 +19,13 @@ impl State for TerminalDescent {
             spawn!(fire_main)?;
             Ok(())
         });
-        context.shared_resources.timer.lock(|timer| {
-            timer.start();
+        // 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> {

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,8 +33,8 @@ impl State for WaitForRecovery {
                 })
             });
         }
-        context.shared_resources.timer.lock(|timer| {
-            timer.disable_interrupts();
+        context.shared_resources.recovery_timer.lock(|timer| {
+            timer.disable_interrupt();
         })
     }
     fn step(&mut self, _context: &mut StateMachineContext) -> Option<RocketStates> {