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>
This commit is contained in:
17624 files changed
+4564928
-38
No files matched your search
+40
@@ -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 0xffff_ffff"]
|
||||
impl crate::Resettable for CODEPAGESIZE_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0xffff_ffff
|
||||
}
|
||||
}
|
||||
+40
@@ -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 0xffff_ffff"]
|
||||
impl crate::Resettable for CODESIZE_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0xffff_ffff
|
||||
}
|
||||
}
|
||||
+41
@@ -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\\[0\\]: Device address 0\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
|
||||
}
|
||||
}
|
||||
+74
@@ -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
|
||||
}
|
||||
}
|
||||
+41
@@ -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\\[0\\]: 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
|
||||
}
|
||||
}
|
||||
Vendored
+41
@@ -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\\[0\\]: Encryption Root, word 0\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
|
||||
}
|
||||
}
|
||||
Vendored
+40
@@ -0,0 +1,40 @@
|
||||
#[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 = "0x14..0x20 - Description collection\\[0\\]: Unspecified"]
|
||||
pub unused0: [UNUSED0; 3],
|
||||
}
|
||||
#[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;
|
||||
#[doc = "UNUSED0 (rw) register accessor: an alias for `Reg<UNUSED0_SPEC>`"]
|
||||
pub type UNUSED0 = crate::Reg<unused0::UNUSED0_SPEC>;
|
||||
#[doc = "Description collection\\[0\\]: Unspecified"]
|
||||
pub mod unused0;
|
||||
+92
@@ -0,0 +1,92 @@
|
||||
#[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: 512"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
#[repr(u32)]
|
||||
pub enum FLASH_A {
|
||||
#[doc = "128: 128 kByte FLASH"]
|
||||
K128 = 128,
|
||||
#[doc = "256: 256 kByte FLASH"]
|
||||
K256 = 256,
|
||||
#[doc = "512: 512 kByte FLASH"]
|
||||
K512 = 512,
|
||||
#[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 {
|
||||
128 => Some(FLASH_A::K128),
|
||||
256 => Some(FLASH_A::K256),
|
||||
512 => Some(FLASH_A::K512),
|
||||
4294967295 => Some(FLASH_A::UNSPECIFIED),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `K128`"]
|
||||
#[inline(always)]
|
||||
pub fn is_k128(&self) -> bool {
|
||||
*self == FLASH_A::K128
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `K256`"]
|
||||
#[inline(always)]
|
||||
pub fn is_k256(&self) -> bool {
|
||||
*self == FLASH_A::K256
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `K512`"]
|
||||
#[inline(always)]
|
||||
pub fn is_k512(&self) -> bool {
|
||||
*self == FLASH_A::K512
|
||||
}
|
||||
#[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 0x0200"]
|
||||
impl crate::Resettable for FLASH_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0x0200
|
||||
}
|
||||
}
|
||||
+100
@@ -0,0 +1,100 @@
|
||||
#[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: 8192"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
#[repr(u32)]
|
||||
pub enum PACKAGE_A {
|
||||
#[doc = "8192: QFxx - 48-pin QFN"]
|
||||
QF = 8192,
|
||||
#[doc = "8193: CHxx - 7x8 WLCSP 56 balls"]
|
||||
CH = 8193,
|
||||
#[doc = "8194: CIxx - 7x8 WLCSP 56 balls"]
|
||||
CI = 8194,
|
||||
#[doc = "8197: CKxx - 7x8 WLCSP 56 balls with backside coating for light protection"]
|
||||
CK = 8197,
|
||||
#[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),
|
||||
8193 => Some(PACKAGE_A::CH),
|
||||
8194 => Some(PACKAGE_A::CI),
|
||||
8197 => Some(PACKAGE_A::CK),
|
||||
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 `CH`"]
|
||||
#[inline(always)]
|
||||
pub fn is_ch(&self) -> bool {
|
||||
*self == PACKAGE_A::CH
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `CI`"]
|
||||
#[inline(always)]
|
||||
pub fn is_ci(&self) -> bool {
|
||||
*self == PACKAGE_A::CI
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `CK`"]
|
||||
#[inline(always)]
|
||||
pub fn is_ck(&self) -> bool {
|
||||
*self == PACKAGE_A::CK
|
||||
}
|
||||
#[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 0x2000"]
|
||||
impl crate::Resettable for PACKAGE_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0x2000
|
||||
}
|
||||
}
|
||||
+76
@@ -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: 337970"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
#[repr(u32)]
|
||||
pub enum PART_A {
|
||||
#[doc = "337970: nRF52832"]
|
||||
N52832 = 337970,
|
||||
#[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 {
|
||||
337970 => Some(PART_A::N52832),
|
||||
4294967295 => Some(PART_A::UNSPECIFIED),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `N52832`"]
|
||||
#[inline(always)]
|
||||
pub fn is_n52832(&self) -> bool {
|
||||
*self == PART_A::N52832
|
||||
}
|
||||
#[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_2832"]
|
||||
impl crate::Resettable for PART_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0x0005_2832
|
||||
}
|
||||
}
|
||||
+92
@@ -0,0 +1,92 @@
|
||||
#[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: 64"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
#[repr(u32)]
|
||||
pub enum RAM_A {
|
||||
#[doc = "16: 16 kByte RAM"]
|
||||
K16 = 16,
|
||||
#[doc = "32: 32 kByte RAM"]
|
||||
K32 = 32,
|
||||
#[doc = "64: 64 kByte RAM"]
|
||||
K64 = 64,
|
||||
#[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 {
|
||||
16 => Some(RAM_A::K16),
|
||||
32 => Some(RAM_A::K32),
|
||||
64 => Some(RAM_A::K64),
|
||||
4294967295 => Some(RAM_A::UNSPECIFIED),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `K16`"]
|
||||
#[inline(always)]
|
||||
pub fn is_k16(&self) -> bool {
|
||||
*self == RAM_A::K16
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `K32`"]
|
||||
#[inline(always)]
|
||||
pub fn is_k32(&self) -> bool {
|
||||
*self == RAM_A::K32
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `K64`"]
|
||||
#[inline(always)]
|
||||
pub fn is_k64(&self) -> bool {
|
||||
*self == RAM_A::K64
|
||||
}
|
||||
#[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 0x40"]
|
||||
impl crate::Resettable for RAM_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0x40
|
||||
}
|
||||
}
|
||||
+65
@@ -0,0 +1,65 @@
|
||||
#[doc = "Register `UNUSED0[%s]` reader"]
|
||||
pub struct R(crate::R<UNUSED0_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<UNUSED0_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<UNUSED0_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<UNUSED0_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `UNUSED0[%s]` writer"]
|
||||
pub struct W(crate::W<UNUSED0_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<UNUSED0_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<UNUSED0_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<UNUSED0_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "Description collection\\[0\\]: Unspecified\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [unused0](index.html) module"]
|
||||
pub struct UNUSED0_SPEC;
|
||||
impl crate::RegisterSpec for UNUSED0_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [unused0::R](R) reader structure"]
|
||||
impl crate::Readable for UNUSED0_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [unused0::W](W) writer structure"]
|
||||
impl crate::Writable for UNUSED0_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets UNUSED0[%s]
|
||||
to value 0"]
|
||||
impl crate::Resettable for UNUSED0_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
+116
@@ -0,0 +1,116 @@
|
||||
#[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: 1094795586"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
#[repr(u32)]
|
||||
pub enum VARIANT_A {
|
||||
#[doc = "1094795585: AAAA"]
|
||||
AAAA = 1094795585,
|
||||
#[doc = "1094795586: AAAB"]
|
||||
AAAB = 1094795586,
|
||||
#[doc = "1094795841: AABA"]
|
||||
AABA = 1094795841,
|
||||
#[doc = "1094795842: AABB"]
|
||||
AABB = 1094795842,
|
||||
#[doc = "1094795824: AAB0"]
|
||||
AAB0 = 1094795824,
|
||||
#[doc = "1094796592: AAE0"]
|
||||
AAE0 = 1094796592,
|
||||
#[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),
|
||||
1094795586 => Some(VARIANT_A::AAAB),
|
||||
1094795841 => Some(VARIANT_A::AABA),
|
||||
1094795842 => Some(VARIANT_A::AABB),
|
||||
1094795824 => Some(VARIANT_A::AAB0),
|
||||
1094796592 => Some(VARIANT_A::AAE0),
|
||||
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 `AAAB`"]
|
||||
#[inline(always)]
|
||||
pub fn is_aaab(&self) -> bool {
|
||||
*self == VARIANT_A::AAAB
|
||||
}
|
||||
#[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 `AAE0`"]
|
||||
#[inline(always)]
|
||||
pub fn is_aae0(&self) -> bool {
|
||||
*self == VARIANT_A::AAE0
|
||||
}
|
||||
#[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 0x4141_4142"]
|
||||
impl crate::Resettable for VARIANT_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0x4141_4142
|
||||
}
|
||||
}
|
||||
Vendored
+41
@@ -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\\[0\\]: Identity Root, word 0\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
|
||||
}
|
||||
}
|
||||
Vendored
+28
@@ -0,0 +1,28 @@
|
||||
#[doc = r"Register block"]
|
||||
#[repr(C)]
|
||||
pub struct NFC {
|
||||
#[doc = "0x00 - Default header for NFC Tag. Software can read these values to populate NFCID1_3RD_LAST, NFCID1_2ND_LAST and NFCID1_LAST."]
|
||||
pub tagheader0: TAGHEADER0,
|
||||
#[doc = "0x04 - Default header for NFC Tag. Software can read these values to populate NFCID1_3RD_LAST, NFCID1_2ND_LAST and NFCID1_LAST."]
|
||||
pub tagheader1: TAGHEADER1,
|
||||
#[doc = "0x08 - Default header for NFC Tag. Software can read these values to populate NFCID1_3RD_LAST, NFCID1_2ND_LAST and NFCID1_LAST."]
|
||||
pub tagheader2: TAGHEADER2,
|
||||
#[doc = "0x0c - Default header for NFC Tag. Software can read these values to populate NFCID1_3RD_LAST, NFCID1_2ND_LAST and NFCID1_LAST."]
|
||||
pub tagheader3: TAGHEADER3,
|
||||
}
|
||||
#[doc = "TAGHEADER0 (r) register accessor: an alias for `Reg<TAGHEADER0_SPEC>`"]
|
||||
pub type TAGHEADER0 = crate::Reg<tagheader0::TAGHEADER0_SPEC>;
|
||||
#[doc = "Default header for NFC Tag. Software can read these values to populate NFCID1_3RD_LAST, NFCID1_2ND_LAST and NFCID1_LAST."]
|
||||
pub mod tagheader0;
|
||||
#[doc = "TAGHEADER1 (r) register accessor: an alias for `Reg<TAGHEADER1_SPEC>`"]
|
||||
pub type TAGHEADER1 = crate::Reg<tagheader1::TAGHEADER1_SPEC>;
|
||||
#[doc = "Default header for NFC Tag. Software can read these values to populate NFCID1_3RD_LAST, NFCID1_2ND_LAST and NFCID1_LAST."]
|
||||
pub mod tagheader1;
|
||||
#[doc = "TAGHEADER2 (r) register accessor: an alias for `Reg<TAGHEADER2_SPEC>`"]
|
||||
pub type TAGHEADER2 = crate::Reg<tagheader2::TAGHEADER2_SPEC>;
|
||||
#[doc = "Default header for NFC Tag. Software can read these values to populate NFCID1_3RD_LAST, NFCID1_2ND_LAST and NFCID1_LAST."]
|
||||
pub mod tagheader2;
|
||||
#[doc = "TAGHEADER3 (r) register accessor: an alias for `Reg<TAGHEADER3_SPEC>`"]
|
||||
pub type TAGHEADER3 = crate::Reg<tagheader3::TAGHEADER3_SPEC>;
|
||||
#[doc = "Default header for NFC Tag. Software can read these values to populate NFCID1_3RD_LAST, NFCID1_2ND_LAST and NFCID1_LAST."]
|
||||
pub mod tagheader3;
|
||||
+61
@@ -0,0 +1,61 @@
|
||||
#[doc = "Register `TAGHEADER0` reader"]
|
||||
pub struct R(crate::R<TAGHEADER0_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<TAGHEADER0_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<TAGHEADER0_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<TAGHEADER0_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `MFGID` reader - Default Manufacturer ID: Nordic Semiconductor ASA has ICM 0x5F"]
|
||||
pub type MFGID_R = crate::FieldReader<u8, u8>;
|
||||
#[doc = "Field `UD1` reader - Unique identifier byte 1"]
|
||||
pub type UD1_R = crate::FieldReader<u8, u8>;
|
||||
#[doc = "Field `UD2` reader - Unique identifier byte 2"]
|
||||
pub type UD2_R = crate::FieldReader<u8, u8>;
|
||||
#[doc = "Field `UD3` reader - Unique identifier byte 3"]
|
||||
pub type UD3_R = crate::FieldReader<u8, u8>;
|
||||
impl R {
|
||||
#[doc = "Bits 0:7 - Default Manufacturer ID: Nordic Semiconductor ASA has ICM 0x5F"]
|
||||
#[inline(always)]
|
||||
pub fn mfgid(&self) -> MFGID_R {
|
||||
MFGID_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 8:15 - Unique identifier byte 1"]
|
||||
#[inline(always)]
|
||||
pub fn ud1(&self) -> UD1_R {
|
||||
UD1_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 16:23 - Unique identifier byte 2"]
|
||||
#[inline(always)]
|
||||
pub fn ud2(&self) -> UD2_R {
|
||||
UD2_R::new(((self.bits >> 16) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 24:31 - Unique identifier byte 3"]
|
||||
#[inline(always)]
|
||||
pub fn ud3(&self) -> UD3_R {
|
||||
UD3_R::new(((self.bits >> 24) & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
#[doc = "Default header for NFC Tag. Software can read these values to populate NFCID1_3RD_LAST, NFCID1_2ND_LAST and NFCID1_LAST.\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 [tagheader0](index.html) module"]
|
||||
pub struct TAGHEADER0_SPEC;
|
||||
impl crate::RegisterSpec for TAGHEADER0_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [tagheader0::R](R) reader structure"]
|
||||
impl crate::Readable for TAGHEADER0_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`reset()` method sets TAGHEADER0 to value 0xffff_ff5f"]
|
||||
impl crate::Resettable for TAGHEADER0_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0xffff_ff5f
|
||||
}
|
||||
}
|
||||
+61
@@ -0,0 +1,61 @@
|
||||
#[doc = "Register `TAGHEADER1` reader"]
|
||||
pub struct R(crate::R<TAGHEADER1_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<TAGHEADER1_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<TAGHEADER1_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<TAGHEADER1_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `UD4` reader - Unique identifier byte 4"]
|
||||
pub type UD4_R = crate::FieldReader<u8, u8>;
|
||||
#[doc = "Field `UD5` reader - Unique identifier byte 5"]
|
||||
pub type UD5_R = crate::FieldReader<u8, u8>;
|
||||
#[doc = "Field `UD6` reader - Unique identifier byte 6"]
|
||||
pub type UD6_R = crate::FieldReader<u8, u8>;
|
||||
#[doc = "Field `UD7` reader - Unique identifier byte 7"]
|
||||
pub type UD7_R = crate::FieldReader<u8, u8>;
|
||||
impl R {
|
||||
#[doc = "Bits 0:7 - Unique identifier byte 4"]
|
||||
#[inline(always)]
|
||||
pub fn ud4(&self) -> UD4_R {
|
||||
UD4_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 8:15 - Unique identifier byte 5"]
|
||||
#[inline(always)]
|
||||
pub fn ud5(&self) -> UD5_R {
|
||||
UD5_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 16:23 - Unique identifier byte 6"]
|
||||
#[inline(always)]
|
||||
pub fn ud6(&self) -> UD6_R {
|
||||
UD6_R::new(((self.bits >> 16) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 24:31 - Unique identifier byte 7"]
|
||||
#[inline(always)]
|
||||
pub fn ud7(&self) -> UD7_R {
|
||||
UD7_R::new(((self.bits >> 24) & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
#[doc = "Default header for NFC Tag. Software can read these values to populate NFCID1_3RD_LAST, NFCID1_2ND_LAST and NFCID1_LAST.\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 [tagheader1](index.html) module"]
|
||||
pub struct TAGHEADER1_SPEC;
|
||||
impl crate::RegisterSpec for TAGHEADER1_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [tagheader1::R](R) reader structure"]
|
||||
impl crate::Readable for TAGHEADER1_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`reset()` method sets TAGHEADER1 to value 0xffff_ffff"]
|
||||
impl crate::Resettable for TAGHEADER1_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0xffff_ffff
|
||||
}
|
||||
}
|
||||
+61
@@ -0,0 +1,61 @@
|
||||
#[doc = "Register `TAGHEADER2` reader"]
|
||||
pub struct R(crate::R<TAGHEADER2_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<TAGHEADER2_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<TAGHEADER2_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<TAGHEADER2_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `UD8` reader - Unique identifier byte 8"]
|
||||
pub type UD8_R = crate::FieldReader<u8, u8>;
|
||||
#[doc = "Field `UD9` reader - Unique identifier byte 9"]
|
||||
pub type UD9_R = crate::FieldReader<u8, u8>;
|
||||
#[doc = "Field `UD10` reader - Unique identifier byte 10"]
|
||||
pub type UD10_R = crate::FieldReader<u8, u8>;
|
||||
#[doc = "Field `UD11` reader - Unique identifier byte 11"]
|
||||
pub type UD11_R = crate::FieldReader<u8, u8>;
|
||||
impl R {
|
||||
#[doc = "Bits 0:7 - Unique identifier byte 8"]
|
||||
#[inline(always)]
|
||||
pub fn ud8(&self) -> UD8_R {
|
||||
UD8_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 8:15 - Unique identifier byte 9"]
|
||||
#[inline(always)]
|
||||
pub fn ud9(&self) -> UD9_R {
|
||||
UD9_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 16:23 - Unique identifier byte 10"]
|
||||
#[inline(always)]
|
||||
pub fn ud10(&self) -> UD10_R {
|
||||
UD10_R::new(((self.bits >> 16) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 24:31 - Unique identifier byte 11"]
|
||||
#[inline(always)]
|
||||
pub fn ud11(&self) -> UD11_R {
|
||||
UD11_R::new(((self.bits >> 24) & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
#[doc = "Default header for NFC Tag. Software can read these values to populate NFCID1_3RD_LAST, NFCID1_2ND_LAST and NFCID1_LAST.\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 [tagheader2](index.html) module"]
|
||||
pub struct TAGHEADER2_SPEC;
|
||||
impl crate::RegisterSpec for TAGHEADER2_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [tagheader2::R](R) reader structure"]
|
||||
impl crate::Readable for TAGHEADER2_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`reset()` method sets TAGHEADER2 to value 0xffff_ffff"]
|
||||
impl crate::Resettable for TAGHEADER2_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0xffff_ffff
|
||||
}
|
||||
}
|
||||
+61
@@ -0,0 +1,61 @@
|
||||
#[doc = "Register `TAGHEADER3` reader"]
|
||||
pub struct R(crate::R<TAGHEADER3_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<TAGHEADER3_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<TAGHEADER3_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<TAGHEADER3_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `UD12` reader - Unique identifier byte 12"]
|
||||
pub type UD12_R = crate::FieldReader<u8, u8>;
|
||||
#[doc = "Field `UD13` reader - Unique identifier byte 13"]
|
||||
pub type UD13_R = crate::FieldReader<u8, u8>;
|
||||
#[doc = "Field `UD14` reader - Unique identifier byte 14"]
|
||||
pub type UD14_R = crate::FieldReader<u8, u8>;
|
||||
#[doc = "Field `UD15` reader - Unique identifier byte 15"]
|
||||
pub type UD15_R = crate::FieldReader<u8, u8>;
|
||||
impl R {
|
||||
#[doc = "Bits 0:7 - Unique identifier byte 12"]
|
||||
#[inline(always)]
|
||||
pub fn ud12(&self) -> UD12_R {
|
||||
UD12_R::new((self.bits & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 8:15 - Unique identifier byte 13"]
|
||||
#[inline(always)]
|
||||
pub fn ud13(&self) -> UD13_R {
|
||||
UD13_R::new(((self.bits >> 8) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 16:23 - Unique identifier byte 14"]
|
||||
#[inline(always)]
|
||||
pub fn ud14(&self) -> UD14_R {
|
||||
UD14_R::new(((self.bits >> 16) & 0xff) as u8)
|
||||
}
|
||||
#[doc = "Bits 24:31 - Unique identifier byte 15"]
|
||||
#[inline(always)]
|
||||
pub fn ud15(&self) -> UD15_R {
|
||||
UD15_R::new(((self.bits >> 24) & 0xff) as u8)
|
||||
}
|
||||
}
|
||||
#[doc = "Default header for NFC Tag. Software can read these values to populate NFCID1_3RD_LAST, NFCID1_2ND_LAST and NFCID1_LAST.\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 [tagheader3](index.html) module"]
|
||||
pub struct TAGHEADER3_SPEC;
|
||||
impl crate::RegisterSpec for TAGHEADER3_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [tagheader3::R](R) reader structure"]
|
||||
impl crate::Readable for TAGHEADER3_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`reset()` method sets TAGHEADER3 to value 0xffff_ffff"]
|
||||
impl crate::Resettable for TAGHEADER3_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0xffff_ffff
|
||||
}
|
||||
}
|
||||
Vendored
+106
@@ -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;
|
||||
+40
@@ -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
|
||||
}
|
||||
}
|
||||
+40
@@ -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
|
||||
}
|
||||
}
|
||||
+40
@@ -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
|
||||
}
|
||||
}
|
||||
+40
@@ -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
|
||||
}
|
||||
}
|
||||
+40
@@ -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
|
||||
}
|
||||
}
|
||||
+40
@@ -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
|
||||
}
|
||||
}
|
||||
+40
@@ -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
|
||||
}
|
||||
}
|
||||
+40
@@ -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
|
||||
}
|
||||
}
|
||||
+40
@@ -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
|
||||
}
|
||||
}
|
||||
+40
@@ -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
|
||||
}
|
||||
}
|
||||
+40
@@ -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
|
||||
}
|
||||
}
|
||||
+40
@@ -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
|
||||
}
|
||||
}
|
||||
+40
@@ -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
|
||||
}
|
||||
}
|
||||
+40
@@ -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
|
||||
}
|
||||
}
|
||||
+40
@@ -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
|
||||
}
|
||||
}
|
||||
+40
@@ -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
|
||||
}
|
||||
}
|
||||
+40
@@ -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
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user