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/nrf52810-pac/src/ficr/codepagesize.rs

@@ -0,0 +1,40 @@
+#[doc = "Register `CODEPAGESIZE` reader"]
+pub struct R(crate::R<CODEPAGESIZE_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<CODEPAGESIZE_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<CODEPAGESIZE_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<CODEPAGESIZE_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `CODEPAGESIZE` reader - Code memory page size"]
+pub type CODEPAGESIZE_R = crate::FieldReader<u32, u32>;
+impl R {
+    #[doc = "Bits 0:31 - Code memory page size"]
+    #[inline(always)]
+    pub fn codepagesize(&self) -> CODEPAGESIZE_R {
+        CODEPAGESIZE_R::new(self.bits)
+    }
+}
+#[doc = "Code memory page size\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [codepagesize](index.html) module"]
+pub struct CODEPAGESIZE_SPEC;
+impl crate::RegisterSpec for CODEPAGESIZE_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [codepagesize::R](R) reader structure"]
+impl crate::Readable for CODEPAGESIZE_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets CODEPAGESIZE to value 0x1000"]
+impl crate::Resettable for CODEPAGESIZE_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0x1000
+    }
+}

vendor/nrf52810-pac/src/ficr/codesize.rs

@@ -0,0 +1,40 @@
+#[doc = "Register `CODESIZE` reader"]
+pub struct R(crate::R<CODESIZE_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<CODESIZE_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<CODESIZE_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<CODESIZE_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `CODESIZE` reader - Code memory size in number of pages"]
+pub type CODESIZE_R = crate::FieldReader<u32, u32>;
+impl R {
+    #[doc = "Bits 0:31 - Code memory size in number of pages"]
+    #[inline(always)]
+    pub fn codesize(&self) -> CODESIZE_R {
+        CODESIZE_R::new(self.bits)
+    }
+}
+#[doc = "Code memory size\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [codesize](index.html) module"]
+pub struct CODESIZE_SPEC;
+impl crate::RegisterSpec for CODESIZE_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [codesize::R](R) reader structure"]
+impl crate::Readable for CODESIZE_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets CODESIZE to value 0x30"]
+impl crate::Resettable for CODESIZE_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0x30
+    }
+}

vendor/nrf52810-pac/src/ficr/deviceaddr.rs

@@ -0,0 +1,41 @@
+#[doc = "Register `DEVICEADDR[%s]` reader"]
+pub struct R(crate::R<DEVICEADDR_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<DEVICEADDR_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<DEVICEADDR_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<DEVICEADDR_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `DEVICEADDR` reader - 48 bit device address"]
+pub type DEVICEADDR_R = crate::FieldReader<u32, u32>;
+impl R {
+    #[doc = "Bits 0:31 - 48 bit device address"]
+    #[inline(always)]
+    pub fn deviceaddr(&self) -> DEVICEADDR_R {
+        DEVICEADDR_R::new(self.bits)
+    }
+}
+#[doc = "Description collection: Device address n\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [deviceaddr](index.html) module"]
+pub struct DEVICEADDR_SPEC;
+impl crate::RegisterSpec for DEVICEADDR_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [deviceaddr::R](R) reader structure"]
+impl crate::Readable for DEVICEADDR_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets DEVICEADDR[%s]
+to value 0xffff_ffff"]
+impl crate::Resettable for DEVICEADDR_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0xffff_ffff
+    }
+}

vendor/nrf52810-pac/src/ficr/deviceaddrtype.rs

@@ -0,0 +1,74 @@
+#[doc = "Register `DEVICEADDRTYPE` reader"]
+pub struct R(crate::R<DEVICEADDRTYPE_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<DEVICEADDRTYPE_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<DEVICEADDRTYPE_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<DEVICEADDRTYPE_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `DEVICEADDRTYPE` reader - Device address type"]
+pub type DEVICEADDRTYPE_R = crate::BitReader<DEVICEADDRTYPE_A>;
+#[doc = "Device address type\n\nValue on reset: 1"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum DEVICEADDRTYPE_A {
+    #[doc = "0: Public address"]
+    PUBLIC = 0,
+    #[doc = "1: Random address"]
+    RANDOM = 1,
+}
+impl From<DEVICEADDRTYPE_A> for bool {
+    #[inline(always)]
+    fn from(variant: DEVICEADDRTYPE_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl DEVICEADDRTYPE_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> DEVICEADDRTYPE_A {
+        match self.bits {
+            false => DEVICEADDRTYPE_A::PUBLIC,
+            true => DEVICEADDRTYPE_A::RANDOM,
+        }
+    }
+    #[doc = "Checks if the value of the field is `PUBLIC`"]
+    #[inline(always)]
+    pub fn is_public(&self) -> bool {
+        *self == DEVICEADDRTYPE_A::PUBLIC
+    }
+    #[doc = "Checks if the value of the field is `RANDOM`"]
+    #[inline(always)]
+    pub fn is_random(&self) -> bool {
+        *self == DEVICEADDRTYPE_A::RANDOM
+    }
+}
+impl R {
+    #[doc = "Bit 0 - Device address type"]
+    #[inline(always)]
+    pub fn deviceaddrtype(&self) -> DEVICEADDRTYPE_R {
+        DEVICEADDRTYPE_R::new((self.bits & 1) != 0)
+    }
+}
+#[doc = "Device address type\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [deviceaddrtype](index.html) module"]
+pub struct DEVICEADDRTYPE_SPEC;
+impl crate::RegisterSpec for DEVICEADDRTYPE_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [deviceaddrtype::R](R) reader structure"]
+impl crate::Readable for DEVICEADDRTYPE_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets DEVICEADDRTYPE to value 0xffff_ffff"]
+impl crate::Resettable for DEVICEADDRTYPE_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0xffff_ffff
+    }
+}

