Update RGBLED digital implementation

Co-authored-by: Sam Greenbury <[email protected]>

Author: llewelld

Cargo.toml

@@ -16,4 +16,4 @@ edition = "2018"
 
 [dependencies]
 rppal = "0.12.0"
-
+palette = "0.7.3"

examples/blink_rgb.rs

@@ -1,18 +1,38 @@
 //! Blinks an LED : on_time: 2 seconds and off_time: 3 seconds
 
 use rust_gpiozero::*;
+use palette::rgb::Rgb;
+use std::{thread, time};
 
 fn main() {
     // Create a new LED attached to Pin 17
-    let mut led = RGBLED::new(23, 24, 25);
+    let mut led = RGBLED::new(12, 19, 13);
 
-    // on_time = 2 secs, off_time=3 secs
-    led.red.blink(0.11, 0.05);
-    led.green.blink(0.7, 0.17);
-    led.blue.blink(0.23, 0.03);
+    // Display some colours for half a second each
+    led.set_color(Rgb::new(1.0, 1.0, 0.0));
+    thread::sleep(time::Duration::from_millis(500));
+    led.set_color(Rgb::new(0.0, 1.0, 0.0));
+    thread::sleep(time::Duration::from_millis(500));
+    led.set_color(Rgb::new(0.0, 1.0, 1.0));
+    thread::sleep(time::Duration::from_millis(500));
 
-    // prevent program from exiting immediately
-    led.red.wait();
-    led.green.wait();
-    led.blue.wait();
+    // Blink five times
+    led.set_blink_count(5);
+    led.blink(0.5, 0.2, Rgb::new(1.0, 1.0, 0.0), Rgb::new(0.0, 0.0, 1.0));
+    led.wait();
+    led.off();
+
+    // Stay off for a second
+    thread::sleep(time::Duration::from_millis(1000));
+
+    // Blink ten times
+    led.set_blink_count(10);
+    led.blink(0.2, 0.5, Rgb::new(1.0, 1.0, 1.0), Rgb::new(1.0, 0.0, 0.0));
+    led.wait();
+
+    // Show white for two seconds
+    led.on();
+    led.set_color(Rgb::new(1.0, 1.0, 1.0));
+    thread::sleep(time::Duration::from_millis(2000));
+    led.off();
 }

src/devices.rs

