1
//! State machine module for the embedded application
2

3
#![allow(dead_code)] // only used for development
4
#![allow(unused_variables)] // only used for development
5

6
use defmt::*;
7
use defmt_rtt as _;
8
use panic_probe as _;
9

10
use embassy_time::{Duration, Instant, Timer};
11

12
/// State machine possible states
13
#[derive(Format, Debug, Clone, Copy, PartialEq)]
14
enum State {
15
    /// Startup - Initial state
16
    Startup,
17
    /// Device is idle
18
    Idle,
19
    /// Device is processing something
20
    Processing,
21
    /// Device is in an error state
22
    Error,
23
}
24

25
/// State machine possible events
26
#[derive(Format, Debug, Clone, Copy)]
27
enum Event {
28
    /// Initial startup
29
    PowerOn,
30
    /// System ready
31
    Ready,
32
    /// Nothing has happened
33
    Nothing,
34
    // Temporary state machine event (To be replaced later)
35
    SomethingElse,
36
    /// Error has occurred
37
    Error,
38
}

38
// ....
39

40
struct StateMachine {
41
    /// Current state of the state machine: [`State`]
42
    current_state: State,
43
    /// Latest event: [`Event`]
44
    latest_event: Event,
45
}
46

47
impl StateMachine {
48
    /// Constructor
49
    fn new(current_state: State, latest_event: Event) -> Self {
50
        StateMachine {
51
            current_state,
52
            latest_event,
53
        }
54
    }
55

56
    /// Handle events and transition between states in state machine
57
    ///
58
    /// * `event` - Event to handle
59
    async fn handle_event(&mut self, event: Event) {
60
        // Check the current state of the state machine with the passed state machine event
61
        match (self.current_state, event) {
62
            // TODO: Logic to handle events
63

64
            _ => {}
65
        }
66
    }
67

68
    /// Get the current event - based on various conditions and inputs
69
    /// Return event to the state machine for determining the next state
70
    async fn get_current_event(&mut self) -> Event {
71
      // TODO:: Logic to get the next event
72
    }
73

74
    /// Check for any system error conditions
75
    /// Return `true` if an error is detected
76
    async fn check_for_errors(&self) -> bool {
77
        false
78
    }
79
}

38
// ....
39

40
struct StateMachine {
4 collapsed lines
41
    /// Current state of the state machine: [`State`]
42
    current_state: State,
43
    /// Latest event: [`Event`]
44
    latest_event: Event,
45
}
46

47
impl StateMachine {
48
    /// Constructor
49
    fn new(current_state: State, latest_event: Event) -> Self {
4 collapsed lines
50
        StateMachine {
51
            current_state,
52
            latest_event,
53
        }
54
    }
55

56
    /// Handle events and transition between states in state machine
57
    ///
58
    /// * `event` - Event to handle
59
    async fn handle_event(&mut self, event: Event) {
60
        // Check the current state of the state machine with the passed state machine event
61
        match (self.current_state, event) {
62
            (State::Startup, Event::PowerOn) => {
63
                info!("[State: Startup - Event: PowerOn]");
64
            }
65

66
            (State::Startup, Event::Ready) => {
67
                info!("[State: Startup - Event: Ready] Startup -> Idle");
68
                self.current_state = State::Idle;
69
            }
70

71
            (State::Idle, Event::SomethingElse) => {
72
                info!("[State: Idle - Event: SomethingElse] Some other event happened: Idle -> Processing");
73
                self.current_state = State::Processing;
74
            }
75

76
            (State::Processing, Event::Nothing) => {
77
                info!("[State: Processing - Event: Nothing] Nothing: Processing -> Idle");
78
                self.current_state = State::Idle;
79
            }
80

81
            (_, Event::Error) => {
82
                info!("[Event: Error] Error: {:?} -> Error", self.current_state);
83
                self.current_state = State::Error;
84
            }
85

86
            (State::Error, _) => {
87
                core::panic!("[State: Error] State machine in an error state!");
88
            }
89

90
            _ => {} // No state change for unhandled events
91
        }
92
    }
93

94
    /// Get the current event - based on various conditions and inputs
95
    /// Return event to the state machine for determining the next state
96
    async fn get_current_event(&mut self) -> Event {
97
        // ++ Add event handling here (i.e. monitor button press) ++
98

99
        // No events occurred, return a nothing event
100
        Event::Nothing
101
    }
102

103
    /// Check for any system error conditions
104
    /// Return `true` if an error is detected
105
    async fn check_for_errors(&self) -> bool {
106
        false
107
    }
108
}

