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/esp32s3/src/ds/c_mem.rs

@@ -0,0 +1,28 @@
+#[doc = "Register `C_MEM[%s]` reader"]
+pub type R = crate::R<C_MEM_SPEC>;
+#[doc = "Register `C_MEM[%s]` writer"]
+pub type W = crate::W<C_MEM_SPEC>;
+#[cfg(feature = "impl-register-debug")]
+impl core::fmt::Debug for R {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "{}", self.bits())
+    }
+}
+impl W {}
+#[doc = "Memory C\n\nYou can [`read`](crate::Reg::read) this register and get [`c_mem::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`c_mem::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct C_MEM_SPEC;
+impl crate::RegisterSpec for C_MEM_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`c_mem::R`](R) reader structure"]
+impl crate::Readable for C_MEM_SPEC {}
+#[doc = "`write(|w| ..)` method takes [`c_mem::W`](W) writer structure"]
+impl crate::Writable for C_MEM_SPEC {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets C_MEM[%s] to value 0"]
+impl crate::Resettable for C_MEM_SPEC {
+    const RESET_VALUE: u32 = 0;
+}

vendor/esp32s3/src/ds/date.rs

@@ -0,0 +1,45 @@
+#[doc = "Register `DATE` reader"]
+pub type R = crate::R<DATE_SPEC>;
+#[doc = "Register `DATE` writer"]
+pub type W = crate::W<DATE_SPEC>;
+#[doc = "Field `DATE` reader - ds version information"]
+pub type DATE_R = crate::FieldReader<u32>;
+#[doc = "Field `DATE` writer - ds version information"]
+pub type DATE_W<'a, REG> = crate::FieldWriter<'a, REG, 30, u32>;
+impl R {
+    #[doc = "Bits 0:29 - ds version information"]
+    #[inline(always)]
+    pub fn date(&self) -> DATE_R {
+        DATE_R::new(self.bits & 0x3fff_ffff)
+    }
+}
+#[cfg(feature = "impl-register-debug")]
+impl core::fmt::Debug for R {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        f.debug_struct("DATE").field("date", &self.date()).finish()
+    }
+}
+impl W {
+    #[doc = "Bits 0:29 - ds version information"]
+    #[inline(always)]
+    pub fn date(&mut self) -> DATE_W<DATE_SPEC> {
+        DATE_W::new(self, 0)
+    }
+}
+#[doc = "DS version control register\n\nYou can [`read`](crate::Reg::read) this register and get [`date::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`date::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct DATE_SPEC;
+impl crate::RegisterSpec for DATE_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`date::R`](R) reader structure"]
+impl crate::Readable for DATE_SPEC {}
+#[doc = "`write(|w| ..)` method takes [`date::W`](W) writer structure"]
+impl crate::Writable for DATE_SPEC {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets DATE to value 0x2019_1217"]
+impl crate::Resettable for DATE_SPEC {
+    const RESET_VALUE: u32 = 0x2019_1217;
+}

vendor/esp32s3/src/ds/iv_.rs

@@ -0,0 +1,45 @@
+#[doc = "Register `IV_%s` reader"]
+pub type R = crate::R<IV__SPEC>;
+#[doc = "Register `IV_%s` writer"]
+pub type W = crate::W<IV__SPEC>;
+#[doc = "Field `IV` reader - Stores IV block data"]
+pub type IV_R = crate::FieldReader<u32>;
+#[doc = "Field `IV` writer - Stores IV block data"]
+pub type IV_W<'a, REG> = crate::FieldWriter<'a, REG, 32, u32>;
+impl R {
+    #[doc = "Bits 0:31 - Stores IV block data"]
+    #[inline(always)]
+    pub fn iv(&self) -> IV_R {
+        IV_R::new(self.bits)
+    }
+}
+#[cfg(feature = "impl-register-debug")]
+impl core::fmt::Debug for R {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        f.debug_struct("IV_").field("iv", &self.iv()).finish()
+    }
+}
+impl W {
+    #[doc = "Bits 0:31 - Stores IV block data"]
+    #[inline(always)]
+    pub fn iv(&mut self) -> IV_W<IV__SPEC> {
+        IV_W::new(self, 0)
+    }
+}
+#[doc = "IV block data\n\nYou can [`read`](crate::Reg::read) this register and get [`iv_::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`iv_::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct IV__SPEC;
+impl crate::RegisterSpec for IV__SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`iv_::R`](R) reader structure"]
+impl crate::Readable for IV__SPEC {}
+#[doc = "`write(|w| ..)` method takes [`iv_::W`](W) writer structure"]
+impl crate::Writable for IV__SPEC {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets IV_%s to value 0"]
+impl crate::Resettable for IV__SPEC {
+    const RESET_VALUE: u32 = 0;
+}

vendor/esp32s3/src/ds/query_busy.rs

@@ -0,0 +1,30 @@
+#[doc = "Register `QUERY_BUSY` reader"]
+pub type R = crate::R<QUERY_BUSY_SPEC>;
+#[doc = "Field `QUERY_BUSY` reader - Stores the status of the DS peripheral. 1: The DS peripheral is busy. 0: The DS peripheral is idle."]
+pub type QUERY_BUSY_R = crate::BitReader;
+impl R {
+    #[doc = "Bit 0 - Stores the status of the DS peripheral. 1: The DS peripheral is busy. 0: The DS peripheral is idle."]
+    #[inline(always)]
+    pub fn query_busy(&self) -> QUERY_BUSY_R {
+        QUERY_BUSY_R::new((self.bits & 1) != 0)
+    }
+}
+#[cfg(feature = "impl-register-debug")]
+impl core::fmt::Debug for R {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        f.debug_struct("QUERY_BUSY")
+            .field("query_busy", &self.query_busy())
+            .finish()
+    }
+}
+#[doc = "Status of the DS perihperal\n\nYou can [`read`](crate::Reg::read) this register and get [`query_busy::R`](R). See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct QUERY_BUSY_SPEC;
+impl crate::RegisterSpec for QUERY_BUSY_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`query_busy::R`](R) reader structure"]
+impl crate::Readable for QUERY_BUSY_SPEC {}
+#[doc = "`reset()` method sets QUERY_BUSY to value 0"]
+impl crate::Resettable for QUERY_BUSY_SPEC {
+    const RESET_VALUE: u32 = 0;
+}