vendor/nrf52810-pac/src/ficr/deviceid.rs

@@ -0,0 +1,41 @@
+#[doc = "Register `DEVICEID[%s]` reader"]
+pub struct R(crate::R<DEVICEID_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<DEVICEID_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<DEVICEID_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<DEVICEID_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `DEVICEID` reader - 64 bit unique device identifier"]
+pub type DEVICEID_R = crate::FieldReader<u32, u32>;
+impl R {
+    #[doc = "Bits 0:31 - 64 bit unique device identifier"]
+    #[inline(always)]
+    pub fn deviceid(&self) -> DEVICEID_R {
+        DEVICEID_R::new(self.bits)
+    }
+}
+#[doc = "Description collection: Device identifier\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [deviceid](index.html) module"]
+pub struct DEVICEID_SPEC;
+impl crate::RegisterSpec for DEVICEID_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [deviceid::R](R) reader structure"]
+impl crate::Readable for DEVICEID_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets DEVICEID[%s]
+to value 0xffff_ffff"]
+impl crate::Resettable for DEVICEID_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0xffff_ffff
+    }
+}

vendor/nrf52810-pac/src/ficr/er.rs

@@ -0,0 +1,41 @@
+#[doc = "Register `ER[%s]` reader"]
+pub struct R(crate::R<ER_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<ER_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<ER_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<ER_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `ER` reader - Encryption root, word n"]
+pub type ER_R = crate::FieldReader<u32, u32>;
+impl R {
+    #[doc = "Bits 0:31 - Encryption root, word n"]
+    #[inline(always)]
+    pub fn er(&self) -> ER_R {
+        ER_R::new(self.bits)
+    }
+}
+#[doc = "Description collection: Encryption root, word n\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [er](index.html) module"]
+pub struct ER_SPEC;
+impl crate::RegisterSpec for ER_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [er::R](R) reader structure"]
+impl crate::Readable for ER_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets ER[%s]
+to value 0xffff_ffff"]
+impl crate::Resettable for ER_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0xffff_ffff
+    }
+}

vendor/nrf52810-pac/src/ficr/info.rs

@@ -0,0 +1,34 @@
+#[doc = r"Register block"]
+#[repr(C)]
+pub struct INFO {
+    #[doc = "0x00 - Part code"]
+    pub part: PART,
+    #[doc = "0x04 - Part variant, hardware version and production configuration"]
+    pub variant: VARIANT,
+    #[doc = "0x08 - Package option"]
+    pub package: PACKAGE,
+    #[doc = "0x0c - RAM variant"]
+    pub ram: RAM,
+    #[doc = "0x10 - Flash variant"]
+    pub flash: FLASH,
+}
+#[doc = "PART (r) register accessor: an alias for `Reg<PART_SPEC>`"]
+pub type PART = crate::Reg<part::PART_SPEC>;
+#[doc = "Part code"]
+pub mod part;
+#[doc = "VARIANT (r) register accessor: an alias for `Reg<VARIANT_SPEC>`"]
+pub type VARIANT = crate::Reg<variant::VARIANT_SPEC>;
+#[doc = "Part variant, hardware version and production configuration"]
+pub mod variant;
+#[doc = "PACKAGE (r) register accessor: an alias for `Reg<PACKAGE_SPEC>`"]
+pub type PACKAGE = crate::Reg<package::PACKAGE_SPEC>;
+#[doc = "Package option"]
+pub mod package;
+#[doc = "RAM (r) register accessor: an alias for `Reg<RAM_SPEC>`"]
+pub type RAM = crate::Reg<ram::RAM_SPEC>;
+#[doc = "RAM variant"]
+pub mod ram;
+#[doc = "FLASH (r) register accessor: an alias for `Reg<FLASH_SPEC>`"]
+pub type FLASH = crate::Reg<flash::FLASH_SPEC>;
+#[doc = "Flash variant"]
+pub mod flash;

vendor/nrf52810-pac/src/ficr/info/flash.rs

@@ -0,0 +1,76 @@
+#[doc = "Register `FLASH` reader"]
+pub struct R(crate::R<FLASH_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<FLASH_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<FLASH_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<FLASH_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `FLASH` reader - Flash variant"]
+pub type FLASH_R = crate::FieldReader<u32, FLASH_A>;
+#[doc = "Flash variant\n\nValue on reset: 192"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+#[repr(u32)]
+pub enum FLASH_A {
+    #[doc = "192: 192 kByte flash"]
+    K192 = 192,
+    #[doc = "4294967295: Unspecified"]
+    UNSPECIFIED = 4294967295,
+}
+impl From<FLASH_A> for u32 {
+    #[inline(always)]
+    fn from(variant: FLASH_A) -> Self {
+        variant as _
+    }
+}
+impl FLASH_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> Option<FLASH_A> {
+        match self.bits {
+            192 => Some(FLASH_A::K192),
+            4294967295 => Some(FLASH_A::UNSPECIFIED),
+            _ => None,
+        }
+    }
+    #[doc = "Checks if the value of the field is `K192`"]
+    #[inline(always)]
+    pub fn is_k192(&self) -> bool {
+        *self == FLASH_A::K192
+    }
+    #[doc = "Checks if the value of the field is `UNSPECIFIED`"]
+    #[inline(always)]
+    pub fn is_unspecified(&self) -> bool {
+        *self == FLASH_A::UNSPECIFIED
+    }
+}
+impl R {
+    #[doc = "Bits 0:31 - Flash variant"]
+    #[inline(always)]
+    pub fn flash(&self) -> FLASH_R {
+        FLASH_R::new(self.bits)
+    }
+}
+#[doc = "Flash variant\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [flash](index.html) module"]
+pub struct FLASH_SPEC;
+impl crate::RegisterSpec for FLASH_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [flash::R](R) reader structure"]
+impl crate::Readable for FLASH_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets FLASH to value 0xc0"]
+impl crate::Resettable for FLASH_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0xc0
+    }
+}

