esp-flow 0.2.0

ESP embedded library with reusable modules for BLE, Wi-Fi, HTTP, GPS, LED control, and more.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

use anyhow::{anyhow, Result};
use esp_idf_svc::log::EspLogger;
use log::info;
use std::sync::{Arc, Mutex};

use esp_flow::{
    gps::{Reading, Sensor},
    infra::{Poller, Switch},
    thread,
};

mod common;
use common::{
    hw::Context,
    logic::{trace_func, Core, DeviceNearby, State, Trigger},
};

// State machine for the client device (GPS tracking, BLE advertising).
struct StateMachine<'a> {
    core: Core<'a>,
    location: Arc<Mutex<Option<Reading>>>,
    max_speed_mps: f32,
}

impl<'a> StateMachine<'a> {
    // Creates a new client state machine.
    fn new(core: Core<'a>, location: Arc<Mutex<Option<Reading>>>) -> Self {
        Self {
            core,
            location,
            max_speed_mps: 0.0,
        }
    }

    // Custom button handler that also resets the max speed.
    fn handle_button_pressed(
        core: &mut Core<'_>,
        max_speed_mps: &mut f32,
    ) -> Result<()> {
        trace_func!();

        if core.state.is_off() {
            *max_speed_mps = 0.0;
            core.state = State::on();
        } else {
            core.state = State::off();
        }

        core.advertiser.toggle()
    }

    // Runs the state machine.
    fn run(&mut self) -> Result<()> {
        let max_speed_mps = &mut self.max_speed_mps;
        let location = &self.location;

        self.core.run(|core, triggers| {
            if core.handle_common_triggers(
                triggers,
                |c| Self::handle_button_pressed(c, max_speed_mps),
                |c| {
                    trace_func!();
                    // Only change state if not already Off or ActiveDeviceNearby
                    if c.state.is_on()
                        && !matches!(c.state, State::On(Some(DeviceNearby::Active)))
                    {
                        c.state = State::On(Some(DeviceNearby::Active));
                    }
                    Ok(())
                },
            )? {
                Ok(())
            } else if triggers.contains(&Trigger::GpsDataAvailable) {
                let mut data = location
                    .lock()
                    .map_err(|e| anyhow!("Mutex lock error: {:?}", e))?;

                if let Some(reading) = data.take() {
                    info!("GPS Reading: {}", reading);
                    if let Some(speed) = reading.speed_mps() {
                        if speed > *max_speed_mps {
                            *max_speed_mps = speed;
                        }
                    }
                    let payload = (*max_speed_mps > 0.0).then(|| {
                        let bytes = max_speed_mps.to_le_bytes().to_vec();
                        let kmph = *max_speed_mps * 3.6;
                        info!(
                            "Advertising {} bytes: {:?} (max_speed: {kmph:.2} km/h)",
                            bytes.len(),
                            bytes
                        );
                        bytes
                    });
                    core.advertiser.set_payload(payload)?;
                }
                Ok(())
            } else {
                Err(anyhow!("Unknown triggers: {:?}", triggers))
            }
        })
    }
}

fn main() -> ! {
    thread::main(|| {
        EspLogger::initialize_default();

        // Setup common context (peripherals, threads, etc.)
        let context = Context::try_default()?;

        // Setup GPS sensor thread (client-specific)
        let location = Arc::new(Mutex::new(None::<Reading>));
        let (
            dispatcher,
            advertiser,
            led,
            led_timer,
            gps_notifier,
            button_state,
            uart_driver,
            _,
            _,
        ) = context.into_parts();

        let mut gps = Sensor::new(
            gps_notifier,
            &Trigger::GpsDataAvailable,
            button_state,
            uart_driver,
            Arc::clone(&location),
        );
        thread::spawn(move || gps.poll());

        // Create and run state machine with location
        let core = Core::new(State::on(), dispatcher, advertiser, led, led_timer)?;
        let mut sm = StateMachine::new(core, location);

        sm.run()
    })
}