State Machine Implementation (#16)

* Initial orchestrator implementation

* Migrate argus to use a bin + lib architecture, move SM to corresponding file

* Added more tests

* Moved SM to shared resources

* Add last state guard and infinite orchestrator loop

* Added tasks

* Removed redundant states

Author: BLM16

boards/argus/Cargo.toml

@@ -3,6 +3,10 @@ name = "argus"
 version = "0.1.0"
 edition = "2021"
 
+[lib]
+name = "argus"
+path = "src/lib.rs"
+
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]

boards/argus/src/lib.rs

@@ -0,0 +1,9 @@
+#![no_std]
+
+pub mod adc_manager;
+pub mod can_manager;
+pub mod data_manager;
+pub mod state_machine;
+pub mod time_manager;
+pub mod traits;
+pub mod types;

boards/argus/src/main.rs

@@ -6,13 +6,7 @@ compile_error!(
     "You must enable exactly one of the features: 'pressure', 'temperature', or 'strain'."
 );
 
-// mod state_machine;
-pub mod adc_manager;
-mod can_manager;
-mod data_manager;
-mod time_manager;
-mod traits;
-mod types;
+use argus::*;
 
 use adc_manager::AdcManager;
 use chrono::NaiveDate;
@@ -24,7 +18,7 @@ use messages::CanMessage;
 use panic_probe as _;
 use rtic_monotonics::systick::prelude::*;
 use rtic_sync::{channel::*, make_channel};
-use smlang::statemachine;
+use state_machine as sm;
 use stm32h7xx_hal::gpio::gpioa::{PA2, PA3};
 use stm32h7xx_hal::gpio::PA4;
 use stm32h7xx_hal::gpio::{Edge, ExtiPin, Pin};
@@ -41,18 +35,6 @@ const DATA_CHANNEL_CAPACITY: usize = 10;
 
 systick_monotonic!(Mono, 500);
 