vendor/nrf52810-pac/src/ficr/info/package.rs

@@ -0,0 +1,84 @@
+#[doc = "Register `PACKAGE` reader"]
+pub struct R(crate::R<PACKAGE_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<PACKAGE_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<PACKAGE_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<PACKAGE_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `PACKAGE` reader - Package option"]
+pub type PACKAGE_R = crate::FieldReader<u32, PACKAGE_A>;
+#[doc = "Package option\n\nValue on reset: 4294967295"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+#[repr(u32)]
+pub enum PACKAGE_A {
+    #[doc = "8192: QFxx - 48-pin QFN"]
+    QF = 8192,
+    #[doc = "8195: QCxx - 32-pin QFN"]
+    QC = 8195,
+    #[doc = "4294967295: Unspecified"]
+    UNSPECIFIED = 4294967295,
+}
+impl From<PACKAGE_A> for u32 {
+    #[inline(always)]
+    fn from(variant: PACKAGE_A) -> Self {
+        variant as _
+    }
+}
+impl PACKAGE_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> Option<PACKAGE_A> {
+        match self.bits {
+            8192 => Some(PACKAGE_A::QF),
+            8195 => Some(PACKAGE_A::QC),
+            4294967295 => Some(PACKAGE_A::UNSPECIFIED),
+            _ => None,
+        }
+    }
+    #[doc = "Checks if the value of the field is `QF`"]
+    #[inline(always)]
+    pub fn is_qf(&self) -> bool {
+        *self == PACKAGE_A::QF
+    }
+    #[doc = "Checks if the value of the field is `QC`"]
+    #[inline(always)]
+    pub fn is_qc(&self) -> bool {
+        *self == PACKAGE_A::QC
+    }
+    #[doc = "Checks if the value of the field is `UNSPECIFIED`"]
+    #[inline(always)]
+    pub fn is_unspecified(&self) -> bool {
+        *self == PACKAGE_A::UNSPECIFIED
+    }
+}
+impl R {
+    #[doc = "Bits 0:31 - Package option"]
+    #[inline(always)]
+    pub fn package(&self) -> PACKAGE_R {
+        PACKAGE_R::new(self.bits)
+    }
+}
+#[doc = "Package option\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [package](index.html) module"]
+pub struct PACKAGE_SPEC;
+impl crate::RegisterSpec for PACKAGE_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [package::R](R) reader structure"]
+impl crate::Readable for PACKAGE_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets PACKAGE to value 0xffff_ffff"]
+impl crate::Resettable for PACKAGE_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0xffff_ffff
+    }
+}

vendor/nrf52810-pac/src/ficr/info/part.rs

@@ -0,0 +1,76 @@
+#[doc = "Register `PART` reader"]
+pub struct R(crate::R<PART_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<PART_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<PART_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<PART_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `PART` reader - Part code"]
+pub type PART_R = crate::FieldReader<u32, PART_A>;
+#[doc = "Part code\n\nValue on reset: 337936"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+#[repr(u32)]
+pub enum PART_A {
+    #[doc = "337936: nRF52810"]
+    N52810 = 337936,
+    #[doc = "4294967295: Unspecified"]
+    UNSPECIFIED = 4294967295,
+}
+impl From<PART_A> for u32 {
+    #[inline(always)]
+    fn from(variant: PART_A) -> Self {
+        variant as _
+    }
+}
+impl PART_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> Option<PART_A> {
+        match self.bits {
+            337936 => Some(PART_A::N52810),
+            4294967295 => Some(PART_A::UNSPECIFIED),
+            _ => None,
+        }
+    }
+    #[doc = "Checks if the value of the field is `N52810`"]
+    #[inline(always)]
+    pub fn is_n52810(&self) -> bool {
+        *self == PART_A::N52810
+    }
+    #[doc = "Checks if the value of the field is `UNSPECIFIED`"]
+    #[inline(always)]
+    pub fn is_unspecified(&self) -> bool {
+        *self == PART_A::UNSPECIFIED
+    }
+}
+impl R {
+    #[doc = "Bits 0:31 - Part code"]
+    #[inline(always)]
+    pub fn part(&self) -> PART_R {
+        PART_R::new(self.bits)
+    }
+}
+#[doc = "Part code\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [part](index.html) module"]
+pub struct PART_SPEC;
+impl crate::RegisterSpec for PART_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [part::R](R) reader structure"]
+impl crate::Readable for PART_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets PART to value 0x0005_2810"]
+impl crate::Resettable for PART_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0x0005_2810
+    }
+}

vendor/nrf52810-pac/src/ficr/info/ram.rs