@@ -31,6 +31,7 @@ macro_rules! impl_device {
 pub struct GpioDevice {
     pin: Pin,
     active_state: bool,
+    #[allow(dead_code)]
     inactive_state: bool,
 }
 

src/output_devices.rs

@@ -6,6 +6,7 @@ use std::sync::Mutex;
 use std::thread;
 use std::thread::JoinHandle;
 use std::time::Duration;
+use palette::rgb::Rgb;
 
 /// Represents a generic GPIO output device.
 #[derive(Debug)]
@@ -257,19 +258,205 @@ impl DigitalOutputDevice {
 }
 
 pub struct RGBLED {
-    pub red: LED,
-    pub green: LED,
-    pub blue: LED,
+    devices: [Arc<Mutex<OutputDevice>>; 3],
+    blinking: Arc<AtomicBool>,
+    handle: Option<JoinHandle<()>>,
+    blink_count: Option<i32>,
 }
 
 impl RGBLED {
     pub fn new(pin_red: u8, pin_green: u8, pin_blue: u8) -> RGBLED {
         RGBLED {
-            red: LED::new(pin_red),
-            green: LED::new(pin_green),
-            blue: LED::new(pin_blue),
+            devices: [
+                Arc::new(Mutex::new(OutputDevice::new(pin_red))),
+                Arc::new(Mutex::new(OutputDevice::new(pin_green))),
+                Arc::new(Mutex::new(OutputDevice::new(pin_blue))),
+            ],
+            blinking: Arc::new(AtomicBool::new(false)),
+            handle: None,
+            blink_count: None,
+        }
+    }
+
+    pub fn set_color(&mut self, color: Rgb) {
+        Self::write_color(&self.devices, color);
+    }
+
+    fn write_color(devices: &[Arc<Mutex<OutputDevice>>; 3], color: Rgb) {
+        Self::write_state(&devices[0], color.red > 0.5);
+        Self::write_state(&devices[1], color.green > 0.5);
+        Self::write_state(&devices[2], color.blue > 0.5);
+    }
+
+    fn write_state(device: &Arc<Mutex<OutputDevice>>, value: bool) {
+        if device.lock().unwrap().value_to_state(value) {
+            device.lock().unwrap().pin.set_high()
+        } else {
+            device.lock().unwrap().pin.set_low()
+        }
+    }
+
+    fn blinker(&mut self, on_time: f32, off_time: f32, on_color: Rgb, off_color: Rgb, n: Option<i32>) {
+        self.stop();
+
+        let devices = [
+            Arc::clone(&self.devices[0]),
+            Arc::clone(&self.devices[1]),
+            Arc::clone(&self.devices[2]),
+        ];
+        let blinking = Arc::clone(&self.blinking);
+
+        self.handle = Some(thread::spawn(move || {
+            blinking.store(true, Ordering::SeqCst);
+            match n {
+                Some(end) => {
+                    for _ in 0..end {
+                        if !blinking.load(Ordering::SeqCst) {
+                            devices[0].lock().unwrap().off();
+                            devices[1].lock().unwrap().off();
+                            devices[2].lock().unwrap().off();
+                            break;
+                        }
+                        Self::write_color(&devices, on_color);
+                        thread::sleep(Duration::from_millis((on_time * 1000.0) as u64));
+                        Self::write_color(&devices, off_color);
+                        thread::sleep(Duration::from_millis((off_time * 1000.0) as u64));
+                    }
+                }
+                None => loop {
+                    if !blinking.load(Ordering::SeqCst) {
+                        devices[0].lock().unwrap().off();
+                        devices[1].lock().unwrap().off();
+                        devices[2].lock().unwrap().off();
+                        break;
+                    }
+                    Self::write_color(&devices, on_color);
+                    thread::sleep(Duration::from_millis((on_time * 1000.0) as u64));
+                    Self::write_color(&devices, off_color);
+                    thread::sleep(Duration::from_millis((off_time * 1000.0) as u64));
+                },
+            }
+        }));
+    }
+    /// Returns ``True`` if the device is currently active and ``False`` otherwise.
+    pub fn is_active(&self) -> bool {
+        self.devices[0].lock().unwrap().is_active()
+            || self.devices[1].lock().unwrap().is_active()
+            || self.devices[2].lock().unwrap().is_active()
+    }
+    /// Turns the device on.
+    pub fn on(&self) {
+        self.stop();
+        self.devices[0].lock().unwrap().on();
+        self.devices[1].lock().unwrap().on();
+        self.devices[2].lock().unwrap().on();
+    }
+    /// Turns the device off.
+    pub fn off(&self) {
+        self.stop();
+        self.devices[0].lock().unwrap().off();
+        self.devices[1].lock().unwrap().off();
+        self.devices[2].lock().unwrap().off();
+    }
+    /// Reverse the state of the device. If it's on, turn it off; if it's off, turn it on.
+    pub fn toggle(&mut self) {
+        if self.is_active() {
+            self.on()
+        } else {
+            self.off()
+        }
+    }
+
+    /// Returns ``True`` if the device is currently active and ``False`` otherwise.
+    pub fn value_red(&self) -> bool {
+        self.devices[0].lock().unwrap().value()
+    }
+
+    /// Returns ``True`` if the device is currently active and ``False`` otherwise.
+    pub fn value_green(&self) -> bool {
+        self.devices[1].lock().unwrap().value()
+    }
+
+    /// Returns ``True`` if the device is currently active and ``False`` otherwise.
+    pub fn value_blue(&self) -> bool {
+        self.devices[2].lock().unwrap().value()
+    }
+
+    fn stop(&self) {
+        self.blinking.clone().store(false, Ordering::SeqCst);
+        self.devices[0].lock().unwrap().pin.set_low();
+        self.devices[1].lock().unwrap().pin.set_low();
+        self.devices[2].lock().unwrap().pin.set_low();
+    }
+
+    /// When ``True``, the `value` property is ``True`` when the device's
+    /// `pin` is high. When ``False`` the `value` property is
+    /// ``True`` when the device's pin is low (i.e. the value is inverted).
+    /// Be warned that changing it will invert `value` (i.e. changing this property doesn't change
+    /// the device's pin state - it just changes how that state is interpreted).
+    pub fn active_high(&self) -> bool {
+        self.devices[0].lock().unwrap().active_high()
+        || self.devices[1].lock().unwrap().active_high()
+        || self.devices[2].lock().unwrap().active_high()
+    }
+
+    /// Set the state for active_high
+    pub fn set_active_high(&mut self, value: bool) {
+        self.devices[0].lock().unwrap().set_active_high(value);
+        self.devices[1].lock().unwrap().set_active_high(value);
+        self.devices[2].lock().unwrap().set_active_high(value);
+    }
+
+    /// The `Pin` that the device is connected to.
+    pub fn pin_red(&self) -> u8 {
+        self.devices[0].lock().unwrap().pin.pin()
+    }
+
+    /// The `Pin` that the device is connected to.
+    pub fn pin_green(&self) -> u8 {
+        self.devices[1].lock().unwrap().pin.pin()
+    }
+
+    /// The `Pin` that the device is connected to.
+    pub fn pin_blue(&self) -> u8 {
+        self.devices[2].lock().unwrap().pin.pin()
+    }
+
+    /// Shut down the device and release all associated resources.
+    pub fn close(self) {
+        drop(self)
+    }
+
+    /// Block until background process is done
+    pub fn wait(&mut self) {
+        self.handle
+            .take()
+            .expect("Called stop on non-running thread")
+            .join()
+            .expect("Could not join spawned thread");
+    }
+
+    /// Make the device turn on and off repeatedly in the background.
+    /// Use `set_blink_count` to set the number of times to blink the device
+    /// * `on_time` - Number of seconds on
+    /// * `off_time` - Number of seconds off
+    ///
+    pub fn blink(&mut self, on_time: f32, off_time: f32, on_color: Rgb, off_color: Rgb) {
+        match self.blink_count {
+            None => self.blinker(on_time, off_time, on_color, off_color, None),
+            Some(n) => self.blinker(on_time, off_time, on_color, off_color, Some(n)),
         }
     }
+
+    /// Set the number of times to blink the device
+    /// * `n` - Number of times to blink
+    pub fn set_blink_count(&mut self, n: i32) {
+        self.blink_count = Some(n)
+    }
+
+    pub fn is_lit(&self) -> bool {
+        self.is_active()
+    }
 }
 
 ///  Represents a light emitting diode (LED)