108
// ....
109

110
/// State machine task with infinite loop
111
#[embassy_executor::task]
112
pub async fn state_machine_task() -> ! {
113
    info!("Running State Machine async task ...");
114

115
    let mut state_machine = StateMachine::new(State::Startup, Event::Nothing);
116
    state_machine.handle_event(Event::PowerOn).await;
117

118
    // Main infinite loop for the state machine
119
    loop {
120
        // Get the current event
121
        let current_event = state_machine.get_current_event().await;
122

123
        // Handle the event and update the state
124
        state_machine.handle_event(current_event).await;
125

126
        // Add a small delay to prevent tight looping
127
        Timer::after_millis(10).await;
128
    }
129
}

13 collapsed lines
1
#![no_std]
2
#![no_main]
3
#![allow(unused_variables)] // only used for development
4
#![allow(unused_imports)] // only used for development
5

6
use defmt::*;
7
use defmt_rtt as _;
8
use panic_probe as _;
9

10
use embassy_executor::Spawner;
11
use embassy_rp::config::Config as HalConfig;
12
use embassy_rp::gpio;
13
use embassy_time::Timer;
14

15
mod clocks_config;
16
use clocks_config::ClockSettings;
17
mod state_machine;
18
mod utility;
19

9 collapsed lines
20
// Loading configurations
21
// Note: This comes from the 'configs.rs' file created in 'build.rs' from 'configs.json'
22
// Note: All loaded configurations will be UPPERCASE string slice (&str) constants
23
include!(concat!(env!("OUT_DIR"), "/configs.rs"));
24

25
// Loading obfuscated secrets (XOR_KEY and _OBFUSCATED constants)
26
// Note: Similar considerations as configurations
27
// Note: Load via utility.deobfuscate()
28
include!(concat!(env!("OUT_DIR"), "/secrets.rs"));
29

30
#[embassy_executor::main]
31
async fn main(spawner: Spawner) {
18 collapsed lines
32
    info!("==================================");
33
    info!("    Package: {} v{}", env!("CARGO_PKG_NAME"), env!("CARGO_PKG_VERSION"));
34
    info!("==================================");
35

36
    // Apply default clock configuration
37
    let mut hal_configuration = HalConfig::default();
38

39
    info!("Configuring all system clocks ...");
40
    let clock_settings = ClockSettings {
41
        xosc_crystal_hz: 12_000_000, // RP2350 uses 12MHz crystal
42
        system_frequency_mhz: CLOCK_SYSTEM_FREQUENCY_MHZ.parse::<u32>().unwrap(),
43
        usb_frequency_mhz: CLOCK_USB_FREQUENCY_MHZ.parse::<u32>().unwrap(),
44
        peripheral_clock_divider: CLOCK_PERIPHERAL_DIVIDER.parse::<u8>().unwrap(),
45
        adc_frequency_mhz: CLOCK_ADC_FREQUENCY_MHZ.parse::<u32>().unwrap(),
46
        reference_clock_divider: CLOCK_REFERENCE_DIVIDER.parse::<u8>().unwrap(),
47
    };
48
    clocks_config::configure_all_clocks(&mut hal_configuration, clock_settings);
49
    let peripherals = embassy_rp::init(hal_configuration);
50

51
    // Log and verify system clock frequencies
52
    clocks_config::print_device_frequencies();
53
    clocks_config::verify_clock_with_timer(500).await;
54

55
    // Spawn state machine async task
56
    spawner
57
        .spawn(state_machine::state_machine_task())
58
        .expect("Failed spawning state machine");
59

60
    info!("All Set! Running async loop ...");
61

62
    // General async loop to ensure entire program runs forever while
63
    // asynchronously working on other tasks
64
    loop {
65
        Timer::after_secs(5).await;
66
    }
67
}