refactored feedback & its depending stuff

- buzzer is just modulate_tone
- led is just turn on and off
- handle feedback logic to feeback file

src/buzzer.rs

@@ -2,10 +2,14 @@ use rppal::pwm::{Channel, Error, Polarity, Pwm};
 use std::{future::Future, time::Duration};
 use tokio::time::sleep;
 
-pub trait Buzzer {
+const DEFAULT_PWM_CHANNEL_BUZZER: Channel = Channel::Pwm0; //PWM0 = GPIO18/Physical pin 12
-    fn beep_ack(&mut self) -> impl Future<Output = Result<(), Error>> + std::marker::Send;
 
-    fn beep_nak(&mut self) -> impl Future<Output = Result<(), Error>> + std::marker::Send;
+pub trait Buzzer {
+    fn modulated_tone(
+        &mut self,
+        frequency_hz: f64,
+        duration: Duration,
+    ) -> impl Future<Output = Result<(), Error>> + std::marker::Send;
 }
 
 pub struct GPIOBuzzer {
@@ -13,49 +17,26 @@ pub struct GPIOBuzzer {
 }
 
 impl GPIOBuzzer {
-    /// Create a new GPIOBuzzer instance.
+    pub fn new_from_channel(channel: Channel) -> Result<Self, Error> {
-    /// 0.5 duty cyle
-    /// # Arguments
-    /// * "channel" - PWM channel for buzzer PWM0 = GPIO 12 / PWM1 = GPIO 13
-    pub fn new(channel: Channel) -> Result<Self, Error> {
         // Enable with dummy values; we'll set frequency/duty in the tone method
         let duty_cycle: f64 = 0.5;
         let pwm = Pwm::with_frequency(channel, 1000.0, duty_cycle, Polarity::Normal, true)?;
-        pwm.disable()?; // Start disabled
+        pwm.disable()?;
 
         Ok(GPIOBuzzer { pwm })
     }
 
-    /// Play a tone using hardware PWM on supported GPIO pins.
+    pub fn new_default() -> Result<Self, Error> {
-    ///
+        Self::new_from_channel(DEFAULT_PWM_CHANNEL_BUZZER)
-    /// # Arguments
-    /// * `frequency` - Frequency in Hz.
-    /// * `duration_ms` - Duration in milliseconds.
-    async fn modulated_tone(&mut self, frequency: f64, duration_ms: u64) -> Result<(), Error> {
-        self.pwm.set_frequency(frequency, 0.5)?; // 50% duty cycle (square wave)
-        self.pwm.enable()?;
-        sleep(Duration::from_millis(duration_ms)).await;
-        self.pwm.disable()?;
-        Ok(())
     }
 }
 
 impl Buzzer for GPIOBuzzer {
-    async fn beep_ack(&mut self) -> Result<(), Error> {
+    async fn modulated_tone(&mut self, frequency_hz: f64, duration: Duration) -> Result<(), Error> {
-        let sleep_ms: u64 = 10;
+        self.pwm.set_frequency(frequency_hz, 0.5)?; // 50% duty cycle (square wave)
-
+        self.pwm.enable()?;
-        self.modulated_tone(1200.0, 100).await?;
+        sleep(duration).await;
-        sleep(Duration::from_millis(sleep_ms)).await;
+        self.pwm.disable()?;
-        self.modulated_tone(2000.0, 50).await?;
-        Ok(())
-    }
-
-    async fn beep_nak(&mut self) -> Result<(), Error> {
-        let sleep_ms: u64 = 100;
-
-        self.modulated_tone(600.0, 150).await?;
-        sleep(Duration::from_millis(sleep_ms)).await;
-        self.modulated_tone(600.0, 150).await?;
         Ok(())
     }
 }

src/color.rs

@@ -1,56 +0,0 @@
-use rgb::Rgb;
-
-#[derive(Debug)]
-pub enum NamedColor {
-    Red,
-    Green,
-    Blue,
-    White,
-    Off,
-    Yellow,
-    Cyan,
-    Magenta,
-}
-
-impl Into<Rgb<u8>> for NamedColor {
-    fn into(self) -> Rgb<u8> {
-        match self {
-            NamedColor::Red => Rgb { r: 150, g: 0, b: 0 },
-            NamedColor::Green => Rgb { r: 0, g: 150, b: 0 },
-            NamedColor::Blue => Rgb { r: 0, g: 0, b: 150 },
-            NamedColor::White => Rgb {
-                r: 255,
-                g: 255,
-                b: 255,
-            },
-            NamedColor::Off => Rgb { r: 0, g: 0, b: 0 },
-            NamedColor::Yellow => Rgb {
-                r: 255,
-                g: 255,
-                b: 0,
-            },
-            NamedColor::Cyan => Rgb {
-                r: 0,
-                g: 255,
-                b: 255,
-            },
-            NamedColor::Magenta => Rgb {
-                r: 255,
-                g: 0,
-                b: 255,
-            },
-        }
-    }
-}
-
-
-impl IntoIterator for NamedColor {
-    type Item = Self;
-
-    type IntoIter = std::vec::IntoIter<Self>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        vec![self].into_iter()
-    }
-}
-

src/feedback.rs

@@ -1,7 +1,8 @@
 use log::error;
-use rppal::pwm::Channel;
+use rgb::RGB8;
-use std::error::Error;
+use smart_leds::colors::{GREEN, RED};
-use tokio::join;
+use std::{error::Error, time::Duration};
+use tokio::{join, time::sleep};
 
 use crate::{
     buzzer::{Buzzer, GPIOBuzzer},
@@ -11,7 +12,7 @@ use crate::{
 #[cfg(feature = "mock_pi")]
 use crate::mock::{MockBuzzer, MockLed};
 
-const PWM_CHANNEL_BUZZER: Channel = Channel::Pwm0; //PWM0 = GPIO18/Physical pin 12
+const LED_BLINK_DURATION: Duration = Duration::from_secs(1);
 
 pub struct Feedback<B: Buzzer, L: StatusLed> {
     buzzer: B,
@@ -20,28 +21,57 @@ pub struct Feedback<B: Buzzer, L: StatusLed> {
 
 impl<B: Buzzer, L: StatusLed> Feedback<B, L> {
     pub async fn success(&mut self) {
-        let (buzzer_result, led_result) =
+        let buzzer_handle = Self::beep_ack(&mut self.buzzer);
-            join!(self.buzzer.beep_ack(), self.led.turn_green_on_1s());
+        let led_handle = Self::blink_led_for_duration(&mut self.led, GREEN, LED_BLINK_DURATION);
+        let (buzzer_result, _) = join!(buzzer_handle, led_handle);
 
         buzzer_result.unwrap_or_else(|err| {
             error!("Failed to buzz: {err}");
         });
-
-        led_result.unwrap_or_else(|err| {
-            error!("Failed to set LED: {err}");
-        });
     }
 
     pub async fn failure(&mut self) {
-        let (buzzer_result, led_result) = join!(self.buzzer.beep_nak(), self.led.turn_red_on_1s());
+        let buzzer_handle = Self::beep_nak(&mut self.buzzer);
+        let led_handle = Self::blink_led_for_duration(&mut self.led, RED, LED_BLINK_DURATION);
+
+        let (buzzer_result, _) = join!(buzzer_handle, led_handle);
 
         buzzer_result.unwrap_or_else(|err| {
             error!("Failed to buzz: {err}");
         });
+    }
 
-        led_result.unwrap_or_else(|err| {
+    async fn blink_led_for_duration(
-            error!("Failed to set LED: {err}");
+        led: &mut L,
-        });
+        color: RGB8,
+        duration: Duration,
+    ) -> Result<(), Box<dyn Error>> {
+        led.turn_on(color)?;
+        sleep(duration).await;
+        led.turn_off()?;
+        Ok(())
+    }
+
+    async fn beep_ack(buzzer: &mut B) -> Result<(), Box<dyn Error>> {
+        buzzer
+            .modulated_tone(1200.0, Duration::from_millis(100))
+            .await?;
+        sleep(Duration::from_millis(10)).await;
+        buzzer
+            .modulated_tone(2000.0, Duration::from_millis(50))
+            .await?;
+        Ok(())
+    }
+
+    async fn beep_nak(buzzer: &mut B) -> Result<(), Box<dyn Error>> {
+        buzzer
+            .modulated_tone(600.0, Duration::from_millis(150))
+            .await?;
+        sleep(Duration::from_millis(100)).await;
+        buzzer
+            .modulated_tone(600.0, Duration::from_millis(150))
+            .await?;
+        Ok(())
     }
 }
 
@@ -62,7 +92,7 @@ impl FeedbackImpl {
         #[cfg(not(feature = "mock_pi"))]
         {
             Ok(Feedback {
-                buzzer: GPIOBuzzer::new(PWM_CHANNEL_BUZZER)?,
+                buzzer: GPIOBuzzer::new_default()?,
                 led: SpiLed::new()?,
             })
         }

src/led.rs

@@ -1,22 +1,14 @@
-use std::time::Duration;
+use rppal::spi::{Bus, Mode, SlaveSelect, Spi};
-
-use rppal::spi::{Bus, Error, Mode, SlaveSelect, Spi};
 use smart_leds::SmartLedsWrite;
-use tokio::time::sleep;
+use std::error::Error;
 use ws2812_spi::Ws2812;
 
-use crate::color::NamedColor;
+const SPI_CLOCK_SPEED: u32 = 3_800_000;
-
-const STATUS_DURATION: Duration = Duration::from_secs(1); // 1s sleep for all status led signals
 
 pub trait StatusLed {
-    fn turn_green_on_1s(
+    fn turn_off(&mut self) -> Result<(), Box<dyn Error>>;
-        &mut self,
-    ) -> impl std::future::Future<Output = Result<(), Error>> + std::marker::Send;
 
-    fn turn_red_on_1s(
+    fn turn_on(&mut self, color: rgb::RGB8) -> Result<(), Box<dyn Error>>;
-        &mut self,
-    ) -> impl std::future::Future<Output = Result<(), Error>> + std::marker::Send;
 }
 
 pub struct SpiLed {
@@ -24,30 +16,22 @@ pub struct SpiLed {
 }
 
 impl SpiLed {
-    pub fn new() -> Result<Self, Error> {
+    pub fn new() -> Result<Self, rppal::spi::Error> {
-        let spi = Spi::new(Bus::Spi0, SlaveSelect::Ss0, 3_800_000, Mode::Mode0)?;
+        let spi = Spi::new(Bus::Spi0, SlaveSelect::Ss0, SPI_CLOCK_SPEED, Mode::Mode0)?;
         let controller = Ws2812::new(spi);
         Ok(SpiLed { controller })
     }
-
-    fn turn_off(&mut self) -> Result<(), Error> {
-        self.controller.write(NamedColor::Off.into_iter())?;
-        Ok(())
-    }
 }
 
 impl StatusLed for SpiLed {
-    async fn turn_green_on_1s(&mut self) -> Result<(), Error> {
+    fn turn_off(&mut self) -> Result<(), Box<dyn Error>> {
-        self.controller.write(NamedColor::Green.into_iter())?;
+        self.controller
-        sleep(STATUS_DURATION).await;
+            .write(vec![rgb::RGB8::new(0, 0, 0)].into_iter())?;
-        self.turn_off()?;
         Ok(())
     }
 
-    async fn turn_red_on_1s(&mut self) -> Result<(), Error> {
+    fn turn_on(&mut self, color: rgb::RGB8) -> Result<(), Box<dyn Error>> {
-        self.controller.write(NamedColor::Red.into_iter())?;
+        self.controller.write(vec![color].into_iter())?;
-        sleep(STATUS_DURATION).await;
-        self.turn_off()?;
         Ok(())
     }
 }

src/main.rs

@@ -21,7 +21,6 @@ use mock::MockHotspot;
 
 mod activity_fairing;
 mod buzzer;
-mod color;
 mod feedback;
 mod hotspot;
 mod id_mapping;

src/mock.rs

@@ -1,17 +1,20 @@
+use std::time::Duration;
+
 use log::debug;
+use tokio::time::sleep;
 
 use crate::{buzzer::Buzzer, hotspot::Hotspot, led::StatusLed};
 
 pub struct MockBuzzer {}
 
 impl Buzzer for MockBuzzer {
-    async fn beep_ack(&mut self) -> Result<(), rppal::pwm::Error> {
+    async fn modulated_tone(
-        debug!("Mockbuzzer: ACK");
+        &mut self,
-        Ok(())
+        frequency_hz: f64,
-    }
+        duration: Duration,
-
+    ) -> Result<(), rppal::pwm::Error> {
-    async fn beep_nak(&mut self) -> Result<(), rppal::pwm::Error> {
+        debug!("MockBuzzer: modulte tone: {frequency_hz} Hz");
-        debug!("Mockbuzzer: NAK");
+        sleep(duration).await;
         Ok(())
     }
 }
@@ -19,13 +22,13 @@ impl Buzzer for MockBuzzer {
 pub struct MockLed {}
 
 impl StatusLed for MockLed {
-    async fn turn_green_on_1s(&mut self) -> Result<(), rppal::spi::Error> {
+    fn turn_off(&mut self) -> Result<(), Box<dyn std::error::Error>> {
-        debug!("Mockled: Turn LED green for 1 sec");
+        debug!("Turn mock LED off");
         Ok(())
     }
 
-    async fn turn_red_on_1s(&mut self) -> Result<(), rppal::spi::Error> {
+    fn turn_on(&mut self, color: rgb::RGB8) -> Result<(), Box<dyn std::error::Error>> {
-        debug!("Mockled: Turn LED red for 1 sec");
+        debug!("Turn mock LED on to: {color}");
         Ok(())
     }
 }