@@ -0,0 +1,76 @@
+#[doc = "Register `RAM` reader"]
+pub struct R(crate::R<RAM_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<RAM_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<RAM_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<RAM_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `RAM` reader - RAM variant"]
+pub type RAM_R = crate::FieldReader<u32, RAM_A>;
+#[doc = "RAM variant\n\nValue on reset: 24"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+#[repr(u32)]
+pub enum RAM_A {
+    #[doc = "24: 24 kByte RAM"]
+    K24 = 24,
+    #[doc = "4294967295: Unspecified"]
+    UNSPECIFIED = 4294967295,
+}
+impl From<RAM_A> for u32 {
+    #[inline(always)]
+    fn from(variant: RAM_A) -> Self {
+        variant as _
+    }
+}
+impl RAM_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> Option<RAM_A> {
+        match self.bits {
+            24 => Some(RAM_A::K24),
+            4294967295 => Some(RAM_A::UNSPECIFIED),
+            _ => None,
+        }
+    }
+    #[doc = "Checks if the value of the field is `K24`"]
+    #[inline(always)]
+    pub fn is_k24(&self) -> bool {
+        *self == RAM_A::K24
+    }
+    #[doc = "Checks if the value of the field is `UNSPECIFIED`"]
+    #[inline(always)]
+    pub fn is_unspecified(&self) -> bool {
+        *self == RAM_A::UNSPECIFIED
+    }
+}
+impl R {
+    #[doc = "Bits 0:31 - RAM variant"]
+    #[inline(always)]
+    pub fn ram(&self) -> RAM_R {
+        RAM_R::new(self.bits)
+    }
+}
+#[doc = "RAM variant\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ram](index.html) module"]
+pub struct RAM_SPEC;
+impl crate::RegisterSpec for RAM_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [ram::R](R) reader structure"]
+impl crate::Readable for RAM_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets RAM to value 0x18"]
+impl crate::Resettable for RAM_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0x18
+    }
+}

vendor/nrf52810-pac/src/ficr/info/variant.rs

@@ -0,0 +1,132 @@
+#[doc = "Register `VARIANT` reader"]
+pub struct R(crate::R<VARIANT_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<VARIANT_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<VARIANT_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<VARIANT_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `VARIANT` reader - Part variant, hardware version and production configuration, encoded as ASCII"]
+pub type VARIANT_R = crate::FieldReader<u32, VARIANT_A>;
+#[doc = "Part variant, hardware version and production configuration, encoded as ASCII\n\nValue on reset: 4294967295"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+#[repr(u32)]
+pub enum VARIANT_A {
+    #[doc = "1094795585: AAAA"]
+    AAAA = 1094795585,
+    #[doc = "1094795568: AAA0"]
+    AAA0 = 1094795568,
+    #[doc = "1094795841: AABA"]
+    AABA = 1094795841,
+    #[doc = "1094795842: AABB"]
+    AABB = 1094795842,
+    #[doc = "1094795824: AAB0"]
+    AAB0 = 1094795824,
+    #[doc = "1094796097: AACA"]
+    AACA = 1094796097,
+    #[doc = "1094796098: AACB"]
+    AACB = 1094796098,
+    #[doc = "1094796080: AAC0"]
+    AAC0 = 1094796080,
+    #[doc = "4294967295: Unspecified"]
+    UNSPECIFIED = 4294967295,
+}
+impl From<VARIANT_A> for u32 {
+    #[inline(always)]
+    fn from(variant: VARIANT_A) -> Self {
+        variant as _
+    }
+}
+impl VARIANT_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> Option<VARIANT_A> {
+        match self.bits {
+            1094795585 => Some(VARIANT_A::AAAA),
+            1094795568 => Some(VARIANT_A::AAA0),
+            1094795841 => Some(VARIANT_A::AABA),
+            1094795842 => Some(VARIANT_A::AABB),
+            1094795824 => Some(VARIANT_A::AAB0),
+            1094796097 => Some(VARIANT_A::AACA),
+            1094796098 => Some(VARIANT_A::AACB),
+            1094796080 => Some(VARIANT_A::AAC0),
+            4294967295 => Some(VARIANT_A::UNSPECIFIED),
+            _ => None,
+        }
+    }
+    #[doc = "Checks if the value of the field is `AAAA`"]
+    #[inline(always)]
+    pub fn is_aaaa(&self) -> bool {
+        *self == VARIANT_A::AAAA
+    }
+    #[doc = "Checks if the value of the field is `AAA0`"]
+    #[inline(always)]
+    pub fn is_aaa0(&self) -> bool {
+        *self == VARIANT_A::AAA0
+    }
+    #[doc = "Checks if the value of the field is `AABA`"]
+    #[inline(always)]
+    pub fn is_aaba(&self) -> bool {
+        *self == VARIANT_A::AABA
+    }
+    #[doc = "Checks if the value of the field is `AABB`"]
+    #[inline(always)]
+    pub fn is_aabb(&self) -> bool {
+        *self == VARIANT_A::AABB
+    }
+    #[doc = "Checks if the value of the field is `AAB0`"]
+    #[inline(always)]
+    pub fn is_aab0(&self) -> bool {
+        *self == VARIANT_A::AAB0
+    }
+    #[doc = "Checks if the value of the field is `AACA`"]
+    #[inline(always)]
+    pub fn is_aaca(&self) -> bool {
+        *self == VARIANT_A::AACA
+    }
+    #[doc = "Checks if the value of the field is `AACB`"]
+    #[inline(always)]
+    pub fn is_aacb(&self) -> bool {
+        *self == VARIANT_A::AACB
+    }
+    #[doc = "Checks if the value of the field is `AAC0`"]
+    #[inline(always)]
+    pub fn is_aac0(&self) -> bool {
+        *self == VARIANT_A::AAC0
+    }
+    #[doc = "Checks if the value of the field is `UNSPECIFIED`"]
+    #[inline(always)]
+    pub fn is_unspecified(&self) -> bool {
+        *self == VARIANT_A::UNSPECIFIED
+    }
+}
+impl R {
+    #[doc = "Bits 0:31 - Part variant, hardware version and production configuration, encoded as ASCII"]
+    #[inline(always)]
+    pub fn variant(&self) -> VARIANT_R {
+        VARIANT_R::new(self.bits)
+    }
+}
+#[doc = "Part variant, hardware version and production configuration\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [variant](index.html) module"]
+pub struct VARIANT_SPEC;
+impl crate::RegisterSpec for VARIANT_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [variant::R](R) reader structure"]
+impl crate::Readable for VARIANT_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets VARIANT to value 0xffff_ffff"]
+impl crate::Resettable for VARIANT_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0xffff_ffff
+    }
+}