-statemachine! {
-    transitions: {
-        *Init + Start = Idle,
-        Idle | Recovery + WantsCollection = Collection,
-        Idle + NoConfig = Calibration,
-        Collection + WantsProcessing = Processing,
-        Calibration + Configured = Idle,
-        Fault + FaultCleared = Idle,
-        _ + FaultDetected = Fault,
-    }
-}
-
 #[inline(never)]
 #[defmt::panic_handler]
 fn panic() -> ! {
@@ -80,11 +62,11 @@ mod app {
         rtc: rtc::Rtc,
         adc_manager: AdcManager<Pin<ADC2_RST_PIN_PORT, ADC2_RST_PIN_ID, Output<PushPull>>>,
         time_manager: TimeManager,
+        state_machine: sm::StateMachine<traits::Context>,
     }
 
     #[local]
     struct LocalResources {
-        state_machine: StateMachine<traits::Context>,
         can_sender: Sender<'static, CanMessage, DATA_CHANNEL_CAPACITY>,
         led_red: PA2<Output<PushPull>>,
         led_green: PA3<Output<PushPull>>,
@@ -259,12 +241,13 @@ mod app {
         let mut data_manager = DataManager::new();
         data_manager.set_reset_reason(reset);
         let em = ErrorManager::new();
-        let state_machine = StateMachine::new(traits::Context {});
+        let state_machine = sm::StateMachine::new(traits::Context {});
 
         blink::spawn().ok();
         // send_data_internal::spawn(can_receiver).ok();
         reset_reason_send::spawn().ok();
         state_send::spawn().ok();
+        sm_orchestrate::spawn().ok();
         info!("Online");
 
         (
@@ -277,18 +260,66 @@ mod app {
                 rtc,
                 adc_manager,
                 time_manager,
+                state_machine,
             },
             LocalResources {
                 adc1_int,
                 adc2_int,
                 can_sender,
                 led_red,
                 led_green,
-                state_machine,
             },
         )
     }
 
+    /// The state machine orchestrator.
+    /// Handles the current state of the ARGUS system.
+    #[task(priority = 2, shared = [&state_machine])]
+    async fn sm_orchestrate(cx: sm_orchestrate::Context) {
+        let mut last_state = cx.shared.state_machine.state();
+        loop {
+            let state = cx.shared.state_machine.state();
+            if state != last_state {
+                _ = match state {
+                    sm::States::Calibration => spawn!(sm_calibrate),
+                    sm::States::Collection => spawn!(sm_collect),
+                    sm::States::Fault => spawn!(sm_fault),
+                    sm::States::Idle => spawn!(sm_idle),
+                    sm::States::Init => spawn!(sm_init),
+                };
+                
+                last_state = state;
+            }
+
+            Mono::delay(100.millis()).await;
+        }
+    }
+
+    #[task(priority = 3)]
+    async fn sm_calibrate(cx: sm_calibrate::Context) {
+        todo!()
+    }
+
+    #[task(priority = 3)]
+    async fn sm_collect(cx: sm_collect::Context) {
+        todo!()
+    }
+
+    #[task(priority = 3)]
+    async fn sm_fault(cx: sm_fault::Context) {
+        todo!()
+    }
+
+    #[task(priority = 3)]
+    async fn sm_idle(cx: sm_idle::Context) {
+        todo!()
+    }
+
+    #[task(priority = 3)]
+    async fn sm_init(cx: sm_init::Context) {
+        todo!()
+    }
+
     #[task(priority = 3, binds = EXTI15_10, shared = [adc_manager], local = [adc1_int])]
     fn adc1_data_ready(mut cx: adc1_data_ready::Context) {
         info!("new data available come through");

boards/argus/src/state_machine.rs

@@ -0,0 +1,67 @@
+use smlang::statemachine;
+
+statemachine! {
+    transitions: {
+        *Init + Start = Idle,
+        Idle + WantsCollection = Collection,
+        Idle + NoConfig = Calibration,
+        Calibration + Configured = Idle,
+        Fault + FaultCleared = Idle,
+        _ + FaultDetected = Fault,
+    }
+}
+
+#[cfg(test)]
+pub mod tests {
+    use super::*;
+    use crate::traits;
+
+    #[test]
+    pub fn sm_should_transition_between_states_on_event() {
+        let mut sm = StateMachine::new(traits::Context {});
+    
+        // Should be in init by default
+        assert!(*sm.state() == States::Init);
+    
+        // Should transition to idle on start
+        _ = sm.process_event(Events::Start).unwrap();
+        assert!(*sm.state() == States::Idle);
+    
+        // Should transition to calibration when there is no config
+        _ = sm.process_event(Events::NoConfig).unwrap();
+        assert!(*sm.state() == States::Calibration);
+    
+        // Should transition back to idle when configured
+        _ = sm.process_event(Events::Configured).unwrap();
+        assert!(*sm.state() == States::Idle);
+    
+        // Should transition to collection when asked
+        _ = sm.process_event(Events::WantsCollection).unwrap();
+        assert!(*sm.state() == States::Collection);
+    }
+
+    #[test]
+    pub fn sm_should_handle_fault_in_any_state() {
+        let mut sm = StateMachine::new(traits::Context {});
+    
+        // Should be in init by default
+        assert!(*sm.state() == States::Init);
+    
+        // Should transition to fault on fault detected
+        _ = sm.process_event(Events::FaultDetected).unwrap();
+        assert!(*sm.state() == States::Fault);
+    
+        // Should transition to idle on fault cleared
+        _ = sm.process_event(Events::FaultCleared).unwrap();
+        assert!(*sm.state() == States::Idle);
+
+        // Check fault transition from another state
+        _ = sm.process_event(Events::WantsCollection).unwrap();
+        _ = sm.process_event(Events::FaultDetected).unwrap();
+        assert!(*sm.state() == States::Fault);
+
+        // Should transition to idle on fault cleared
+        _ = sm.process_event(Events::FaultCleared).unwrap();
+        assert!(*sm.state() == States::Idle);
+    }
+}

boards/argus/src/traits.rs

@@ -1,9 +1,7 @@
 //! This module should be refactored out.
-use crate::States;
+use crate::state_machine::{StateMachineContext, States};
 use messages::state::DeviceState;
 
-use crate::StateMachineContext;
-
 pub struct Context {}
 
 impl StateMachineContext for Context {}
@@ -13,10 +11,8 @@ impl From<States> for DeviceState {
         match value {
             States::Idle => DeviceState::Idle,
             States::Calibration => DeviceState::Calibration,
-            States::Recovery => DeviceState::Recovery,
             States::Collection => DeviceState::Collection,
             States::Init => DeviceState::Init,
-            States::Processing => DeviceState::Processing,
             States::Fault => DeviceState::Fault,
         }
     }