feat: add display UI with splash screen, dashboard, and RSSI sparkline

Implement full SSD1306 OLED display support:
- Splash screen on boot (1.5s) with project name, version, board
- Dashboard showing radio state, config, counters, RSSI/SNR
- RSSI history sparkline (64-sample ring buffer, 2px-wide bars)
- DisplayOn/DisplayOff host commands routed via dedicated channel
- Pure render functions against generic DrawTarget (no hardware coupling)
- Display on/off control bypasses radio task entirely

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

vendor/embassy-executor/tests/test.rs

@@ -0,0 +1,151 @@
+#![cfg_attr(feature = "nightly", feature(impl_trait_in_assoc_type))]
+
+use std::boxed::Box;
+use std::future::poll_fn;
+use std::sync::{Arc, Mutex};
+use std::task::Poll;
+
+use embassy_executor::raw::Executor;
+use embassy_executor::task;
+
+#[export_name = "__pender"]
+fn __pender(context: *mut ()) {
+    unsafe {
+        let trace = &*(context as *const Trace);
+        trace.push("pend");
+    }
+}
+
+#[derive(Clone)]
+struct Trace {
+    trace: Arc<Mutex<Vec<&'static str>>>,
+}
+
+impl Trace {
+    fn new() -> Self {
+        Self {
+            trace: Arc::new(Mutex::new(Vec::new())),
+        }
+    }
+    fn push(&self, value: &'static str) {
+        self.trace.lock().unwrap().push(value)
+    }
+
+    fn get(&self) -> Vec<&'static str> {
+        self.trace.lock().unwrap().clone()
+    }
+}
+
+fn setup() -> (&'static Executor, Trace) {
+    let trace = Trace::new();
+    let context = Box::leak(Box::new(trace.clone())) as *mut _ as *mut ();
+    let executor = &*Box::leak(Box::new(Executor::new(context)));
+    (executor, trace)
+}
+
+#[test]
+fn executor_noop() {
+    let (executor, trace) = setup();
+    unsafe { executor.poll() };
+    assert!(trace.get().is_empty())
+}
+
+#[test]
+fn executor_task() {
+    #[task]
+    async fn task1(trace: Trace) {
+        trace.push("poll task1")
+    }
+
+    let (executor, trace) = setup();
+    executor.spawner().spawn(task1(trace.clone())).unwrap();
+
+    unsafe { executor.poll() };
+    unsafe { executor.poll() };
+
+    assert_eq!(
+        trace.get(),
+        &[
+            "pend",       // spawning a task pends the executor
+            "poll task1", // poll only once.
+        ]
+    )
+}
+
+#[test]
+fn executor_task_self_wake() {
+    #[task]
+    async fn task1(trace: Trace) {
+        poll_fn(|cx| {
+            trace.push("poll task1");
+            cx.waker().wake_by_ref();
+            Poll::Pending
+        })
+        .await
+    }
+
+    let (executor, trace) = setup();
+    executor.spawner().spawn(task1(trace.clone())).unwrap();
+
+    unsafe { executor.poll() };
+    unsafe { executor.poll() };
+
+    assert_eq!(
+        trace.get(),
+        &[
+            "pend",       // spawning a task pends the executor
+            "poll task1", //
+            "pend",       // task self-wakes
+            "poll task1", //
+            "pend",       // task self-wakes
+        ]
+    )
+}
+
+#[test]
+fn executor_task_self_wake_twice() {
+    #[task]
+    async fn task1(trace: Trace) {
+        poll_fn(|cx| {
+            trace.push("poll task1");
+            cx.waker().wake_by_ref();
+            trace.push("poll task1 wake 2");
+            cx.waker().wake_by_ref();
+            Poll::Pending
+        })
+        .await
+    }
+
+    let (executor, trace) = setup();
+    executor.spawner().spawn(task1(trace.clone())).unwrap();
+
+    unsafe { executor.poll() };
+    unsafe { executor.poll() };
+
+    assert_eq!(
+        trace.get(),
+        &[
+            "pend",              // spawning a task pends the executor
+            "poll task1",        //
+            "pend",              // task self-wakes
+            "poll task1 wake 2", // task self-wakes again, shouldn't pend
+            "poll task1",        //
+            "pend",              // task self-wakes
+            "poll task1 wake 2", // task self-wakes again, shouldn't pend
+        ]
+    )
+}
+
+#[test]
+fn executor_task_cfg_args() {
+    // simulate cfg'ing away argument c
+    #[task]
+    async fn task1(a: u32, b: u32, #[cfg(any())] c: u32) {
+        let (_, _) = (a, b);
+    }
+
+    #[task]
+    async fn task2(a: u32, b: u32, #[cfg(all())] c: u32) {
+        let (_, _, _) = (a, b, c);
+    }
+}