vendor/nrf52810-pac/src/ficr/ir.rs

@@ -0,0 +1,41 @@
+#[doc = "Register `IR[%s]` reader"]
+pub struct R(crate::R<IR_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<IR_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<IR_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<IR_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `IR` reader - Identity root, word n"]
+pub type IR_R = crate::FieldReader<u32, u32>;
+impl R {
+    #[doc = "Bits 0:31 - Identity root, word n"]
+    #[inline(always)]
+    pub fn ir(&self) -> IR_R {
+        IR_R::new(self.bits)
+    }
+}
+#[doc = "Description collection: Identity root, word n\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ir](index.html) module"]
+pub struct IR_SPEC;
+impl crate::RegisterSpec for IR_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [ir::R](R) reader structure"]
+impl crate::Readable for IR_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets IR[%s]
+to value 0xffff_ffff"]
+impl crate::Resettable for IR_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0xffff_ffff
+    }
+}

vendor/nrf52810-pac/src/ficr/temp.rs

@@ -0,0 +1,106 @@
+#[doc = r"Register block"]
+#[repr(C)]
+pub struct TEMP {
+    #[doc = "0x00 - Slope definition A0"]
+    pub a0: A0,
+    #[doc = "0x04 - Slope definition A1"]
+    pub a1: A1,
+    #[doc = "0x08 - Slope definition A2"]
+    pub a2: A2,
+    #[doc = "0x0c - Slope definition A3"]
+    pub a3: A3,
+    #[doc = "0x10 - Slope definition A4"]
+    pub a4: A4,
+    #[doc = "0x14 - Slope definition A5"]
+    pub a5: A5,
+    #[doc = "0x18 - Y-intercept B0"]
+    pub b0: B0,
+    #[doc = "0x1c - Y-intercept B1"]
+    pub b1: B1,
+    #[doc = "0x20 - Y-intercept B2"]
+    pub b2: B2,
+    #[doc = "0x24 - Y-intercept B3"]
+    pub b3: B3,
+    #[doc = "0x28 - Y-intercept B4"]
+    pub b4: B4,
+    #[doc = "0x2c - Y-intercept B5"]
+    pub b5: B5,
+    #[doc = "0x30 - Segment end T0"]
+    pub t0: T0,
+    #[doc = "0x34 - Segment end T1"]
+    pub t1: T1,
+    #[doc = "0x38 - Segment end T2"]
+    pub t2: T2,
+    #[doc = "0x3c - Segment end T3"]
+    pub t3: T3,
+    #[doc = "0x40 - Segment end T4"]
+    pub t4: T4,
+}
+#[doc = "A0 (r) register accessor: an alias for `Reg<A0_SPEC>`"]
+pub type A0 = crate::Reg<a0::A0_SPEC>;
+#[doc = "Slope definition A0"]
+pub mod a0;
+#[doc = "A1 (r) register accessor: an alias for `Reg<A1_SPEC>`"]
+pub type A1 = crate::Reg<a1::A1_SPEC>;
+#[doc = "Slope definition A1"]
+pub mod a1;
+#[doc = "A2 (r) register accessor: an alias for `Reg<A2_SPEC>`"]
+pub type A2 = crate::Reg<a2::A2_SPEC>;
+#[doc = "Slope definition A2"]
+pub mod a2;
+#[doc = "A3 (r) register accessor: an alias for `Reg<A3_SPEC>`"]
+pub type A3 = crate::Reg<a3::A3_SPEC>;
+#[doc = "Slope definition A3"]
+pub mod a3;
+#[doc = "A4 (r) register accessor: an alias for `Reg<A4_SPEC>`"]
+pub type A4 = crate::Reg<a4::A4_SPEC>;
+#[doc = "Slope definition A4"]
+pub mod a4;
+#[doc = "A5 (r) register accessor: an alias for `Reg<A5_SPEC>`"]
+pub type A5 = crate::Reg<a5::A5_SPEC>;
+#[doc = "Slope definition A5"]
+pub mod a5;
+#[doc = "B0 (r) register accessor: an alias for `Reg<B0_SPEC>`"]
+pub type B0 = crate::Reg<b0::B0_SPEC>;
+#[doc = "Y-intercept B0"]
+pub mod b0;
+#[doc = "B1 (r) register accessor: an alias for `Reg<B1_SPEC>`"]
+pub type B1 = crate::Reg<b1::B1_SPEC>;
+#[doc = "Y-intercept B1"]
+pub mod b1;
+#[doc = "B2 (r) register accessor: an alias for `Reg<B2_SPEC>`"]
+pub type B2 = crate::Reg<b2::B2_SPEC>;
+#[doc = "Y-intercept B2"]
+pub mod b2;
+#[doc = "B3 (r) register accessor: an alias for `Reg<B3_SPEC>`"]
+pub type B3 = crate::Reg<b3::B3_SPEC>;
+#[doc = "Y-intercept B3"]
+pub mod b3;
+#[doc = "B4 (r) register accessor: an alias for `Reg<B4_SPEC>`"]
+pub type B4 = crate::Reg<b4::B4_SPEC>;
+#[doc = "Y-intercept B4"]
+pub mod b4;
+#[doc = "B5 (r) register accessor: an alias for `Reg<B5_SPEC>`"]
+pub type B5 = crate::Reg<b5::B5_SPEC>;
+#[doc = "Y-intercept B5"]
+pub mod b5;
+#[doc = "T0 (r) register accessor: an alias for `Reg<T0_SPEC>`"]
+pub type T0 = crate::Reg<t0::T0_SPEC>;
+#[doc = "Segment end T0"]
+pub mod t0;
+#[doc = "T1 (r) register accessor: an alias for `Reg<T1_SPEC>`"]
+pub type T1 = crate::Reg<t1::T1_SPEC>;
+#[doc = "Segment end T1"]
+pub mod t1;
+#[doc = "T2 (r) register accessor: an alias for `Reg<T2_SPEC>`"]
+pub type T2 = crate::Reg<t2::T2_SPEC>;
+#[doc = "Segment end T2"]
+pub mod t2;
+#[doc = "T3 (r) register accessor: an alias for `Reg<T3_SPEC>`"]
+pub type T3 = crate::Reg<t3::T3_SPEC>;
+#[doc = "Segment end T3"]
+pub mod t3;
+#[doc = "T4 (r) register accessor: an alias for `Reg<T4_SPEC>`"]
+pub type T4 = crate::Reg<t4::T4_SPEC>;
+#[doc = "Segment end T4"]
+pub mod t4;