vendor/esp32s3/src/ds/query_check.rs

@@ -0,0 +1,38 @@
+#[doc = "Register `QUERY_CHECK` reader"]
+pub type R = crate::R<QUERY_CHECK_SPEC>;
+#[doc = "Field `MD_ERROR` reader - MD checkout result. 1: The MD check fails. 0: The MD check passes."]
+pub type MD_ERROR_R = crate::BitReader;
+#[doc = "Field `PADDING_BAD` reader - padding checkout result. 1: The padding check fails. 0: The padding check passes."]
+pub type PADDING_BAD_R = crate::BitReader;
+impl R {
+    #[doc = "Bit 0 - MD checkout result. 1: The MD check fails. 0: The MD check passes."]
+    #[inline(always)]
+    pub fn md_error(&self) -> MD_ERROR_R {
+        MD_ERROR_R::new((self.bits & 1) != 0)
+    }
+    #[doc = "Bit 1 - padding checkout result. 1: The padding check fails. 0: The padding check passes."]
+    #[inline(always)]
+    pub fn padding_bad(&self) -> PADDING_BAD_R {
+        PADDING_BAD_R::new(((self.bits >> 1) & 1) != 0)
+    }
+}
+#[cfg(feature = "impl-register-debug")]
+impl core::fmt::Debug for R {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        f.debug_struct("QUERY_CHECK")
+            .field("md_error", &self.md_error())
+            .field("padding_bad", &self.padding_bad())
+            .finish()
+    }
+}
+#[doc = "Queries DS check result\n\nYou can [`read`](crate::Reg::read) this register and get [`query_check::R`](R). See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct QUERY_CHECK_SPEC;
+impl crate::RegisterSpec for QUERY_CHECK_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`query_check::R`](R) reader structure"]
+impl crate::Readable for QUERY_CHECK_SPEC {}
+#[doc = "`reset()` method sets QUERY_CHECK to value 0"]
+impl crate::Resettable for QUERY_CHECK_SPEC {
+    const RESET_VALUE: u32 = 0;
+}

vendor/esp32s3/src/ds/query_key_wrong.rs