vendor/embassy-executor/tests/ui.rs

@@ -0,0 +1,23 @@
+#[cfg(not(miri))]
+#[test]
+fn ui() {
+    let t = trybuild::TestCases::new();
+    t.compile_fail("tests/ui/abi.rs");
+    t.compile_fail("tests/ui/bad_return.rs");
+    t.compile_fail("tests/ui/generics.rs");
+    t.compile_fail("tests/ui/impl_trait_nested.rs");
+    t.compile_fail("tests/ui/impl_trait.rs");
+    t.compile_fail("tests/ui/impl_trait_static.rs");
+    t.compile_fail("tests/ui/nonstatic_ref_anon_nested.rs");
+    t.compile_fail("tests/ui/nonstatic_ref_anon.rs");
+    t.compile_fail("tests/ui/nonstatic_ref_elided.rs");
+    t.compile_fail("tests/ui/nonstatic_ref_generic.rs");
+    t.compile_fail("tests/ui/nonstatic_struct_anon.rs");
+    #[cfg(not(feature = "nightly"))] // we can't catch this case with the macro, so the output changes on nightly.
+    t.compile_fail("tests/ui/nonstatic_struct_elided.rs");
+    t.compile_fail("tests/ui/nonstatic_struct_generic.rs");
+    t.compile_fail("tests/ui/not_async.rs");
+    t.compile_fail("tests/ui/self_ref.rs");
+    t.compile_fail("tests/ui/self.rs");
+    t.compile_fail("tests/ui/where_clause.rs");
+}

vendor/embassy-executor/tests/ui/abi.rs

@@ -0,0 +1,8 @@
+#![cfg_attr(feature = "nightly", feature(impl_trait_in_assoc_type))]
+
+struct Foo<'a>(&'a ());
+
+#[embassy_executor::task]
+async extern "C" fn task() {}
+
+fn main() {}

vendor/embassy-executor/tests/ui/abi.stderr

@@ -0,0 +1,5 @@
+error: task functions must not have an ABI qualifier
+ --> tests/ui/abi.rs:6:1
+  |
+6 | async extern "C" fn task() {}
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^^

vendor/embassy-executor/tests/ui/bad_return.rs

@@ -0,0 +1,10 @@
+#![cfg_attr(feature = "nightly", feature(impl_trait_in_assoc_type))]
+
+struct Foo<'a>(&'a ());
+
+#[embassy_executor::task]
+async fn task() -> u32 {
+    5
+}
+
+fn main() {}

vendor/embassy-executor/tests/ui/bad_return.stderr

@@ -0,0 +1,5 @@
+error: task functions must either not return a value, return `()` or return `!`
+ --> tests/ui/bad_return.rs:6:1
+  |
+6 | async fn task() -> u32 {
+  | ^^^^^^^^^^^^^^^^^^^^^^

vendor/embassy-executor/tests/ui/generics.rs

@@ -0,0 +1,8 @@
+#![cfg_attr(feature = "nightly", feature(impl_trait_in_assoc_type))]
+
+struct Foo<'a>(&'a ());
+
+#[embassy_executor::task]
+async fn task<T: Sized>(_t: T) {}
+
+fn main() {}

vendor/embassy-executor/tests/ui/generics.stderr

@@ -0,0 +1,5 @@
+error: task functions must not be generic
+ --> tests/ui/generics.rs:6:1
+  |
+6 | async fn task<T: Sized>(_t: T) {}
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

vendor/embassy-executor/tests/ui/impl_trait.rs

@@ -0,0 +1,6 @@
+#![cfg_attr(feature = "nightly", feature(impl_trait_in_assoc_type))]
+
+#[embassy_executor::task]
+async fn foo(_x: impl Sized) {}
+
+fn main() {}

vendor/embassy-executor/tests/ui/impl_trait.stderr

@@ -0,0 +1,5 @@
+error: `impl Trait` is not allowed in task arguments. It is syntax sugar for generics, and tasks can't be generic.
+ --> tests/ui/impl_trait.rs:4:18
+  |
+4 | async fn foo(_x: impl Sized) {}
+  |                  ^^^^^^^^^^

vendor/embassy-executor/tests/ui/impl_trait_nested.rs

