orb-ui: show car simulation

orb-ui/cone/examples/cone-simulation.rs

@@ -54,11 +54,11 @@ async fn simulation_task(cone: &mut Cone) -> eyre::Result<()> {
         let state_res = match counter {
             SimulationState::Idle => {
                 for pixel in pixels.iter_mut() {
-                    *pixel = Argb::DIAMOND_USER_IDLE;
+                    *pixel = Argb::DIAMOND_CONE_AMBER;
                 }
                 cone.lcd
                     .tx()
-                    .try_send(LcdCommand::try_from(Argb::DIAMOND_USER_IDLE)?)
+                    .try_send(LcdCommand::try_from(Argb::DIAMOND_CONE_AMBER)?)
                     .wrap_err("unable to send DIAMOND_USER_IDLE to lcd")
             }
             SimulationState::Red => {
@@ -134,7 +134,7 @@ async fn simulation_task(cone: &mut Cone) -> eyre::Result<()> {
             }
             SimulationState::QrCode => {
                 for pixel in pixels.iter_mut() {
-                    *pixel = Argb::DIAMOND_USER_AMBER;
+                    *pixel = Argb::DIAMOND_SHROUD_SUMMON_USER_AMBER;
                 }
 
                 let cmd =

orb-ui/rgb/src/lib.rs

@@ -1,5 +1,6 @@
 use serde::{Deserialize, Serialize};
 use std::ops;
+use std::ops::Add;
 
 /// RGB LED color.
 #[derive(Eq, PartialEq, Copy, Clone, Default, Debug, Serialize, Deserialize)]
@@ -15,39 +16,34 @@ impl ops::Mul<f64> for Argb {
 
     #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
     fn mul(self, rhs: f64) -> Self::Output {
-        // if intensity is led by the dimming value, use it
-        // otherwise, modify the color values
-        if let Some(dim) = self.0 {
-            Argb(
-                Some(((f64::from(dim) * rhs) as u8).clamp(0, Self::DIMMING_MAX_VALUE)),
-                self.1,
-                self.2,
-                self.3,
-            )
-        } else {
-            Argb(
-                None,
-                ((f64::from(self.1) * rhs) as u8).clamp(0, 255),
-                ((f64::from(self.2) * rhs) as u8).clamp(0, 255),
-                ((f64::from(self.3) * rhs) as u8).clamp(0, 255),
-            )
-        }
+        Argb(
+            self.0,
+            ((f64::from(self.1) * rhs) as u8).clamp(0, u8::MAX),
+            ((f64::from(self.2) * rhs) as u8).clamp(0, u8::MAX),
+            ((f64::from(self.3) * rhs) as u8).clamp(0, u8::MAX),
+        )
     }
 }
 
 impl ops::MulAssign<f64> for Argb {
     #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
     fn mul_assign(&mut self, rhs: f64) {
-        // if intensity is led by the dimming value, use it
-        // otherwise, modify the color values
-        if let Some(dim) = self.0 {
-            self.0 =
-                Some(((f64::from(dim) * rhs) as u8).clamp(0, Self::DIMMING_MAX_VALUE));
-        } else {
-            self.1 = ((f64::from(self.1) * rhs) as u8).clamp(0, 255);
-            self.2 = ((f64::from(self.2) * rhs) as u8).clamp(0, 255);
-            self.3 = ((f64::from(self.3) * rhs) as u8).clamp(0, 255);
-        };
+        self.1 = ((f64::from(self.1) * rhs) as u8).clamp(0, u8::MAX);
+        self.2 = ((f64::from(self.2) * rhs) as u8).clamp(0, u8::MAX);
+        self.3 = ((f64::from(self.3) * rhs) as u8).clamp(0, u8::MAX);
+    }
+}
+
+impl Add for Argb {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        Argb(
+            self.0,
+            self.1.saturating_add(rhs.1),
+            self.2.saturating_add(rhs.2),
+            self.3.saturating_add(rhs.3),
+        )
     }
 }
 
@@ -77,16 +73,21 @@ impl Argb {
         Argb(Some(Self::DIMMING_MAX_VALUE), 128, 128, 0);
     pub const DIAMOND_OPERATOR_VERSIONS_OUTDATED: Argb =
         Argb(Some(Self::DIMMING_MAX_VALUE), 255, 0, 0);
-    pub const DIAMOND_USER_AMBER: Argb = Argb(Some(Self::DIMMING_MAX_VALUE), 20, 16, 1);
-    #[allow(dead_code)]
-    pub const DIAMOND_USER_IDLE: Argb = Argb(Some(Self::DIMMING_MAX_VALUE), 18, 23, 18);
-    pub const DIAMOND_USER_QR_SCAN: Argb =
-        Argb(Some(Self::DIMMING_MAX_VALUE), 24, 29, 24);
-    pub const DIAMOND_USER_SIGNUP: Argb =
-        Argb(Some(Self::DIMMING_MAX_VALUE), 32, 26, 1);
-    pub const DIAMOND_USER_FLASH: Argb =
-        Argb(Some(Self::DIMMING_MAX_VALUE), 255, 255, 255);
+    /// Outer-ring color during operator QR scans
+    pub const DIAMOND_RING_OPERATOR_QR_SCAN: Argb = Argb(Some(4), 55, 10, 0);
+    pub const DIAMOND_RING_OPERATOR_QR_SCAN_SPINNER: Argb = Argb(Some(7), 80, 50, 30);
+    /// Outer-ring color during user QR scans
+    pub const DIAMOND_RING_USER_QR_SCAN: Argb = Argb(Some(4), 50, 40, 3);
+    pub const DIAMOND_RING_USER_QR_SCAN_SPINNER: Argb = Argb(Some(7), 80, 60, 40);
+    /// Shroud color to invite user to scan / reposition in front of the orb
+    pub const DIAMOND_SHROUD_SUMMON_USER_AMBER: Argb = Argb(Some(3), 95, 40, 3);
+    /// Shroud color during user scan/capture (in progress)
+    pub const DIAMOND_SHROUD_USER_CAPTURE: Argb = Argb(Some(3), 118, 51, 3);
+    /// Outer-ring color during user scan/capture (in progress)
+    pub const DIAMOND_RING_USER_CAPTURE: Argb = Argb(Some(10), 100, 80, 3);
     pub const DIAMOND_CONE_AMBER: Argb = Argb(Some(Self::DIMMING_MAX_VALUE), 25, 18, 1);
+    /// Error color for outer ring
+    pub const DIAMOND_RING_ERROR_SALMON: Argb = Argb(Some(3), 127, 20, 0);
 
     pub const FULL_RED: Argb = Argb(None, 255, 0, 0);
     pub const FULL_GREEN: Argb = Argb(None, 0, 255, 0);

orb-ui/sound/src/queue.rs

@@ -4,6 +4,7 @@ use libc::{
     c_int, c_void, fd_set, suseconds_t, time_t, timeval, EFD_CLOEXEC, FD_ISSET, FD_SET,
     FD_ZERO,
 };
+use std::ops::Add;
 use std::{
     ffi::CString,
     io,
@@ -37,6 +38,7 @@ pub struct SoundBuilder<'a> {
     reader: Option<Box<dyn Reader>>,
     cancel_all: bool,
     priority: u8,
+    delay: Option<Duration>,
     max_delay: Duration,
     volume: f64,
 }
@@ -50,6 +52,7 @@ struct Sound {
     id: u64,
     reader: Box<dyn Reader>,
     name: String,
+    start_time: Instant,
     deadline: Duration,
     volume: f64,
     state: SharedState,
@@ -118,6 +121,7 @@ impl Queue {
             reader: reader.map(|reader| Box::new(reader) as _),
             cancel_all: false,
             priority: 0,
+            delay: None,
             max_delay: Duration::MAX,
             volume: 1.0,
         }
@@ -197,6 +201,13 @@ impl SoundBuilder<'_> {
         self
     }
 
+    /// Adds delay before playing the sound.
+    #[must_use]
+    pub fn delay(mut self, delay: Option<Duration>) -> Self {
+        self.delay = delay;
+        self
+    }
+
     /// Inserts the sound to the queue returning a future that resolves when the
     /// sound has left the queue. The boolean output represents whether the
     /// sound has been played.
@@ -210,6 +221,7 @@ impl SoundBuilder<'_> {
             reader,
             cancel_all,
             priority,
+            delay,
             max_delay,
             volume,
         } = self;
@@ -229,11 +241,13 @@ impl SoundBuilder<'_> {
             .duration_since(UNIX_EPOCH)
             .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?
             .saturating_add(max_delay);
+        let start_time = Instant::now().add(delay.unwrap_or(Duration::ZERO));
         let state = Arc::new(Mutex::new(State::Pending));
         let sound = Sound {
             id,
             name,
             reader,
+            start_time,
             deadline,
             state: Arc::clone(&state),
             volume,
@@ -313,6 +327,10 @@ fn queue_loop(
             let now = SystemTime::now()
                 .duration_since(UNIX_EPOCH)
                 .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
+            if Instant::now() < sound.start_time {
+                let duration = sound.start_time.duration_since(Instant::now());
+                cancellable_sleep(duration, cancel_event)?;
+            }
             let play = now < sound.deadline;
             if play {
                 let volume = sound.volume;

orb-ui/src/dbus.rs

@@ -22,7 +22,7 @@ impl Interface {
     /// Forward events to UI engine by sending serialized engine::Event to the event channel.
     async fn orb_signup_state_event(&mut self, event: String) -> zbus::fdo::Result<()> {
         // parse event to engine::Event using json_serde
-        tracing::debug!("received JSON event: {}", event);
+        tracing::trace!("received JSON event: {}", event);
         let event: engine::Event = serde_json::from_str(&event).map_err(|e| {
             zbus::fdo::Error::InvalidArgs(format!(
                 "invalid event: failed to parse {}",

orb-ui/src/engine/animations/alert.rs

@@ -42,6 +42,8 @@ pub struct Alert<const N: usize> {
     phase: f64,
     /// first edge from pattern\[0\] to pattern\[1\] has LEDs on
     active_at_start: bool,
+    /// initial delay, in seconds, before starting the animation
+    initial_delay: f64,
 }
 
 impl<const N: usize> Alert<N> {
@@ -60,8 +62,15 @@ impl<const N: usize> Alert<N> {
             blinks,
             phase: 0.0,
             active_at_start,
+            initial_delay: 0.0,
         }
     }
+
+    #[expect(dead_code)]
+    pub fn with_delay(mut self, delay: f64) -> Self {
+        self.initial_delay = delay;
+        self
+    }
 }
 
 impl<const N: usize> Animation for Alert<N> {
@@ -84,6 +93,12 @@ impl<const N: usize> Animation for Alert<N> {
         let mut duration_acc = 0.0;
         let mut color = Argb::OFF;
 
+        // initial delay
+        if self.initial_delay > 0.0 {
+            self.initial_delay -= dt;
+            return AnimationState::Running;
+        }
+
         // sum up each edge duration and quit when the phase is in the current edge
         for (i, &edge_duration) in self.blinks.0.iter().enumerate() {
             duration_acc += edge_duration;

orb-ui/src/engine/animations/arc_dash.rs

@@ -85,7 +85,7 @@ impl<const N: usize> Animation for ArcDash<N> {
             if N == PEARL_RING_LED_COUNT {
                 current_color = Argb::PEARL_USER_FLASH;
             } else {
-                current_color = Argb::DIAMOND_USER_FLASH;
+                current_color = Argb::DIAMOND_RING_USER_CAPTURE;
             }
             *phase += dt;
             if *phase >= FLASH_ON_TIME {

orb-ui/src/engine/animations/arc_pulse.rs

@@ -60,9 +60,12 @@ impl<const N: usize> Animation for ArcPulse<N> {
         AnimationState::Running
     }
 
-    fn transition_from(&mut self, superseded: &dyn Any) {
+    fn transition_from(&mut self, superseded: &dyn Any) -> bool {
         if let Some(other) = superseded.downcast_ref::<ArcPulse<N>>() {
             self.shape = other.shape.clone();
+            true
+        } else {
+            false
         }
     }
 }

orb-ui/src/engine/animations/idle.rs

@@ -61,6 +61,4 @@ impl<const N: usize> Animation for Idle<N> {
         }
         AnimationState::Running
     }
-
-    fn transition_from(&mut self, _superseded: &dyn Any) {}
 }