@@ -0,0 +1,30 @@
+#[doc = "Register `QUERY_KEY_WRONG` reader"]
+pub type R = crate::R<QUERY_KEY_WRONG_SPEC>;
+#[doc = "Field `QUERY_KEY_WRONG` reader - 1-15: HMAC was activated, but the DS peripheral did not successfully receive the DS_KEY from the HMAC peripheral. (The biggest value is 15). 0: HMAC is not activated."]
+pub type QUERY_KEY_WRONG_R = crate::FieldReader;
+impl R {
+    #[doc = "Bits 0:3 - 1-15: HMAC was activated, but the DS peripheral did not successfully receive the DS_KEY from the HMAC peripheral. (The biggest value is 15). 0: HMAC is not activated."]
+    #[inline(always)]
+    pub fn query_key_wrong(&self) -> QUERY_KEY_WRONG_R {
+        QUERY_KEY_WRONG_R::new((self.bits & 0x0f) as u8)
+    }
+}
+#[cfg(feature = "impl-register-debug")]
+impl core::fmt::Debug for R {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        f.debug_struct("QUERY_KEY_WRONG")
+            .field("query_key_wrong", &self.query_key_wrong())
+            .finish()
+    }
+}
+#[doc = "Checks the reason why DS_KEY is not ready\n\nYou can [`read`](crate::Reg::read) this register and get [`query_key_wrong::R`](R). See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct QUERY_KEY_WRONG_SPEC;
+impl crate::RegisterSpec for QUERY_KEY_WRONG_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`query_key_wrong::R`](R) reader structure"]
+impl crate::Readable for QUERY_KEY_WRONG_SPEC {}
+#[doc = "`reset()` method sets QUERY_KEY_WRONG to value 0"]
+impl crate::Resettable for QUERY_KEY_WRONG_SPEC {
+    const RESET_VALUE: u32 = 0;
+}

vendor/esp32s3/src/ds/set_finish.rs