@@ -0,0 +1,8 @@
+#![cfg_attr(feature = "nightly", feature(impl_trait_in_assoc_type))]
+
+struct Foo<T>(T);
+
+#[embassy_executor::task]
+async fn foo(_x: Foo<impl Sized + 'static>) {}
+
+fn main() {}

vendor/embassy-executor/tests/ui/impl_trait_nested.stderr

@@ -0,0 +1,5 @@
+error: `impl Trait` is not allowed in task arguments. It is syntax sugar for generics, and tasks can't be generic.
+ --> tests/ui/impl_trait_nested.rs:6:22
+  |
+6 | async fn foo(_x: Foo<impl Sized + 'static>) {}
+  |                      ^^^^^^^^^^^^^^^^^^^^

vendor/embassy-executor/tests/ui/impl_trait_static.rs

@@ -0,0 +1,6 @@
+#![cfg_attr(feature = "nightly", feature(impl_trait_in_assoc_type))]
+
+#[embassy_executor::task]
+async fn foo(_x: impl Sized + 'static) {}
+
+fn main() {}

vendor/embassy-executor/tests/ui/impl_trait_static.stderr

@@ -0,0 +1,5 @@
+error: `impl Trait` is not allowed in task arguments. It is syntax sugar for generics, and tasks can't be generic.
+ --> tests/ui/impl_trait_static.rs:4:18
+  |
+4 | async fn foo(_x: impl Sized + 'static) {}
+  |                  ^^^^^^^^^^^^^^^^^^^^

vendor/embassy-executor/tests/ui/nonstatic_ref_anon.rs

@@ -0,0 +1,6 @@
+#![cfg_attr(feature = "nightly", feature(impl_trait_in_assoc_type))]
+
+#[embassy_executor::task]
+async fn foo(_x: &'_ u32) {}
+
+fn main() {}

vendor/embassy-executor/tests/ui/nonstatic_ref_anon.stderr

@@ -0,0 +1,5 @@
+error: Arguments for tasks must live forever. Try using the `'static` lifetime.
+ --> tests/ui/nonstatic_ref_anon.rs:4:19
+  |
+4 | async fn foo(_x: &'_ u32) {}
+  |                   ^^

vendor/embassy-executor/tests/ui/nonstatic_ref_anon_nested.rs

@@ -0,0 +1,6 @@
+#![cfg_attr(feature = "nightly", feature(impl_trait_in_assoc_type))]
+
+#[embassy_executor::task]
+async fn foo(_x: &'static &'_ u32) {}
+
+fn main() {}

vendor/embassy-executor/tests/ui/nonstatic_ref_anon_nested.stderr

@@ -0,0 +1,5 @@
+error: Arguments for tasks must live forever. Try using the `'static` lifetime.
+ --> tests/ui/nonstatic_ref_anon_nested.rs:4:28
+  |
+4 | async fn foo(_x: &'static &'_ u32) {}
+  |                            ^^

vendor/embassy-executor/tests/ui/nonstatic_ref_elided.rs

@@ -0,0 +1,6 @@
+#![cfg_attr(feature = "nightly", feature(impl_trait_in_assoc_type))]
+
+#[embassy_executor::task]
+async fn foo(_x: &u32) {}
+
+fn main() {}

vendor/embassy-executor/tests/ui/nonstatic_ref_elided.stderr

@@ -0,0 +1,5 @@
+error: Arguments for tasks must live forever. Try using the `'static` lifetime.
+ --> tests/ui/nonstatic_ref_elided.rs:4:18
+  |
+4 | async fn foo(_x: &u32) {}
+  |                  ^

vendor/embassy-executor/tests/ui/nonstatic_ref_generic.rs

@@ -0,0 +1,6 @@
+#![cfg_attr(feature = "nightly", feature(impl_trait_in_assoc_type))]
+
+#[embassy_executor::task]
+async fn foo<'a>(_x: &'a u32) {}
+
+fn main() {}

vendor/embassy-executor/tests/ui/nonstatic_ref_generic.stderr

@@ -0,0 +1,11 @@
+error: task functions must not be generic
+ --> tests/ui/nonstatic_ref_generic.rs:4:1
+  |
+4 | async fn foo<'a>(_x: &'a u32) {}
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: Arguments for tasks must live forever. Try using the `'static` lifetime.
+ --> tests/ui/nonstatic_ref_generic.rs:4:23
+  |
+4 | async fn foo<'a>(_x: &'a u32) {}
+  |                       ^^

vendor/embassy-executor/tests/ui/nonstatic_struct_anon.rs

@@ -0,0 +1,8 @@
+#![cfg_attr(feature = "nightly", feature(impl_trait_in_assoc_type))]
+
+struct Foo<'a>(&'a ());
+
+#[embassy_executor::task]
+async fn task(_x: Foo<'_>) {}
+
+fn main() {}

vendor/embassy-executor/tests/ui/nonstatic_struct_anon.stderr

@@ -0,0 +1,5 @@
+error: Arguments for tasks must live forever. Try using the `'static` lifetime.
+ --> tests/ui/nonstatic_struct_anon.rs:6:23
+  |
+6 | async fn task(_x: Foo<'_>) {}
+  |                       ^^

vendor/embassy-executor/tests/ui/nonstatic_struct_elided.rs

@@ -0,0 +1,8 @@
+#![cfg_attr(feature = "nightly", feature(impl_trait_in_assoc_type))]
+
+struct Foo<'a>(&'a ());
+
+#[embassy_executor::task]
+async fn task(_x: Foo) {}
+
+fn main() {}

vendor/embassy-executor/tests/ui/nonstatic_struct_elided.stderr

@@ -0,0 +1,10 @@
+error[E0726]: implicit elided lifetime not allowed here
+ --> tests/ui/nonstatic_struct_elided.rs:6:19
+  |
+6 | async fn task(_x: Foo) {}
+  |                   ^^^ expected lifetime parameter
+  |
+help: indicate the anonymous lifetime
+  |
+6 | async fn task(_x: Foo<'_>) {}
+  |                      ++++

vendor/embassy-executor/tests/ui/nonstatic_struct_generic.rs

@@ -0,0 +1,8 @@
+#![cfg_attr(feature = "nightly", feature(impl_trait_in_assoc_type))]
+
+struct Foo<'a>(&'a ());
+
+#[embassy_executor::task]
+async fn task<'a>(_x: Foo<'a>) {}
+
+fn main() {}

vendor/embassy-executor/tests/ui/nonstatic_struct_generic.stderr

@@ -0,0 +1,11 @@
+error: task functions must not be generic
+ --> tests/ui/nonstatic_struct_generic.rs:6:1
+  |
+6 | async fn task<'a>(_x: Foo<'a>) {}
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: Arguments for tasks must live forever. Try using the `'static` lifetime.
+ --> tests/ui/nonstatic_struct_generic.rs:6:27
+  |
+6 | async fn task<'a>(_x: Foo<'a>) {}
+  |                           ^^

