1
//! System manager
2

3
use defmt::*;
4
use defmt_rtt as _;
5
use panic_probe as _;
6

7
use embassy_sync::blocking_mutex::raw::ThreadModeRawMutex;
8
use embassy_sync::pubsub::PubSubChannel;
9

10
use crate::button::BUTTON_READY_SIGNAL;
11

12
//////////////////////////////////////////////////////////////////////////////
13
//                         SYSTEM READY SIGNAL
14
//////////////////////////////////////////////////////////////////////////////
15

16
/// System ready pub-sub topic channel
17
/// 1 total capacity/messages, 4 subscribers, and 1 publisher
18
pub static SYSTEM_READY_PUBSUB_CHANNEL: PubSubChannel<ThreadModeRawMutex, (), 1, 4, 1> = PubSubChannel::new();
19

20
/// Async task - Waiting for all subsystems to report back as ready
21
#[embassy_executor::task]
22
pub async fn wait_for_system_ready() {
23
    info!("Running System ready async task ...");
24
    info!("Waiting for system to be ready ...");
25

26
    // Waiting for each system component to report back as ready
27
    BUTTON_READY_SIGNAL.wait().await;
28
    // ... Add other ready signal here ...
29

30
    // Signal out that the system is ready
31
    SYSTEM_READY_PUBSUB_CHANNEL.publisher().unwrap().publish(()).await;
32
    info!(">>>>>>>>>  ALL SYSTEMS GO! BIG BUTTON IS READY!  <<<<<<<<<");
33
}

5
use embassy_sync::blocking_mutex::raw::ThreadModeRawMutex; // Ensure thread-safety across tasks
6
use embassy_sync::pubsub::PubSubChannel;
7
use embassy_sync::signal::Signal;
8
use embassy_time::Instant;
9

23 collapsed lines
10
/// Button press type
11
#[derive(Debug, Copy, Clone, PartialEq)]
12
pub enum PressType {
13
    /// Short button press type
14
    ShortRelease,
15
    /// Long button press type
16
    LongRelease,
17
    /// Long hold
18
    LongHold,
19
}
20

21
/// Button pub-sub message item definition/structure that is passed via channel
22
#[derive(Debug, Copy, Clone)]
23
pub struct ButtonMessage {
24
    /// Button ID
25
    pub id: u8,
26
    /// Timestamp of button press start
27
    pub timestamp_start: Instant,
28
    /// Timestamp of button press end
29
    pub timestamp_end: Instant,
30
    /// The type of button press
31
    pub press_type: PressType,
32
}
33

34
/// Button pub-sub topic channel
35
/// Other program parts can listen to this topic to get button press events
36
/// 3 total capacity/messages, 3 subscribers, and 1 publisher
37
pub static BUTTON_PUBSUB_CHANNEL: PubSubChannel<ThreadModeRawMutex, ButtonMessage, 2, 3, 1> = PubSubChannel::new();
38

39
/// A signal / flag that signals that the button system ready
40
pub static BUTTON_READY_SIGNAL: Signal<ThreadModeRawMutex, bool> = Signal::new();

6 collapsed lines
1
//! Button module - Task manager module
2

3
use defmt::*;
4
use defmt_rtt as _;
5
use panic_probe as _;
6

7
use embassy_futures::select::select;
8
use embassy_rp::gpio::Input;
9

10
use super::BUTTON_READY_SIGNAL;
11
use super::Button;
12
use super::utility;
13
use crate::system_manager::SYSTEM_READY_PUBSUB_CHANNEL;
14