@@ -0,0 +1,32 @@
+#[doc = "Register `SET_FINISH` writer"]
+pub type W = crate::W<SET_FINISH_SPEC>;
+#[doc = "Field `SET_FINISH` writer - Write 1 to this register to end DS operation."]
+pub type SET_FINISH_W<'a, REG> = crate::BitWriter<'a, REG>;
+#[cfg(feature = "impl-register-debug")]
+impl core::fmt::Debug for crate::generic::Reg<SET_FINISH_SPEC> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "(not readable)")
+    }
+}
+impl W {
+    #[doc = "Bit 0 - Write 1 to this register to end DS operation."]
+    #[inline(always)]
+    pub fn set_finish(&mut self) -> SET_FINISH_W<SET_FINISH_SPEC> {
+        SET_FINISH_W::new(self, 0)
+    }
+}
+#[doc = "Ends DS operation\n\nYou can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`set_finish::W`](W). See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct SET_FINISH_SPEC;
+impl crate::RegisterSpec for SET_FINISH_SPEC {
+    type Ux = u32;
+}
+#[doc = "`write(|w| ..)` method takes [`set_finish::W`](W) writer structure"]
+impl crate::Writable for SET_FINISH_SPEC {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets SET_FINISH to value 0"]
+impl crate::Resettable for SET_FINISH_SPEC {
+    const RESET_VALUE: u32 = 0;
+}

vendor/esp32s3/src/ds/set_me.rs

@@ -0,0 +1,32 @@
+#[doc = "Register `SET_ME` writer"]
+pub type W = crate::W<SET_ME_SPEC>;
+#[doc = "Field `SET_ME` writer - Write 1 to this register to start DS operation."]
+pub type SET_ME_W<'a, REG> = crate::BitWriter<'a, REG>;
+#[cfg(feature = "impl-register-debug")]
+impl core::fmt::Debug for crate::generic::Reg<SET_ME_SPEC> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "(not readable)")
+    }
+}
+impl W {
+    #[doc = "Bit 0 - Write 1 to this register to start DS operation."]
+    #[inline(always)]
+    pub fn set_me(&mut self) -> SET_ME_W<SET_ME_SPEC> {
+        SET_ME_W::new(self, 0)
+    }
+}
+#[doc = "Starts DS operation\n\nYou can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`set_me::W`](W). See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct SET_ME_SPEC;
+impl crate::RegisterSpec for SET_ME_SPEC {
+    type Ux = u32;
+}
+#[doc = "`write(|w| ..)` method takes [`set_me::W`](W) writer structure"]
+impl crate::Writable for SET_ME_SPEC {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets SET_ME to value 0"]
+impl crate::Resettable for SET_ME_SPEC {
+    const RESET_VALUE: u32 = 0;
+}

vendor/esp32s3/src/ds/set_start.rs

@@ -0,0 +1,32 @@
+#[doc = "Register `SET_START` writer"]
+pub type W = crate::W<SET_START_SPEC>;
+#[doc = "Field `SET_START` writer - Write 1 to this register to active the DS peripheral"]
+pub type SET_START_W<'a, REG> = crate::BitWriter<'a, REG>;
+#[cfg(feature = "impl-register-debug")]
+impl core::fmt::Debug for crate::generic::Reg<SET_START_SPEC> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "(not readable)")
+    }
+}
+impl W {
+    #[doc = "Bit 0 - Write 1 to this register to active the DS peripheral"]
+    #[inline(always)]
+    pub fn set_start(&mut self) -> SET_START_W<SET_START_SPEC> {
+        SET_START_W::new(self, 0)
+    }
+}
+#[doc = "Activates the DS peripheral\n\nYou can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`set_start::W`](W). See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct SET_START_SPEC;
+impl crate::RegisterSpec for SET_START_SPEC {
+    type Ux = u32;
+}
+#[doc = "`write(|w| ..)` method takes [`set_start::W`](W) writer structure"]
+impl crate::Writable for SET_START_SPEC {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets SET_START to value 0"]
+impl crate::Resettable for SET_START_SPEC {
+    const RESET_VALUE: u32 = 0;
+}

vendor/esp32s3/src/ds/x_mem.rs

@@ -0,0 +1,28 @@
+#[doc = "Register `X_MEM[%s]` reader"]
+pub type R = crate::R<X_MEM_SPEC>;
+#[doc = "Register `X_MEM[%s]` writer"]
+pub type W = crate::W<X_MEM_SPEC>;
+#[cfg(feature = "impl-register-debug")]
+impl core::fmt::Debug for R {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "{}", self.bits())
+    }
+}
+impl W {}
+#[doc = "Memory X\n\nYou can [`read`](crate::Reg::read) this register and get [`x_mem::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`x_mem::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct X_MEM_SPEC;
+impl crate::RegisterSpec for X_MEM_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`x_mem::R`](R) reader structure"]
+impl crate::Readable for X_MEM_SPEC {}
+#[doc = "`write(|w| ..)` method takes [`x_mem::W`](W) writer structure"]
+impl crate::Writable for X_MEM_SPEC {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets X_MEM[%s] to value 0"]
+impl crate::Resettable for X_MEM_SPEC {
+    const RESET_VALUE: u32 = 0;
+}

vendor/esp32s3/src/ds/z_mem.rs

@@ -0,0 +1,28 @@
+#[doc = "Register `Z_MEM[%s]` reader"]
+pub type R = crate::R<Z_MEM_SPEC>;
+#[doc = "Register `Z_MEM[%s]` writer"]
+pub type W = crate::W<Z_MEM_SPEC>;
+#[cfg(feature = "impl-register-debug")]
+impl core::fmt::Debug for R {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "{}", self.bits())
+    }
+}
+impl W {}
+#[doc = "Memory Z\n\nYou can [`read`](crate::Reg::read) this register and get [`z_mem::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`z_mem::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
+pub struct Z_MEM_SPEC;
+impl crate::RegisterSpec for Z_MEM_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [`z_mem::R`](R) reader structure"]
+impl crate::Readable for Z_MEM_SPEC {}
+#[doc = "`write(|w| ..)` method takes [`z_mem::W`](W) writer structure"]
+impl crate::Writable for Z_MEM_SPEC {
+    type Safety = crate::Unsafe;
+    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
+}
+#[doc = "`reset()` method sets Z_MEM[%s] to value 0"]
+impl crate::Resettable for Z_MEM_SPEC {
+    const RESET_VALUE: u32 = 0;
+}