vendor/nrf52810-pac/src/ficr/temp/a0.rs

@@ -0,0 +1,40 @@
+#[doc = "Register `A0` reader"]
+pub struct R(crate::R<A0_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<A0_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<A0_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<A0_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `A` reader - A (slope definition) register"]
+pub type A_R = crate::FieldReader<u16, u16>;
+impl R {
+    #[doc = "Bits 0:11 - A (slope definition) register"]
+    #[inline(always)]
+    pub fn a(&self) -> A_R {
+        A_R::new((self.bits & 0x0fff) as u16)
+    }
+}
+#[doc = "Slope definition A0\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [a0](index.html) module"]
+pub struct A0_SPEC;
+impl crate::RegisterSpec for A0_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [a0::R](R) reader structure"]
+impl crate::Readable for A0_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets A0 to value 0x0320"]
+impl crate::Resettable for A0_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0x0320
+    }
+}

vendor/nrf52810-pac/src/ficr/temp/a1.rs

@@ -0,0 +1,40 @@
+#[doc = "Register `A1` reader"]
+pub struct R(crate::R<A1_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<A1_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<A1_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<A1_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `A` reader - A (slope definition) register"]
+pub type A_R = crate::FieldReader<u16, u16>;
+impl R {
+    #[doc = "Bits 0:11 - A (slope definition) register"]
+    #[inline(always)]
+    pub fn a(&self) -> A_R {
+        A_R::new((self.bits & 0x0fff) as u16)
+    }
+}
+#[doc = "Slope definition A1\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [a1](index.html) module"]
+pub struct A1_SPEC;
+impl crate::RegisterSpec for A1_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [a1::R](R) reader structure"]
+impl crate::Readable for A1_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets A1 to value 0x0343"]
+impl crate::Resettable for A1_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0x0343
+    }
+}

vendor/nrf52810-pac/src/ficr/temp/a2.rs

@@ -0,0 +1,40 @@
+#[doc = "Register `A2` reader"]
+pub struct R(crate::R<A2_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<A2_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<A2_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<A2_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `A` reader - A (slope definition) register"]
+pub type A_R = crate::FieldReader<u16, u16>;
+impl R {
+    #[doc = "Bits 0:11 - A (slope definition) register"]
+    #[inline(always)]
+    pub fn a(&self) -> A_R {
+        A_R::new((self.bits & 0x0fff) as u16)
+    }
+}
+#[doc = "Slope definition A2\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [a2](index.html) module"]
+pub struct A2_SPEC;
+impl crate::RegisterSpec for A2_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [a2::R](R) reader structure"]
+impl crate::Readable for A2_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets A2 to value 0x035d"]
+impl crate::Resettable for A2_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0x035d
+    }
+}

vendor/nrf52810-pac/src/ficr/temp/a3.rs

@@ -0,0 +1,40 @@
+#[doc = "Register `A3` reader"]
+pub struct R(crate::R<A3_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<A3_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<A3_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<A3_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `A` reader - A (slope definition) register"]
+pub type A_R = crate::FieldReader<u16, u16>;
+impl R {
+    #[doc = "Bits 0:11 - A (slope definition) register"]
+    #[inline(always)]
+    pub fn a(&self) -> A_R {
+        A_R::new((self.bits & 0x0fff) as u16)
+    }
+}
+#[doc = "Slope definition A3\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [a3](index.html) module"]
+pub struct A3_SPEC;
+impl crate::RegisterSpec for A3_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [a3::R](R) reader structure"]
+impl crate::Readable for A3_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets A3 to value 0x0400"]
+impl crate::Resettable for A3_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0x0400
+    }
+}

vendor/nrf52810-pac/src/ficr/temp/a4.rs