15
/// Async task - Button
16
/// Continuously monitor and report button press/release events
17
///
18
/// * `button_info` - Button information vector
19
#[embassy_executor::task]
20
pub async fn start_button_monitor(button_info: [(u8, Input<'static>); 1]) {
21
    info!("Running Button monitor async task ...");
22
    let mut button = Button::new(button_info).unwrap();
23

24
    // Signal to system that button is ready to be used
25
    BUTTON_READY_SIGNAL.signal(true);
26

27
    // Wait idle until the system manager sends a ready signal
28
    let mut system_ready_message = SYSTEM_READY_PUBSUB_CHANNEL.subscriber().unwrap();
29
    select(system_ready_message.next_message_pure(), utility::do_nothing_idle()).await;
30

31
    // Start the continuous button monitor watch
32
    button.monitor_press(0).await;
33
}

1
//! Button - Utility functions
2

3
use embassy_time::Timer;
4

5
/// Create a future that doesn't do anything except wait
6
/// This can be used for placeholder for anything that idles
7
pub async fn do_nothing_idle() {
8
    loop {
9
        Timer::after_millis(1000).await;
10
    }
11
}

1
//! Button module - Module definition - Responsible for handling system buttons
2

3
// Map all parts of this module
4
mod consumer_loop;
5
mod core;
6
mod messaging;
7
mod utility;
8

9
// Public re-export of specifics that are available outside of module
10
pub use consumer_loop::start_button_monitor;
11
pub use core::Button;
12
pub use messaging::{BUTTON_PUBSUB_CHANNEL, BUTTON_READY_SIGNAL, ButtonMessage, PressType};

12 collapsed lines
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_sync::blocking_mutex::raw::ThreadModeRawMutex;
11
use embassy_sync::pubsub::Subscriber;
12
use embassy_time::Timer;
13

14
use crate::button::{BUTTON_PUBSUB_CHANNEL, ButtonMessage, PressType};
15
use crate::system_manager::SYSTEM_READY_PUBSUB_CHANNEL;

147
/// State machine task with infinite loop
148
#[embassy_executor::task]
149
pub async fn state_machine_task() -> ! {
150
    info!("Running State Machine async task ...");
151
    let mut state_machine = StateMachine::new(State::Startup, Event::PowerOn);
152

153
    // Send a "PowerOn" event to state machine to handle
154
    state_machine.handle_event(Event::PowerOn).await;
155

156
    // Waiting on system to be ready to proceed
157
    let mut system_ready_message = SYSTEM_READY_PUBSUB_CHANNEL.subscriber().unwrap();
158
    system_ready_message.next_message_pure().await;
159

160
    // Send a "Ready" event to state machine to handle
161
    state_machine.handle_event(Event::Ready).await;
162

163
    // Main infinite loop for the state machine
164
    loop {
8 collapsed lines
165
        // Get the current event
166
        let current_event = state_machine.get_current_event().await;
167

168
        // Handle the event and update the state
169
        state_machine.handle_event(current_event).await;
170

171
        // Add a small delay to prevent tight looping
172
        Timer::after_millis(10).await;
173
    }
174
}

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::{Input, Pull};
13
use embassy_time::Timer;
14

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

1
#[embassy_executor::main]
2
async fn main(spawner: Spawner) {
18 collapsed lines
3
    info!("==================================");
4
    info!("    Package: {} v{}", env!("CARGO_PKG_NAME"), env!("CARGO_PKG_VERSION"));
5
    info!("==================================");
6

7
    // Apply default clock configuration
8
    let mut hal_configuration = HalConfig::default();
9

10
    info!("Configuring all system clocks ...");
11
    let clock_settings = ClockSettings {
12
        xosc_crystal_hz: 12_000_000, // RP2350 uses 12MHz crystal
13
        system_frequency_mhz: CLOCK_SYSTEM_FREQUENCY_MHZ.parse::<u32>().unwrap(),
14
        usb_frequency_mhz: CLOCK_USB_FREQUENCY_MHZ.parse::<u32>().unwrap(),
15
        peripheral_clock_divider: CLOCK_PERIPHERAL_DIVIDER.parse::<u8>().unwrap(),
16
        adc_frequency_mhz: CLOCK_ADC_FREQUENCY_MHZ.parse::<u32>().unwrap(),
17
        reference_clock_divider: CLOCK_REFERENCE_DIVIDER.parse::<u8>().unwrap(),
18
    };
19
    clocks_config::configure_all_clocks(&mut hal_configuration, clock_settings);
20
    let peripherals = embassy_rp::init(hal_configuration);
21

22
    // Log and verify system clock frequencies
23
    clocks_config::print_device_frequencies();
24
    clocks_config::verify_clock_with_timer(500).await;
25

26
    //////////////////////////////////////////////////////////////////////////
27

28
    // Task to check if all system components are ready to go
29
    spawner.spawn(system_manager::wait_for_system_ready()).unwrap();
30

31
    //////////////////////////////////////////////////////////////////////////
32

33
    // Button - Define and spawn async task
34
    let button_info = [(0_u8, Input::new(peripherals.PIN_15, Pull::Up))];
35
    spawner
36
        .spawn(button::start_button_monitor(button_info))
37
        .expect("Failed spawning button_consumer");
38

39
    //////////////////////////////////////////////////////////////////////////
40

12 collapsed lines
41
    // Spawn state machine async task
42
    spawner
43
        .spawn(state_machine::state_machine_task())
44
        .expect("Failed spawning state machine");
45

46
    info!("All Set! Running async loop ...");
47

48
    // General async loop to ensure entire program runs forever while
49
    // asynchronously working on other tasks
50
    loop {
51
        Timer::after_secs(5).await;
52
    }
53
}