2022-02-11 21:00:31 +00:00
|
|
|
//! This example showcases channels and timing utilities of embassy.
|
|
|
|
//!
|
|
|
|
//! This example works best on STM32F3DISCOVERY board. It flashes a single LED, then if the USER
|
|
|
|
//! button is pressed the next LED is flashed (in clockwise fashion). If the USER button is double
|
|
|
|
//! clicked, then the direction changes. If the USER button is pressed for 1 second, then all the
|
|
|
|
//! LEDS flash 3 times.
|
|
|
|
//!
|
|
|
|
|
|
|
|
#![no_std]
|
|
|
|
#![no_main]
|
|
|
|
#![feature(type_alias_impl_trait)]
|
|
|
|
|
2022-04-02 02:35:06 +00:00
|
|
|
use defmt::*;
|
2022-07-29 19:58:35 +00:00
|
|
|
use embassy_executor::executor::Spawner;
|
|
|
|
use embassy_executor::time::{with_timeout, Duration, Timer};
|
2022-02-11 21:00:31 +00:00
|
|
|
use embassy_stm32::exti::ExtiInput;
|
|
|
|
use embassy_stm32::gpio::{AnyPin, Input, Level, Output, Pin, Pull, Speed};
|
|
|
|
use embassy_stm32::peripherals::PA0;
|
|
|
|
use embassy_stm32::Peripherals;
|
2022-07-29 19:58:35 +00:00
|
|
|
use embassy_util::blocking_mutex::raw::ThreadModeRawMutex;
|
|
|
|
use embassy_util::channel::mpmc::Channel;
|
2022-06-12 20:15:44 +00:00
|
|
|
use {defmt_rtt as _, panic_probe as _};
|
2022-02-11 21:00:31 +00:00
|
|
|
|
|
|
|
struct Leds<'a> {
|
|
|
|
leds: [Output<'a, AnyPin>; 8],
|
|
|
|
direction: i8,
|
|
|
|
current_led: usize,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a> Leds<'a> {
|
|
|
|
fn new(pins: [Output<'a, AnyPin>; 8]) -> Self {
|
|
|
|
Self {
|
|
|
|
leds: pins,
|
|
|
|
direction: 1,
|
|
|
|
current_led: 0,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn change_direction(&mut self) {
|
|
|
|
self.direction *= -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
fn move_next(&mut self) {
|
|
|
|
if self.direction > 0 {
|
|
|
|
self.current_led = (self.current_led + 1) & 7;
|
|
|
|
} else {
|
|
|
|
self.current_led = (8 + self.current_led - 1) & 7;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-04-05 22:00:29 +00:00
|
|
|
async fn show(&mut self) {
|
2022-02-11 21:00:31 +00:00
|
|
|
self.leds[self.current_led].set_high();
|
2022-04-05 22:00:29 +00:00
|
|
|
if let Ok(new_message) = with_timeout(Duration::from_millis(500), CHANNEL.recv()).await {
|
2022-02-16 20:22:35 +00:00
|
|
|
self.leds[self.current_led].set_low();
|
|
|
|
self.process_event(new_message).await;
|
|
|
|
} else {
|
|
|
|
self.leds[self.current_led].set_low();
|
2022-06-12 20:15:44 +00:00
|
|
|
if let Ok(new_message) = with_timeout(Duration::from_millis(200), CHANNEL.recv()).await {
|
2022-02-16 20:22:35 +00:00
|
|
|
self.process_event(new_message).await;
|
|
|
|
}
|
|
|
|
}
|
2022-02-11 21:00:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
async fn flash(&mut self) {
|
|
|
|
for _ in 0..3 {
|
|
|
|
for led in &mut self.leds {
|
|
|
|
led.set_high();
|
|
|
|
}
|
|
|
|
Timer::after(Duration::from_millis(500)).await;
|
|
|
|
for led in &mut self.leds {
|
|
|
|
led.set_low();
|
|
|
|
}
|
|
|
|
Timer::after(Duration::from_millis(200)).await;
|
|
|
|
}
|
|
|
|
}
|
2022-02-16 20:22:35 +00:00
|
|
|
|
2022-04-05 22:00:29 +00:00
|
|
|
async fn process_event(&mut self, event: ButtonEvent) {
|
2022-02-16 20:22:35 +00:00
|
|
|
match event {
|
2022-04-05 22:00:29 +00:00
|
|
|
ButtonEvent::SingleClick => {
|
|
|
|
self.move_next();
|
|
|
|
}
|
|
|
|
ButtonEvent::DoubleClick => {
|
2022-02-16 20:22:35 +00:00
|
|
|
self.change_direction();
|
2022-04-05 22:00:29 +00:00
|
|
|
self.move_next();
|
|
|
|
}
|
|
|
|
ButtonEvent::Hold => {
|
|
|
|
self.flash().await;
|
2022-02-16 20:22:35 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2022-02-11 21:00:31 +00:00
|
|
|
}
|
|
|
|
|
2022-02-16 20:22:35 +00:00
|
|
|
#[derive(Format)]
|
2022-02-11 21:00:31 +00:00
|
|
|
enum ButtonEvent {
|
|
|
|
SingleClick,
|
|
|
|
DoubleClick,
|
|
|
|
Hold,
|
|
|
|
}
|
|
|
|
|
2022-04-05 22:00:29 +00:00
|
|
|
static CHANNEL: Channel<ThreadModeRawMutex, ButtonEvent, 4> = Channel::new();
|
2022-02-11 21:00:31 +00:00
|
|
|
|
2022-07-29 19:58:35 +00:00
|
|
|
#[embassy_executor::main]
|
2022-02-11 21:00:31 +00:00
|
|
|
async fn main(spawner: Spawner, p: Peripherals) {
|
|
|
|
let button = Input::new(p.PA0, Pull::Down);
|
|
|
|
let button = ExtiInput::new(button, p.EXTI0);
|
|
|
|
info!("Press the USER button...");
|
|
|
|
let leds = [
|
|
|
|
Output::new(p.PE9.degrade(), Level::Low, Speed::Low),
|
|
|
|
Output::new(p.PE10.degrade(), Level::Low, Speed::Low),
|
|
|
|
Output::new(p.PE11.degrade(), Level::Low, Speed::Low),
|
|
|
|
Output::new(p.PE12.degrade(), Level::Low, Speed::Low),
|
|
|
|
Output::new(p.PE13.degrade(), Level::Low, Speed::Low),
|
|
|
|
Output::new(p.PE14.degrade(), Level::Low, Speed::Low),
|
|
|
|
Output::new(p.PE15.degrade(), Level::Low, Speed::Low),
|
|
|
|
Output::new(p.PE8.degrade(), Level::Low, Speed::Low),
|
|
|
|
];
|
|
|
|
let leds = Leds::new(leds);
|
|
|
|
|
2022-04-05 22:00:29 +00:00
|
|
|
spawner.spawn(button_waiter(button)).unwrap();
|
|
|
|
spawner.spawn(led_blinker(leds)).unwrap();
|
2022-02-11 21:00:31 +00:00
|
|
|
}
|
|
|
|
|
2022-07-29 19:58:35 +00:00
|
|
|
#[embassy_executor::task]
|
2022-04-05 22:00:29 +00:00
|
|
|
async fn led_blinker(mut leds: Leds<'static>) {
|
2022-02-11 21:00:31 +00:00
|
|
|
loop {
|
2022-04-05 22:00:29 +00:00
|
|
|
leds.show().await;
|
2022-02-11 21:00:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-07-29 19:58:35 +00:00
|
|
|
#[embassy_executor::task]
|
2022-04-05 22:00:29 +00:00
|
|
|
async fn button_waiter(mut button: ExtiInput<'static, PA0>) {
|
2022-02-11 21:00:31 +00:00
|
|
|
const DOUBLE_CLICK_DELAY: u64 = 250;
|
|
|
|
const HOLD_DELAY: u64 = 1000;
|
|
|
|
|
|
|
|
button.wait_for_rising_edge().await;
|
|
|
|
loop {
|
2022-06-12 20:15:44 +00:00
|
|
|
if with_timeout(Duration::from_millis(HOLD_DELAY), button.wait_for_falling_edge())
|
|
|
|
.await
|
|
|
|
.is_err()
|
2022-02-11 21:00:31 +00:00
|
|
|
{
|
|
|
|
info!("Hold");
|
2022-04-05 22:00:29 +00:00
|
|
|
CHANNEL.send(ButtonEvent::Hold).await;
|
2022-02-11 21:00:31 +00:00
|
|
|
button.wait_for_falling_edge().await;
|
2022-06-12 20:15:44 +00:00
|
|
|
} else if with_timeout(Duration::from_millis(DOUBLE_CLICK_DELAY), button.wait_for_rising_edge())
|
|
|
|
.await
|
|
|
|
.is_err()
|
2022-02-11 21:00:31 +00:00
|
|
|
{
|
|
|
|
info!("Single click");
|
2022-04-05 22:00:29 +00:00
|
|
|
CHANNEL.send(ButtonEvent::SingleClick).await;
|
2022-02-11 21:00:31 +00:00
|
|
|
} else {
|
|
|
|
info!("Double click");
|
2022-04-05 22:00:29 +00:00
|
|
|
CHANNEL.send(ButtonEvent::DoubleClick).await;
|
2022-02-11 21:00:31 +00:00
|
|
|
button.wait_for_falling_edge().await;
|
|
|
|
}
|
|
|
|
button.wait_for_rising_edge().await;
|
|
|
|
}
|
|
|
|
}
|