@@ -0,0 +1,40 @@
+#[doc = "Register `A4` reader"]
+pub struct R(crate::R<A4_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<A4_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<A4_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<A4_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `A` reader - A (slope definition) register"]
+pub type A_R = crate::FieldReader<u16, u16>;
+impl R {
+    #[doc = "Bits 0:11 - A (slope definition) register"]
+    #[inline(always)]
+    pub fn a(&self) -> A_R {
+        A_R::new((self.bits & 0x0fff) as u16)
+    }
+}
+#[doc = "Slope definition A4\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [a4](index.html) module"]
+pub struct A4_SPEC;
+impl crate::RegisterSpec for A4_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [a4::R](R) reader structure"]
+impl crate::Readable for A4_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets A4 to value 0x0452"]
+impl crate::Resettable for A4_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0x0452
+    }
+}

vendor/nrf52810-pac/src/ficr/temp/a5.rs

@@ -0,0 +1,40 @@
+#[doc = "Register `A5` reader"]
+pub struct R(crate::R<A5_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<A5_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<A5_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<A5_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `A` reader - A (slope definition) register"]
+pub type A_R = crate::FieldReader<u16, u16>;
+impl R {
+    #[doc = "Bits 0:11 - A (slope definition) register"]
+    #[inline(always)]
+    pub fn a(&self) -> A_R {
+        A_R::new((self.bits & 0x0fff) as u16)
+    }
+}
+#[doc = "Slope definition A5\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [a5](index.html) module"]
+pub struct A5_SPEC;
+impl crate::RegisterSpec for A5_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [a5::R](R) reader structure"]
+impl crate::Readable for A5_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets A5 to value 0x037b"]
+impl crate::Resettable for A5_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0x037b
+    }
+}

vendor/nrf52810-pac/src/ficr/temp/b0.rs

@@ -0,0 +1,40 @@
+#[doc = "Register `B0` reader"]
+pub struct R(crate::R<B0_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<B0_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<B0_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<B0_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `B` reader - B (y-intercept)"]
+pub type B_R = crate::FieldReader<u16, u16>;
+impl R {
+    #[doc = "Bits 0:13 - B (y-intercept)"]
+    #[inline(always)]
+    pub fn b(&self) -> B_R {
+        B_R::new((self.bits & 0x3fff) as u16)
+    }
+}
+#[doc = "Y-intercept B0\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [b0](index.html) module"]
+pub struct B0_SPEC;
+impl crate::RegisterSpec for B0_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [b0::R](R) reader structure"]
+impl crate::Readable for B0_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets B0 to value 0x3fcc"]
+impl crate::Resettable for B0_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0x3fcc
+    }
+}

vendor/nrf52810-pac/src/ficr/temp/b1.rs

@@ -0,0 +1,40 @@
+#[doc = "Register `B1` reader"]
+pub struct R(crate::R<B1_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<B1_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<B1_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<B1_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `B` reader - B (y-intercept)"]
+pub type B_R = crate::FieldReader<u16, u16>;
+impl R {
+    #[doc = "Bits 0:13 - B (y-intercept)"]
+    #[inline(always)]
+    pub fn b(&self) -> B_R {
+        B_R::new((self.bits & 0x3fff) as u16)
+    }
+}
+#[doc = "Y-intercept B1\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [b1](index.html) module"]
+pub struct B1_SPEC;
+impl crate::RegisterSpec for B1_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [b1::R](R) reader structure"]
+impl crate::Readable for B1_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets B1 to value 0x3f98"]
+impl crate::Resettable for B1_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0x3f98
+    }
+}

vendor/nrf52810-pac/src/ficr/temp/b2.rs

@@ -0,0 +1,40 @@
+#[doc = "Register `B2` reader"]
+pub struct R(crate::R<B2_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<B2_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<B2_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<B2_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `B` reader - B (y-intercept)"]
+pub type B_R = crate::FieldReader<u16, u16>;
+impl R {
+    #[doc = "Bits 0:13 - B (y-intercept)"]
+    #[inline(always)]
+    pub fn b(&self) -> B_R {
+        B_R::new((self.bits & 0x3fff) as u16)
+    }
+}
+#[doc = "Y-intercept B2\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [b2](index.html) module"]
+pub struct B2_SPEC;
+impl crate::RegisterSpec for B2_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [b2::R](R) reader structure"]
+impl crate::Readable for B2_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets B2 to value 0x3f98"]
+impl crate::Resettable for B2_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0x3f98
+    }
+}

vendor/nrf52810-pac/src/ficr/temp/b3.rs

@@ -0,0 +1,40 @@
+#[doc = "Register `B3` reader"]
+pub struct R(crate::R<B3_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<B3_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<B3_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<B3_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `B` reader - B (y-intercept)"]
+pub type B_R = crate::FieldReader<u16, u16>;
+impl R {
+    #[doc = "Bits 0:13 - B (y-intercept)"]
+    #[inline(always)]
+    pub fn b(&self) -> B_R {
+        B_R::new((self.bits & 0x3fff) as u16)
+    }
+}
+#[doc = "Y-intercept B3\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [b3](index.html) module"]
+pub struct B3_SPEC;
+impl crate::RegisterSpec for B3_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [b3::R](R) reader structure"]
+impl crate::Readable for B3_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets B3 to value 0x12"]
+impl crate::Resettable for B3_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0x12
+    }
+}

vendor/nrf52810-pac/src/ficr/temp/b4.rs

@@ -0,0 +1,40 @@
+#[doc = "Register `B4` reader"]
+pub struct R(crate::R<B4_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<B4_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<B4_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<B4_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `B` reader - B (y-intercept)"]
+pub type B_R = crate::FieldReader<u16, u16>;
+impl R {
+    #[doc = "Bits 0:13 - B (y-intercept)"]
+    #[inline(always)]
+    pub fn b(&self) -> B_R {
+        B_R::new((self.bits & 0x3fff) as u16)
+    }
+}
+#[doc = "Y-intercept B4\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [b4](index.html) module"]
+pub struct B4_SPEC;
+impl crate::RegisterSpec for B4_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [b4::R](R) reader structure"]
+impl crate::Readable for B4_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets B4 to value 0x4d"]
+impl crate::Resettable for B4_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0x4d
+    }
+}

