WIP: Timer Update

boards/recovery/src/data_manager.rs

@@ -1,14 +1,16 @@
+use crate::app::recovery_counter_tick;
 use crate::app::{fire_drogue, fire_main};
 use crate::state_machine::RocketStates;
 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
+const RECOVERY_DATA_POINTS: u8 = 8; // number of barometric altitude readings held by the recovery
+                                    // algorithm
 
 pub struct DataManager {
     pub air: Option<Air>,
@@ -35,12 +37,12 @@
             gps_vel: None,
             historical_barometer_altitude,
             current_state: None,
-            recovery_counter: 0
+            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();
@@ -60,7 +62,7 @@
                     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) => {
@@ -106,7 +108,6 @@
                         if self.recovery_counter >= 15 {
                             return true;
                         }
-                        spawn!(recovery_counter_tick);
                     }
                     _ => {
                         self.recovery_counter = 0;

boards/recovery/src/main.rs

@@ -8,23 +8,23 @@
 mod types;
 
 use atsamd_hal as hal;
 use atsamd_hal::clock::v2::pclk::Pclk;
 use atsamd_hal::clock::v2::Source;
 use atsamd_hal::dmac::DmaController;
 use common_arm::hinfo;
 use common_arm::mcan;
 use common_arm::*;
 use communication::Capacities;
 use data_manager::DataManager;
 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};
 use systick_monotonic::*;
 use types::COM_ID;
-use hal::timer::TimerCounter2;
 
 /// Custom panic handler.
 /// Reset the system if a panic occurs.
@@ -43,14 +43,14 @@
         data_manager: DataManager,
         can0: communication::CanDevice0,
         gpio: GPIOManager,
+        recovery_timer: TimerCounter2,
     }
 
     #[local]
     struct Local {
         led_green: Pin<PB16, PushPullOutput>,
         led_red: Pin<PB17, PushPullOutput>,
         state_machine: StateMachine,
-        recovery_timer: TimerCounter2,
     }
 
     #[monotonic(binds = SysTick, default = true)]
@@ -109,7 +109,8 @@
         /* 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);
+        let mut recovery_timer =
+            hal::timer::TimerCounter2::tc2_(&timerclk, peripherals.TC2, &mut mclk);
         recovery_timer.enable_interrupt();
 
         /* Spawn tasks */
@@ -128,12 +129,12 @@
                 data_manager: DataManager::new(),
                 can0,
                 gpio,
+                recovery_timer,
             },
             Local {
                 led_green,
                 led_red,
                 state_machine,
-                recovery_timer,
             },
             init::Monotonics(mono),
         )
@@ -147,14 +148,15 @@
 
     // 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() {
             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();
+            let timer_duration: atsamd_hal::fugit::Duration<u32, 1, 1000000000> =
+                duration_mins.convert();
             timer.enable_interrupt(); // clear interrupt?
             timer.start(timer_duration);
         }

boards/recovery/src/state_machine/mod.rs

@@ -10,16 +10,17 @@
 use defmt::Format;
 use enum_dispatch::enum_dispatch;
 use messages::state;
 use rtic::Mutex;
 pub use states::Initializing;
 
 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));
 }
 
 impl<'a> StateMachineSharedResources for crate::app::__rtic_internal_run_smSharedResources<'a> {
     fn lock_can(&mut self, fun: &dyn Fn(&mut CanDevice0)) {
         self.can0.lock(fun)
     }
@@ -29,10 +30,13 @@
     fn lock_gpio(&mut self, fun: &dyn Fn(&mut GPIOManager)) {
         self.gpio.lock(fun)
     }
+    fn lock_timer(&mut self, fun: &dyn Fn(&mut TimerCounter2)) {
+        self.recovery_timer.lock(fun)
+    }
 }
 
 pub struct StateMachineContext<'a, 'b> {
     pub shared_resources: &'b mut crate::app::__rtic_internal_run_smSharedResources<'a>,
 }
 pub struct StateMachine {
     state: RocketStates,

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

@@ -1,12 +1,12 @@
 use super::Descent;
 use crate::app::fire_main;
 use crate::state_machine::{
     RocketStates, State, StateMachineContext, TransitionInto, WaitForRecovery,
 };
 use crate::{no_transition, transition};
 use common_arm::spawn;
 use defmt::{write, Format, Formatter};
 use rtic::mutex::Mutex;
 
 #[derive(Debug, Clone)]
 pub struct TerminalDescent {}
@@ -17,6 +17,9 @@
             spawn!(fire_main)?;
             Ok(())
         });
+        context.shared_resources.timer.lock(|timer| {
+            timer.start();
+        });
     }
     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

@@ -1,5 +1,5 @@
 use super::TerminalDescent;
 use crate::app::monotonics;
 use crate::no_transition;
 use crate::state_machine::{RocketStates, State, StateMachineContext, TransitionInto};
 use crate::types::COM_ID;
@@ -7,7 +7,7 @@
 use messages::command::{Command, PowerDown, RadioRate, RadioRateChange};
 use messages::sender::Sender::SensorBoard;
 use messages::Message;
 use rtic::mutex::Mutex;
 
 #[derive(Debug, Clone)]
 pub struct WaitForRecovery {}
@@ -32,6 +32,9 @@
                 })
             });
         }
+        context.shared_resources.timer.lock(|timer| {
+            timer.disable_interrupts();
+        })
     }
     fn step(&mut self, _context: &mut StateMachineContext) -> Option<RocketStates> {
         no_transition!() // this is our final resting place. We should also powerdown this board.