vendor/embassy-executor/tests/ui/not_async.rs

@@ -0,0 +1,8 @@
+#![cfg_attr(feature = "nightly", feature(impl_trait_in_assoc_type))]
+
+struct Foo<'a>(&'a ());
+
+#[embassy_executor::task]
+fn task() {}
+
+fn main() {}

vendor/embassy-executor/tests/ui/not_async.stderr

@@ -0,0 +1,5 @@
+error: task functions must be async
+ --> tests/ui/not_async.rs:6:1
+  |
+6 | fn task() {}
+  | ^^^^^^^^^

vendor/embassy-executor/tests/ui/self.rs

@@ -0,0 +1,8 @@
+#![cfg_attr(feature = "nightly", feature(impl_trait_in_assoc_type))]
+
+struct Foo<'a>(&'a ());
+
+#[embassy_executor::task]
+async fn task(self) {}
+
+fn main() {}

vendor/embassy-executor/tests/ui/self.stderr

@@ -0,0 +1,13 @@
+error: task functions must not have `self` arguments
+ --> tests/ui/self.rs:6:15
+  |
+6 | async fn task(self) {}
+  |               ^^^^
+
+error: `self` parameter is only allowed in associated functions
+ --> tests/ui/self.rs:6:15
+  |
+6 | async fn task(self) {}
+  |               ^^^^ not semantically valid as function parameter
+  |
+  = note: associated functions are those in `impl` or `trait` definitions

vendor/embassy-executor/tests/ui/self_ref.rs

@@ -0,0 +1,8 @@
+#![cfg_attr(feature = "nightly", feature(impl_trait_in_assoc_type))]
+
+struct Foo<'a>(&'a ());
+
+#[embassy_executor::task]
+async fn task(&mut self) {}
+
+fn main() {}

vendor/embassy-executor/tests/ui/self_ref.stderr

@@ -0,0 +1,13 @@
+error: task functions must not have `self` arguments
+ --> tests/ui/self_ref.rs:6:15
+  |
+6 | async fn task(&mut self) {}
+  |               ^^^^^^^^^
+
+error: `self` parameter is only allowed in associated functions
+ --> tests/ui/self_ref.rs:6:15
+  |
+6 | async fn task(&mut self) {}
+  |               ^^^^^^^^^ not semantically valid as function parameter
+  |
+  = note: associated functions are those in `impl` or `trait` definitions

vendor/embassy-executor/tests/ui/where_clause.rs

@@ -0,0 +1,12 @@
+#![cfg_attr(feature = "nightly", feature(impl_trait_in_assoc_type))]
+
+struct Foo<'a>(&'a ());
+
+#[embassy_executor::task]
+async fn task()
+where
+    (): Sized,
+{
+}
+
+fn main() {}

vendor/embassy-executor/tests/ui/where_clause.stderr

@@ -0,0 +1,7 @@
+error: task functions must not have `where` clauses
+ --> tests/ui/where_clause.rs:6:1
+  |
+6 | / async fn task()
+7 | | where
+8 | |     (): Sized,
+  | |______________^