vendor/nrf52810-pac/src/ficr/temp/b5.rs

@@ -0,0 +1,40 @@
+#[doc = "Register `B5` reader"]
+pub struct R(crate::R<B5_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<B5_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<B5_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<B5_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `B` reader - B (y-intercept)"]
+pub type B_R = crate::FieldReader<u16, u16>;
+impl R {
+    #[doc = "Bits 0:13 - B (y-intercept)"]
+    #[inline(always)]
+    pub fn b(&self) -> B_R {
+        B_R::new((self.bits & 0x3fff) as u16)
+    }
+}
+#[doc = "Y-intercept B5\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [b5](index.html) module"]
+pub struct B5_SPEC;
+impl crate::RegisterSpec for B5_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [b5::R](R) reader structure"]
+impl crate::Readable for B5_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets B5 to value 0x3e10"]
+impl crate::Resettable for B5_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0x3e10
+    }
+}

vendor/nrf52810-pac/src/ficr/temp/t0.rs

@@ -0,0 +1,40 @@
+#[doc = "Register `T0` reader"]
+pub struct R(crate::R<T0_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<T0_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<T0_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<T0_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `T` reader - T (segment end) register"]
+pub type T_R = crate::FieldReader<u8, u8>;
+impl R {
+    #[doc = "Bits 0:7 - T (segment end) register"]
+    #[inline(always)]
+    pub fn t(&self) -> T_R {
+        T_R::new((self.bits & 0xff) as u8)
+    }
+}
+#[doc = "Segment end T0\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [t0](index.html) module"]
+pub struct T0_SPEC;
+impl crate::RegisterSpec for T0_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [t0::R](R) reader structure"]
+impl crate::Readable for T0_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets T0 to value 0xe2"]
+impl crate::Resettable for T0_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0xe2
+    }
+}

vendor/nrf52810-pac/src/ficr/temp/t1.rs

@@ -0,0 +1,40 @@
+#[doc = "Register `T1` reader"]
+pub struct R(crate::R<T1_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<T1_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<T1_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<T1_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `T` reader - T (segment end) register"]
+pub type T_R = crate::FieldReader<u8, u8>;
+impl R {
+    #[doc = "Bits 0:7 - T (segment end) register"]
+    #[inline(always)]
+    pub fn t(&self) -> T_R {
+        T_R::new((self.bits & 0xff) as u8)
+    }
+}
+#[doc = "Segment end T1\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [t1](index.html) module"]
+pub struct T1_SPEC;
+impl crate::RegisterSpec for T1_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [t1::R](R) reader structure"]
+impl crate::Readable for T1_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets T1 to value 0"]
+impl crate::Resettable for T1_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf52810-pac/src/ficr/temp/t2.rs

@@ -0,0 +1,40 @@
+#[doc = "Register `T2` reader"]
+pub struct R(crate::R<T2_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<T2_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<T2_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<T2_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `T` reader - T (segment end) register"]
+pub type T_R = crate::FieldReader<u8, u8>;
+impl R {
+    #[doc = "Bits 0:7 - T (segment end) register"]
+    #[inline(always)]
+    pub fn t(&self) -> T_R {
+        T_R::new((self.bits & 0xff) as u8)
+    }
+}
+#[doc = "Segment end T2\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [t2](index.html) module"]
+pub struct T2_SPEC;
+impl crate::RegisterSpec for T2_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [t2::R](R) reader structure"]
+impl crate::Readable for T2_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets T2 to value 0x14"]
+impl crate::Resettable for T2_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0x14
+    }
+}

vendor/nrf52810-pac/src/ficr/temp/t3.rs

@@ -0,0 +1,40 @@
+#[doc = "Register `T3` reader"]
+pub struct R(crate::R<T3_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<T3_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<T3_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<T3_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `T` reader - T (segment end) register"]
+pub type T_R = crate::FieldReader<u8, u8>;
+impl R {
+    #[doc = "Bits 0:7 - T (segment end) register"]
+    #[inline(always)]
+    pub fn t(&self) -> T_R {
+        T_R::new((self.bits & 0xff) as u8)
+    }
+}
+#[doc = "Segment end T3\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [t3](index.html) module"]
+pub struct T3_SPEC;
+impl crate::RegisterSpec for T3_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [t3::R](R) reader structure"]
+impl crate::Readable for T3_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets T3 to value 0x19"]
+impl crate::Resettable for T3_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0x19
+    }
+}

vendor/nrf52810-pac/src/ficr/temp/t4.rs

@@ -0,0 +1,40 @@
+#[doc = "Register `T4` reader"]
+pub struct R(crate::R<T4_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<T4_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<T4_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<T4_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `T` reader - T (segment end) register"]
+pub type T_R = crate::FieldReader<u8, u8>;
+impl R {
+    #[doc = "Bits 0:7 - T (segment end) register"]
+    #[inline(always)]
+    pub fn t(&self) -> T_R {
+        T_R::new((self.bits & 0xff) as u8)
+    }
+}
+#[doc = "Segment end T4\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [t4](index.html) module"]
+pub struct T4_SPEC;
+impl crate::RegisterSpec for T4_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [t4::R](R) reader structure"]
+impl crate::Readable for T4_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets T4 to value 0x50"]
+impl crate::Resettable for T4_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0x50
+    }
+}