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/nrf51-pac/src/uart0/baudrate.rs

@@ -0,0 +1,337 @@
+#[doc = "Register `BAUDRATE` reader"]
+pub struct R(crate::R<BAUDRATE_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<BAUDRATE_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<BAUDRATE_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<BAUDRATE_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `BAUDRATE` writer"]
+pub struct W(crate::W<BAUDRATE_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<BAUDRATE_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<BAUDRATE_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<BAUDRATE_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `BAUDRATE` reader - UART baudrate."]
+pub type BAUDRATE_R = crate::FieldReader<u32, BAUDRATE_A>;
+#[doc = "UART baudrate.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+#[repr(u32)]
+pub enum BAUDRATE_A {
+    #[doc = "323584: 1200 baud."]
+    BAUD1200 = 323584,
+    #[doc = "643072: 2400 baud."]
+    BAUD2400 = 643072,
+    #[doc = "1290240: 4800 baud."]
+    BAUD4800 = 1290240,
+    #[doc = "2576384: 9600 baud."]
+    BAUD9600 = 2576384,
+    #[doc = "3866624: 14400 baud."]
+    BAUD14400 = 3866624,
+    #[doc = "5152768: 19200 baud."]
+    BAUD19200 = 5152768,
+    #[doc = "7729152: 28800 baud."]
+    BAUD28800 = 7729152,
+    #[doc = "8388608: 31250 baud."]
+    BAUD31250 = 8388608,
+    #[doc = "10309632: 38400 baud."]
+    BAUD38400 = 10309632,
+    #[doc = "15007744: 56000 baud."]
+    BAUD56000 = 15007744,
+    #[doc = "15462400: 57600 baud."]
+    BAUD57600 = 15462400,
+    #[doc = "20615168: 76800 baud."]
+    BAUD76800 = 20615168,
+    #[doc = "30924800: 115200 baud."]
+    BAUD115200 = 30924800,
+    #[doc = "61845504: 230400 baud."]
+    BAUD230400 = 61845504,
+    #[doc = "67108864: 250000 baud."]
+    BAUD250000 = 67108864,
+    #[doc = "123695104: 460800 baud."]
+    BAUD460800 = 123695104,
+    #[doc = "247386112: 921600 baud."]
+    BAUD921600 = 247386112,
+    #[doc = "268435456: 1M baud."]
+    BAUD1M = 268435456,
+}
+impl From<BAUDRATE_A> for u32 {
+    #[inline(always)]
+    fn from(variant: BAUDRATE_A) -> Self {
+        variant as _
+    }
+}
+impl BAUDRATE_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> Option<BAUDRATE_A> {
+        match self.bits {
+            323584 => Some(BAUDRATE_A::BAUD1200),
+            643072 => Some(BAUDRATE_A::BAUD2400),
+            1290240 => Some(BAUDRATE_A::BAUD4800),
+            2576384 => Some(BAUDRATE_A::BAUD9600),
+            3866624 => Some(BAUDRATE_A::BAUD14400),
+            5152768 => Some(BAUDRATE_A::BAUD19200),
+            7729152 => Some(BAUDRATE_A::BAUD28800),
+            8388608 => Some(BAUDRATE_A::BAUD31250),
+            10309632 => Some(BAUDRATE_A::BAUD38400),
+            15007744 => Some(BAUDRATE_A::BAUD56000),
+            15462400 => Some(BAUDRATE_A::BAUD57600),
+            20615168 => Some(BAUDRATE_A::BAUD76800),
+            30924800 => Some(BAUDRATE_A::BAUD115200),
+            61845504 => Some(BAUDRATE_A::BAUD230400),
+            67108864 => Some(BAUDRATE_A::BAUD250000),
+            123695104 => Some(BAUDRATE_A::BAUD460800),
+            247386112 => Some(BAUDRATE_A::BAUD921600),
+            268435456 => Some(BAUDRATE_A::BAUD1M),
+            _ => None,
+        }
+    }
+    #[doc = "Checks if the value of the field is `BAUD1200`"]
+    #[inline(always)]
+    pub fn is_baud1200(&self) -> bool {
+        *self == BAUDRATE_A::BAUD1200
+    }
+    #[doc = "Checks if the value of the field is `BAUD2400`"]
+    #[inline(always)]
+    pub fn is_baud2400(&self) -> bool {
+        *self == BAUDRATE_A::BAUD2400
+    }
+    #[doc = "Checks if the value of the field is `BAUD4800`"]
+    #[inline(always)]
+    pub fn is_baud4800(&self) -> bool {
+        *self == BAUDRATE_A::BAUD4800
+    }
+    #[doc = "Checks if the value of the field is `BAUD9600`"]
+    #[inline(always)]
+    pub fn is_baud9600(&self) -> bool {
+        *self == BAUDRATE_A::BAUD9600
+    }
+    #[doc = "Checks if the value of the field is `BAUD14400`"]
+    #[inline(always)]
+    pub fn is_baud14400(&self) -> bool {
+        *self == BAUDRATE_A::BAUD14400
+    }
+    #[doc = "Checks if the value of the field is `BAUD19200`"]
+    #[inline(always)]
+    pub fn is_baud19200(&self) -> bool {
+        *self == BAUDRATE_A::BAUD19200
+    }
+    #[doc = "Checks if the value of the field is `BAUD28800`"]
+    #[inline(always)]
+    pub fn is_baud28800(&self) -> bool {
+        *self == BAUDRATE_A::BAUD28800
+    }
+    #[doc = "Checks if the value of the field is `BAUD31250`"]
+    #[inline(always)]
+    pub fn is_baud31250(&self) -> bool {
+        *self == BAUDRATE_A::BAUD31250
+    }
+    #[doc = "Checks if the value of the field is `BAUD38400`"]
+    #[inline(always)]
+    pub fn is_baud38400(&self) -> bool {
+        *self == BAUDRATE_A::BAUD38400
+    }
+    #[doc = "Checks if the value of the field is `BAUD56000`"]
+    #[inline(always)]
+    pub fn is_baud56000(&self) -> bool {
+        *self == BAUDRATE_A::BAUD56000
+    }
+    #[doc = "Checks if the value of the field is `BAUD57600`"]
+    #[inline(always)]
+    pub fn is_baud57600(&self) -> bool {
+        *self == BAUDRATE_A::BAUD57600
+    }
+    #[doc = "Checks if the value of the field is `BAUD76800`"]
+    #[inline(always)]
+    pub fn is_baud76800(&self) -> bool {
+        *self == BAUDRATE_A::BAUD76800
+    }
+    #[doc = "Checks if the value of the field is `BAUD115200`"]
+    #[inline(always)]
+    pub fn is_baud115200(&self) -> bool {
+        *self == BAUDRATE_A::BAUD115200
+    }
+    #[doc = "Checks if the value of the field is `BAUD230400`"]
+    #[inline(always)]
+    pub fn is_baud230400(&self) -> bool {
+        *self == BAUDRATE_A::BAUD230400
+    }
+    #[doc = "Checks if the value of the field is `BAUD250000`"]
+    #[inline(always)]
+    pub fn is_baud250000(&self) -> bool {
+        *self == BAUDRATE_A::BAUD250000
+    }
+    #[doc = "Checks if the value of the field is `BAUD460800`"]
+    #[inline(always)]
+    pub fn is_baud460800(&self) -> bool {
+        *self == BAUDRATE_A::BAUD460800
+    }
+    #[doc = "Checks if the value of the field is `BAUD921600`"]
+    #[inline(always)]
+    pub fn is_baud921600(&self) -> bool {
+        *self == BAUDRATE_A::BAUD921600
+    }
+    #[doc = "Checks if the value of the field is `BAUD1M`"]
+    #[inline(always)]
+    pub fn is_baud1m(&self) -> bool {
+        *self == BAUDRATE_A::BAUD1M
+    }
+}
+#[doc = "Field `BAUDRATE` writer - UART baudrate."]
+pub type BAUDRATE_W<'a, const O: u8> =
+    crate::FieldWriter<'a, u32, BAUDRATE_SPEC, u32, BAUDRATE_A, 32, O>;
+impl<'a, const O: u8> BAUDRATE_W<'a, O> {
+    #[doc = "1200 baud."]
+    #[inline(always)]
+    pub fn baud1200(self) -> &'a mut W {
+        self.variant(BAUDRATE_A::BAUD1200)
+    }
+    #[doc = "2400 baud."]
+    #[inline(always)]
+    pub fn baud2400(self) -> &'a mut W {
+        self.variant(BAUDRATE_A::BAUD2400)
+    }
+    #[doc = "4800 baud."]
+    #[inline(always)]
+    pub fn baud4800(self) -> &'a mut W {
+        self.variant(BAUDRATE_A::BAUD4800)
+    }
+    #[doc = "9600 baud."]
+    #[inline(always)]
+    pub fn baud9600(self) -> &'a mut W {
+        self.variant(BAUDRATE_A::BAUD9600)
+    }
+    #[doc = "14400 baud."]
+    #[inline(always)]
+    pub fn baud14400(self) -> &'a mut W {
+        self.variant(BAUDRATE_A::BAUD14400)
+    }
+    #[doc = "19200 baud."]
+    #[inline(always)]
+    pub fn baud19200(self) -> &'a mut W {
+        self.variant(BAUDRATE_A::BAUD19200)
+    }
+    #[doc = "28800 baud."]
+    #[inline(always)]
+    pub fn baud28800(self) -> &'a mut W {
+        self.variant(BAUDRATE_A::BAUD28800)
+    }
+    #[doc = "31250 baud."]
+    #[inline(always)]
+    pub fn baud31250(self) -> &'a mut W {
+        self.variant(BAUDRATE_A::BAUD31250)
+    }
+    #[doc = "38400 baud."]
+    #[inline(always)]
+    pub fn baud38400(self) -> &'a mut W {
+        self.variant(BAUDRATE_A::BAUD38400)
+    }
+    #[doc = "56000 baud."]
+    #[inline(always)]
+    pub fn baud56000(self) -> &'a mut W {
+        self.variant(BAUDRATE_A::BAUD56000)
+    }
+    #[doc = "57600 baud."]
+    #[inline(always)]
+    pub fn baud57600(self) -> &'a mut W {
+        self.variant(BAUDRATE_A::BAUD57600)
+    }
+    #[doc = "76800 baud."]
+    #[inline(always)]
+    pub fn baud76800(self) -> &'a mut W {
+        self.variant(BAUDRATE_A::BAUD76800)
+    }
+    #[doc = "115200 baud."]
+    #[inline(always)]
+    pub fn baud115200(self) -> &'a mut W {
+        self.variant(BAUDRATE_A::BAUD115200)
+    }
+    #[doc = "230400 baud."]
+    #[inline(always)]
+    pub fn baud230400(self) -> &'a mut W {
+        self.variant(BAUDRATE_A::BAUD230400)
+    }
+    #[doc = "250000 baud."]
+    #[inline(always)]
+    pub fn baud250000(self) -> &'a mut W {
+        self.variant(BAUDRATE_A::BAUD250000)
+    }
+    #[doc = "460800 baud."]
+    #[inline(always)]
+    pub fn baud460800(self) -> &'a mut W {
+        self.variant(BAUDRATE_A::BAUD460800)
+    }
+    #[doc = "921600 baud."]
+    #[inline(always)]
+    pub fn baud921600(self) -> &'a mut W {
+        self.variant(BAUDRATE_A::BAUD921600)
+    }
+    #[doc = "1M baud."]
+    #[inline(always)]
+    pub fn baud1m(self) -> &'a mut W {
+        self.variant(BAUDRATE_A::BAUD1M)
+    }
+}
+impl R {
+    #[doc = "Bits 0:31 - UART baudrate."]
+    #[inline(always)]
+    pub fn baudrate(&self) -> BAUDRATE_R {
+        BAUDRATE_R::new(self.bits)
+    }
+}
+impl W {
+    #[doc = "Bits 0:31 - UART baudrate."]
+    #[inline(always)]
+    pub fn baudrate(&mut self) -> BAUDRATE_W<0> {
+        BAUDRATE_W::new(self)
+    }
+    #[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 = "UART Baudrate.\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 [baudrate](index.html) module"]
+pub struct BAUDRATE_SPEC;
+impl crate::RegisterSpec for BAUDRATE_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [baudrate::R](R) reader structure"]
+impl crate::Readable for BAUDRATE_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [baudrate::W](W) writer structure"]
+impl crate::Writable for BAUDRATE_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets BAUDRATE to value 0"]
+impl crate::Resettable for BAUDRATE_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf51-pac/src/uart0/config.rs

@@ -0,0 +1,188 @@
+#[doc = "Register `CONFIG` reader"]
+pub struct R(crate::R<CONFIG_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<CONFIG_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<CONFIG_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<CONFIG_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `CONFIG` writer"]
+pub struct W(crate::W<CONFIG_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<CONFIG_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<CONFIG_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<CONFIG_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `HWFC` reader - Hardware flow control."]
+pub type HWFC_R = crate::BitReader<HWFC_A>;
+#[doc = "Hardware flow control.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum HWFC_A {
+    #[doc = "0: Hardware flow control disabled."]
+    DISABLED = 0,
+    #[doc = "1: Hardware flow control enabled."]
+    ENABLED = 1,
+}
+impl From<HWFC_A> for bool {
+    #[inline(always)]
+    fn from(variant: HWFC_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl HWFC_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> HWFC_A {
+        match self.bits {
+            false => HWFC_A::DISABLED,
+            true => HWFC_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == HWFC_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == HWFC_A::ENABLED
+    }
+}
+#[doc = "Field `HWFC` writer - Hardware flow control."]
+pub type HWFC_W<'a, const O: u8> = crate::BitWriter<'a, u32, CONFIG_SPEC, HWFC_A, O>;
+impl<'a, const O: u8> HWFC_W<'a, O> {
+    #[doc = "Hardware flow control disabled."]
+    #[inline(always)]
+    pub fn disabled(self) -> &'a mut W {
+        self.variant(HWFC_A::DISABLED)
+    }
+    #[doc = "Hardware flow control enabled."]
+    #[inline(always)]
+    pub fn enabled(self) -> &'a mut W {
+        self.variant(HWFC_A::ENABLED)
+    }
+}
+#[doc = "Field `PARITY` reader - Include parity bit."]
+pub type PARITY_R = crate::FieldReader<u8, PARITY_A>;
+#[doc = "Include parity bit.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+#[repr(u8)]
+pub enum PARITY_A {
+    #[doc = "0: Parity bit excluded."]
+    EXCLUDED = 0,
+    #[doc = "7: Parity bit included."]
+    INCLUDED = 7,
+}
+impl From<PARITY_A> for u8 {
+    #[inline(always)]
+    fn from(variant: PARITY_A) -> Self {
+        variant as _
+    }
+}
+impl PARITY_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> Option<PARITY_A> {
+        match self.bits {
+            0 => Some(PARITY_A::EXCLUDED),
+            7 => Some(PARITY_A::INCLUDED),
+            _ => None,
+        }
+    }
+    #[doc = "Checks if the value of the field is `EXCLUDED`"]
+    #[inline(always)]
+    pub fn is_excluded(&self) -> bool {
+        *self == PARITY_A::EXCLUDED
+    }
+    #[doc = "Checks if the value of the field is `INCLUDED`"]
+    #[inline(always)]
+    pub fn is_included(&self) -> bool {
+        *self == PARITY_A::INCLUDED
+    }
+}
+#[doc = "Field `PARITY` writer - Include parity bit."]
+pub type PARITY_W<'a, const O: u8> = crate::FieldWriter<'a, u32, CONFIG_SPEC, u8, PARITY_A, 3, O>;
+impl<'a, const O: u8> PARITY_W<'a, O> {
+    #[doc = "Parity bit excluded."]
+    #[inline(always)]
+    pub fn excluded(self) -> &'a mut W {
+        self.variant(PARITY_A::EXCLUDED)
+    }
+    #[doc = "Parity bit included."]
+    #[inline(always)]
+    pub fn included(self) -> &'a mut W {
+        self.variant(PARITY_A::INCLUDED)
+    }
+}
+impl R {
+    #[doc = "Bit 0 - Hardware flow control."]
+    #[inline(always)]
+    pub fn hwfc(&self) -> HWFC_R {
+        HWFC_R::new((self.bits & 1) != 0)
+    }
+    #[doc = "Bits 1:3 - Include parity bit."]
+    #[inline(always)]
+    pub fn parity(&self) -> PARITY_R {
+        PARITY_R::new(((self.bits >> 1) & 7) as u8)
+    }
+}
+impl W {
+    #[doc = "Bit 0 - Hardware flow control."]
+    #[inline(always)]
+    pub fn hwfc(&mut self) -> HWFC_W<0> {
+        HWFC_W::new(self)
+    }
+    #[doc = "Bits 1:3 - Include parity bit."]
+    #[inline(always)]
+    pub fn parity(&mut self) -> PARITY_W<1> {
+        PARITY_W::new(self)
+    }
+    #[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 = "Configuration of parity and hardware flow control register.\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 [config](index.html) module"]
+pub struct CONFIG_SPEC;
+impl crate::RegisterSpec for CONFIG_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [config::R](R) reader structure"]
+impl crate::Readable for CONFIG_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [config::W](W) writer structure"]
+impl crate::Writable for CONFIG_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets CONFIG to value 0"]
+impl crate::Resettable for CONFIG_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf51-pac/src/uart0/enable.rs

@@ -0,0 +1,128 @@
+#[doc = "Register `ENABLE` reader"]
+pub struct R(crate::R<ENABLE_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<ENABLE_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<ENABLE_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<ENABLE_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `ENABLE` writer"]
+pub struct W(crate::W<ENABLE_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<ENABLE_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<ENABLE_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<ENABLE_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `ENABLE` reader - Enable or disable UART and acquire IOs."]
+pub type ENABLE_R = crate::FieldReader<u8, ENABLE_A>;
+#[doc = "Enable or disable UART and acquire IOs.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+#[repr(u8)]
+pub enum ENABLE_A {
+    #[doc = "0: UART disabled."]
+    DISABLED = 0,
+    #[doc = "4: UART enabled."]
+    ENABLED = 4,
+}
+impl From<ENABLE_A> for u8 {
+    #[inline(always)]
+    fn from(variant: ENABLE_A) -> Self {
+        variant as _
+    }
+}
+impl ENABLE_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> Option<ENABLE_A> {
+        match self.bits {
+            0 => Some(ENABLE_A::DISABLED),
+            4 => Some(ENABLE_A::ENABLED),
+            _ => None,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == ENABLE_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == ENABLE_A::ENABLED
+    }
+}
+#[doc = "Field `ENABLE` writer - Enable or disable UART and acquire IOs."]
+pub type ENABLE_W<'a, const O: u8> = crate::FieldWriter<'a, u32, ENABLE_SPEC, u8, ENABLE_A, 3, O>;
+impl<'a, const O: u8> ENABLE_W<'a, O> {
+    #[doc = "UART disabled."]
+    #[inline(always)]
+    pub fn disabled(self) -> &'a mut W {
+        self.variant(ENABLE_A::DISABLED)
+    }
+    #[doc = "UART enabled."]
+    #[inline(always)]
+    pub fn enabled(self) -> &'a mut W {
+        self.variant(ENABLE_A::ENABLED)
+    }
+}
+impl R {
+    #[doc = "Bits 0:2 - Enable or disable UART and acquire IOs."]
+    #[inline(always)]
+    pub fn enable(&self) -> ENABLE_R {
+        ENABLE_R::new((self.bits & 7) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:2 - Enable or disable UART and acquire IOs."]
+    #[inline(always)]
+    pub fn enable(&mut self) -> ENABLE_W<0> {
+        ENABLE_W::new(self)
+    }
+    #[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 = "Enable UART and acquire IOs.\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 [enable](index.html) module"]
+pub struct ENABLE_SPEC;
+impl crate::RegisterSpec for ENABLE_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [enable::R](R) reader structure"]
+impl crate::Readable for ENABLE_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [enable::W](W) writer structure"]
+impl crate::Writable for ENABLE_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets ENABLE to value 0"]
+impl crate::Resettable for ENABLE_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf51-pac/src/uart0/errorsrc.rs

@@ -0,0 +1,334 @@
+#[doc = "Register `ERRORSRC` reader"]
+pub struct R(crate::R<ERRORSRC_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<ERRORSRC_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<ERRORSRC_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<ERRORSRC_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `ERRORSRC` writer"]
+pub struct W(crate::W<ERRORSRC_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<ERRORSRC_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<ERRORSRC_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<ERRORSRC_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `OVERRUN` reader - A start bit is received while the previous data still lies in RXD. (Data loss)."]
+pub type OVERRUN_R = crate::BitReader<OVERRUN_A>;
+#[doc = "A start bit is received while the previous data still lies in RXD. (Data loss).\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum OVERRUN_A {
+    #[doc = "0: Error not present."]
+    NOT_PRESENT = 0,
+    #[doc = "1: Error present."]
+    PRESENT = 1,
+}
+impl From<OVERRUN_A> for bool {
+    #[inline(always)]
+    fn from(variant: OVERRUN_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl OVERRUN_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> OVERRUN_A {
+        match self.bits {
+            false => OVERRUN_A::NOT_PRESENT,
+            true => OVERRUN_A::PRESENT,
+        }
+    }
+    #[doc = "Checks if the value of the field is `NOT_PRESENT`"]
+    #[inline(always)]
+    pub fn is_not_present(&self) -> bool {
+        *self == OVERRUN_A::NOT_PRESENT
+    }
+    #[doc = "Checks if the value of the field is `PRESENT`"]
+    #[inline(always)]
+    pub fn is_present(&self) -> bool {
+        *self == OVERRUN_A::PRESENT
+    }
+}
+#[doc = "A start bit is received while the previous data still lies in RXD. (Data loss).\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum OVERRUN_AW {
+    #[doc = "1: Clear error on write."]
+    CLEAR = 1,
+}
+impl From<OVERRUN_AW> for bool {
+    #[inline(always)]
+    fn from(variant: OVERRUN_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `OVERRUN` writer - A start bit is received while the previous data still lies in RXD. (Data loss)."]
+pub type OVERRUN_W<'a, const O: u8> = crate::BitWriter<'a, u32, ERRORSRC_SPEC, OVERRUN_AW, O>;
+impl<'a, const O: u8> OVERRUN_W<'a, O> {
+    #[doc = "Clear error on write."]
+    #[inline(always)]
+    pub fn clear(self) -> &'a mut W {
+        self.variant(OVERRUN_AW::CLEAR)
+    }
+}
+#[doc = "Field `PARITY` reader - A character with bad parity is received. Only checked if HW parity control is enabled."]
+pub type PARITY_R = crate::BitReader<PARITY_A>;
+#[doc = "A character with bad parity is received. Only checked if HW parity control is enabled.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum PARITY_A {
+    #[doc = "0: Error not present."]
+    NOT_PRESENT = 0,
+    #[doc = "1: Error present."]
+    PRESENT = 1,
+}
+impl From<PARITY_A> for bool {
+    #[inline(always)]
+    fn from(variant: PARITY_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl PARITY_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> PARITY_A {
+        match self.bits {
+            false => PARITY_A::NOT_PRESENT,
+            true => PARITY_A::PRESENT,
+        }
+    }
+    #[doc = "Checks if the value of the field is `NOT_PRESENT`"]
+    #[inline(always)]
+    pub fn is_not_present(&self) -> bool {
+        *self == PARITY_A::NOT_PRESENT
+    }
+    #[doc = "Checks if the value of the field is `PRESENT`"]
+    #[inline(always)]
+    pub fn is_present(&self) -> bool {
+        *self == PARITY_A::PRESENT
+    }
+}
+#[doc = "A character with bad parity is received. Only checked if HW parity control is enabled.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum PARITY_AW {
+    #[doc = "1: Clear error on write."]
+    CLEAR = 1,
+}
+impl From<PARITY_AW> for bool {
+    #[inline(always)]
+    fn from(variant: PARITY_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `PARITY` writer - A character with bad parity is received. Only checked if HW parity control is enabled."]
+pub type PARITY_W<'a, const O: u8> = crate::BitWriter<'a, u32, ERRORSRC_SPEC, PARITY_AW, O>;
+impl<'a, const O: u8> PARITY_W<'a, O> {
+    #[doc = "Clear error on write."]
+    #[inline(always)]
+    pub fn clear(self) -> &'a mut W {
+        self.variant(PARITY_AW::CLEAR)
+    }
+}
+#[doc = "Field `FRAMING` reader - A valid stop bit is not detected on the serial data input after all bits in a character have been received."]
+pub type FRAMING_R = crate::BitReader<FRAMING_A>;
+#[doc = "A valid stop bit is not detected on the serial data input after all bits in a character have been received.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum FRAMING_A {
+    #[doc = "0: Error not present."]
+    NOT_PRESENT = 0,
+    #[doc = "1: Error present."]
+    PRESENT = 1,
+}
+impl From<FRAMING_A> for bool {
+    #[inline(always)]
+    fn from(variant: FRAMING_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl FRAMING_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> FRAMING_A {
+        match self.bits {
+            false => FRAMING_A::NOT_PRESENT,
+            true => FRAMING_A::PRESENT,
+        }
+    }
+    #[doc = "Checks if the value of the field is `NOT_PRESENT`"]
+    #[inline(always)]
+    pub fn is_not_present(&self) -> bool {
+        *self == FRAMING_A::NOT_PRESENT
+    }
+    #[doc = "Checks if the value of the field is `PRESENT`"]
+    #[inline(always)]
+    pub fn is_present(&self) -> bool {
+        *self == FRAMING_A::PRESENT
+    }
+}
+#[doc = "A valid stop bit is not detected on the serial data input after all bits in a character have been received.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum FRAMING_AW {
+    #[doc = "1: Clear error on write."]
+    CLEAR = 1,
+}
+impl From<FRAMING_AW> for bool {
+    #[inline(always)]
+    fn from(variant: FRAMING_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `FRAMING` writer - A valid stop bit is not detected on the serial data input after all bits in a character have been received."]
+pub type FRAMING_W<'a, const O: u8> = crate::BitWriter<'a, u32, ERRORSRC_SPEC, FRAMING_AW, O>;
+impl<'a, const O: u8> FRAMING_W<'a, O> {
+    #[doc = "Clear error on write."]
+    #[inline(always)]
+    pub fn clear(self) -> &'a mut W {
+        self.variant(FRAMING_AW::CLEAR)
+    }
+}
+#[doc = "Field `BREAK` reader - The serial data input is '0' for longer than the length of a data frame."]
+pub type BREAK_R = crate::BitReader<BREAK_A>;
+#[doc = "The serial data input is '0' for longer than the length of a data frame.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum BREAK_A {
+    #[doc = "0: Error not present."]
+    NOT_PRESENT = 0,
+    #[doc = "1: Error present."]
+    PRESENT = 1,
+}
+impl From<BREAK_A> for bool {
+    #[inline(always)]
+    fn from(variant: BREAK_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl BREAK_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> BREAK_A {
+        match self.bits {
+            false => BREAK_A::NOT_PRESENT,
+            true => BREAK_A::PRESENT,
+        }
+    }
+    #[doc = "Checks if the value of the field is `NOT_PRESENT`"]
+    #[inline(always)]
+    pub fn is_not_present(&self) -> bool {
+        *self == BREAK_A::NOT_PRESENT
+    }
+    #[doc = "Checks if the value of the field is `PRESENT`"]
+    #[inline(always)]
+    pub fn is_present(&self) -> bool {
+        *self == BREAK_A::PRESENT
+    }
+}
+#[doc = "The serial data input is '0' for longer than the length of a data frame.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum BREAK_AW {
+    #[doc = "1: Clear error on write."]
+    CLEAR = 1,
+}
+impl From<BREAK_AW> for bool {
+    #[inline(always)]
+    fn from(variant: BREAK_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `BREAK` writer - The serial data input is '0' for longer than the length of a data frame."]
+pub type BREAK_W<'a, const O: u8> = crate::BitWriter<'a, u32, ERRORSRC_SPEC, BREAK_AW, O>;
+impl<'a, const O: u8> BREAK_W<'a, O> {
+    #[doc = "Clear error on write."]
+    #[inline(always)]
+    pub fn clear(self) -> &'a mut W {
+        self.variant(BREAK_AW::CLEAR)
+    }
+}
+impl R {
+    #[doc = "Bit 0 - A start bit is received while the previous data still lies in RXD. (Data loss)."]
+    #[inline(always)]
+    pub fn overrun(&self) -> OVERRUN_R {
+        OVERRUN_R::new((self.bits & 1) != 0)
+    }
+    #[doc = "Bit 1 - A character with bad parity is received. Only checked if HW parity control is enabled."]
+    #[inline(always)]
+    pub fn parity(&self) -> PARITY_R {
+        PARITY_R::new(((self.bits >> 1) & 1) != 0)
+    }
+    #[doc = "Bit 2 - A valid stop bit is not detected on the serial data input after all bits in a character have been received."]
+    #[inline(always)]
+    pub fn framing(&self) -> FRAMING_R {
+        FRAMING_R::new(((self.bits >> 2) & 1) != 0)
+    }
+    #[doc = "Bit 3 - The serial data input is '0' for longer than the length of a data frame."]
+    #[inline(always)]
+    pub fn break_(&self) -> BREAK_R {
+        BREAK_R::new(((self.bits >> 3) & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bit 0 - A start bit is received while the previous data still lies in RXD. (Data loss)."]
+    #[inline(always)]
+    pub fn overrun(&mut self) -> OVERRUN_W<0> {
+        OVERRUN_W::new(self)
+    }
+    #[doc = "Bit 1 - A character with bad parity is received. Only checked if HW parity control is enabled."]
+    #[inline(always)]
+    pub fn parity(&mut self) -> PARITY_W<1> {
+        PARITY_W::new(self)
+    }
+    #[doc = "Bit 2 - A valid stop bit is not detected on the serial data input after all bits in a character have been received."]
+    #[inline(always)]
+    pub fn framing(&mut self) -> FRAMING_W<2> {
+        FRAMING_W::new(self)
+    }
+    #[doc = "Bit 3 - The serial data input is '0' for longer than the length of a data frame."]
+    #[inline(always)]
+    pub fn break_(&mut self) -> BREAK_W<3> {
+        BREAK_W::new(self)
+    }
+    #[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 = "Error source. Write error field to 1 to clear error.\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 [errorsrc](index.html) module"]
+pub struct ERRORSRC_SPEC;
+impl crate::RegisterSpec for ERRORSRC_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [errorsrc::R](R) reader structure"]
+impl crate::Readable for ERRORSRC_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [errorsrc::W](W) writer structure"]
+impl crate::Writable for ERRORSRC_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets ERRORSRC to value 0"]
+impl crate::Resettable for ERRORSRC_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf51-pac/src/uart0/events_cts.rs

@@ -0,0 +1,64 @@
+#[doc = "Register `EVENTS_CTS` reader"]
+pub struct R(crate::R<EVENTS_CTS_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<EVENTS_CTS_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<EVENTS_CTS_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<EVENTS_CTS_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `EVENTS_CTS` writer"]
+pub struct W(crate::W<EVENTS_CTS_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<EVENTS_CTS_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<EVENTS_CTS_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<EVENTS_CTS_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 = "CTS activated.\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 [events_cts](index.html) module"]
+pub struct EVENTS_CTS_SPEC;
+impl crate::RegisterSpec for EVENTS_CTS_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [events_cts::R](R) reader structure"]
+impl crate::Readable for EVENTS_CTS_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [events_cts::W](W) writer structure"]
+impl crate::Writable for EVENTS_CTS_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets EVENTS_CTS to value 0"]
+impl crate::Resettable for EVENTS_CTS_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf51-pac/src/uart0/events_error.rs

@@ -0,0 +1,64 @@
+#[doc = "Register `EVENTS_ERROR` reader"]
+pub struct R(crate::R<EVENTS_ERROR_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<EVENTS_ERROR_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<EVENTS_ERROR_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<EVENTS_ERROR_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `EVENTS_ERROR` writer"]
+pub struct W(crate::W<EVENTS_ERROR_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<EVENTS_ERROR_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<EVENTS_ERROR_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<EVENTS_ERROR_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 = "Error detected.\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 [events_error](index.html) module"]
+pub struct EVENTS_ERROR_SPEC;
+impl crate::RegisterSpec for EVENTS_ERROR_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [events_error::R](R) reader structure"]
+impl crate::Readable for EVENTS_ERROR_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [events_error::W](W) writer structure"]
+impl crate::Writable for EVENTS_ERROR_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets EVENTS_ERROR to value 0"]
+impl crate::Resettable for EVENTS_ERROR_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf51-pac/src/uart0/events_ncts.rs

@@ -0,0 +1,64 @@
+#[doc = "Register `EVENTS_NCTS` reader"]
+pub struct R(crate::R<EVENTS_NCTS_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<EVENTS_NCTS_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<EVENTS_NCTS_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<EVENTS_NCTS_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `EVENTS_NCTS` writer"]
+pub struct W(crate::W<EVENTS_NCTS_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<EVENTS_NCTS_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<EVENTS_NCTS_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<EVENTS_NCTS_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 = "CTS deactivated.\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 [events_ncts](index.html) module"]
+pub struct EVENTS_NCTS_SPEC;
+impl crate::RegisterSpec for EVENTS_NCTS_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [events_ncts::R](R) reader structure"]
+impl crate::Readable for EVENTS_NCTS_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [events_ncts::W](W) writer structure"]
+impl crate::Writable for EVENTS_NCTS_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets EVENTS_NCTS to value 0"]
+impl crate::Resettable for EVENTS_NCTS_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf51-pac/src/uart0/events_rxdrdy.rs

@@ -0,0 +1,64 @@
+#[doc = "Register `EVENTS_RXDRDY` reader"]
+pub struct R(crate::R<EVENTS_RXDRDY_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<EVENTS_RXDRDY_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<EVENTS_RXDRDY_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<EVENTS_RXDRDY_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `EVENTS_RXDRDY` writer"]
+pub struct W(crate::W<EVENTS_RXDRDY_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<EVENTS_RXDRDY_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<EVENTS_RXDRDY_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<EVENTS_RXDRDY_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 = "Data received in RXD.\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 [events_rxdrdy](index.html) module"]
+pub struct EVENTS_RXDRDY_SPEC;
+impl crate::RegisterSpec for EVENTS_RXDRDY_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [events_rxdrdy::R](R) reader structure"]
+impl crate::Readable for EVENTS_RXDRDY_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [events_rxdrdy::W](W) writer structure"]
+impl crate::Writable for EVENTS_RXDRDY_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets EVENTS_RXDRDY to value 0"]
+impl crate::Resettable for EVENTS_RXDRDY_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf51-pac/src/uart0/events_rxto.rs

@@ -0,0 +1,64 @@
+#[doc = "Register `EVENTS_RXTO` reader"]
+pub struct R(crate::R<EVENTS_RXTO_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<EVENTS_RXTO_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<EVENTS_RXTO_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<EVENTS_RXTO_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `EVENTS_RXTO` writer"]
+pub struct W(crate::W<EVENTS_RXTO_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<EVENTS_RXTO_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<EVENTS_RXTO_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<EVENTS_RXTO_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 = "Receiver timeout.\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 [events_rxto](index.html) module"]
+pub struct EVENTS_RXTO_SPEC;
+impl crate::RegisterSpec for EVENTS_RXTO_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [events_rxto::R](R) reader structure"]
+impl crate::Readable for EVENTS_RXTO_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [events_rxto::W](W) writer structure"]
+impl crate::Writable for EVENTS_RXTO_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets EVENTS_RXTO to value 0"]
+impl crate::Resettable for EVENTS_RXTO_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf51-pac/src/uart0/events_txdrdy.rs

@@ -0,0 +1,64 @@
+#[doc = "Register `EVENTS_TXDRDY` reader"]
+pub struct R(crate::R<EVENTS_TXDRDY_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<EVENTS_TXDRDY_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<EVENTS_TXDRDY_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<EVENTS_TXDRDY_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `EVENTS_TXDRDY` writer"]
+pub struct W(crate::W<EVENTS_TXDRDY_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<EVENTS_TXDRDY_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<EVENTS_TXDRDY_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<EVENTS_TXDRDY_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 = "Data sent from TXD.\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 [events_txdrdy](index.html) module"]
+pub struct EVENTS_TXDRDY_SPEC;
+impl crate::RegisterSpec for EVENTS_TXDRDY_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [events_txdrdy::R](R) reader structure"]
+impl crate::Readable for EVENTS_TXDRDY_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [events_txdrdy::W](W) writer structure"]
+impl crate::Writable for EVENTS_TXDRDY_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets EVENTS_TXDRDY to value 0"]
+impl crate::Resettable for EVENTS_TXDRDY_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf51-pac/src/uart0/intenclr.rs

@@ -0,0 +1,468 @@
+#[doc = "Register `INTENCLR` reader"]
+pub struct R(crate::R<INTENCLR_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<INTENCLR_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<INTENCLR_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<INTENCLR_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `INTENCLR` writer"]
+pub struct W(crate::W<INTENCLR_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<INTENCLR_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<INTENCLR_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<INTENCLR_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `CTS` reader - Disable interrupt on CTS event."]
+pub type CTS_R = crate::BitReader<CTS_A>;
+#[doc = "Disable interrupt on CTS event.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum CTS_A {
+    #[doc = "0: Interrupt disabled."]
+    DISABLED = 0,
+    #[doc = "1: Interrupt enabled."]
+    ENABLED = 1,
+}
+impl From<CTS_A> for bool {
+    #[inline(always)]
+    fn from(variant: CTS_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl CTS_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> CTS_A {
+        match self.bits {
+            false => CTS_A::DISABLED,
+            true => CTS_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == CTS_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == CTS_A::ENABLED
+    }
+}
+#[doc = "Disable interrupt on CTS event.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum CTS_AW {
+    #[doc = "1: Disable interrupt on write."]
+    CLEAR = 1,
+}
+impl From<CTS_AW> for bool {
+    #[inline(always)]
+    fn from(variant: CTS_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `CTS` writer - Disable interrupt on CTS event."]
+pub type CTS_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, CTS_AW, O>;
+impl<'a, const O: u8> CTS_W<'a, O> {
+    #[doc = "Disable interrupt on write."]
+    #[inline(always)]
+    pub fn clear(self) -> &'a mut W {
+        self.variant(CTS_AW::CLEAR)
+    }
+}
+#[doc = "Field `NCTS` reader - Disable interrupt on NCTS event."]
+pub type NCTS_R = crate::BitReader<NCTS_A>;
+#[doc = "Disable interrupt on NCTS event.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum NCTS_A {
+    #[doc = "0: Interrupt disabled."]
+    DISABLED = 0,
+    #[doc = "1: Interrupt enabled."]
+    ENABLED = 1,
+}
+impl From<NCTS_A> for bool {
+    #[inline(always)]
+    fn from(variant: NCTS_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl NCTS_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> NCTS_A {
+        match self.bits {
+            false => NCTS_A::DISABLED,
+            true => NCTS_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == NCTS_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == NCTS_A::ENABLED
+    }
+}
+#[doc = "Disable interrupt on NCTS event.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum NCTS_AW {
+    #[doc = "1: Disable interrupt on write."]
+    CLEAR = 1,
+}
+impl From<NCTS_AW> for bool {
+    #[inline(always)]
+    fn from(variant: NCTS_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `NCTS` writer - Disable interrupt on NCTS event."]
+pub type NCTS_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, NCTS_AW, O>;
+impl<'a, const O: u8> NCTS_W<'a, O> {
+    #[doc = "Disable interrupt on write."]
+    #[inline(always)]
+    pub fn clear(self) -> &'a mut W {
+        self.variant(NCTS_AW::CLEAR)
+    }
+}
+#[doc = "Field `RXDRDY` reader - Disable interrupt on RXRDY event."]
+pub type RXDRDY_R = crate::BitReader<RXDRDY_A>;
+#[doc = "Disable interrupt on RXRDY event.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum RXDRDY_A {
+    #[doc = "0: Interrupt disabled."]
+    DISABLED = 0,
+    #[doc = "1: Interrupt enabled."]
+    ENABLED = 1,
+}
+impl From<RXDRDY_A> for bool {
+    #[inline(always)]
+    fn from(variant: RXDRDY_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl RXDRDY_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> RXDRDY_A {
+        match self.bits {
+            false => RXDRDY_A::DISABLED,
+            true => RXDRDY_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == RXDRDY_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == RXDRDY_A::ENABLED
+    }
+}
+#[doc = "Disable interrupt on RXRDY event.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum RXDRDY_AW {
+    #[doc = "1: Disable interrupt on write."]
+    CLEAR = 1,
+}
+impl From<RXDRDY_AW> for bool {
+    #[inline(always)]
+    fn from(variant: RXDRDY_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `RXDRDY` writer - Disable interrupt on RXRDY event."]
+pub type RXDRDY_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, RXDRDY_AW, O>;
+impl<'a, const O: u8> RXDRDY_W<'a, O> {
+    #[doc = "Disable interrupt on write."]
+    #[inline(always)]
+    pub fn clear(self) -> &'a mut W {
+        self.variant(RXDRDY_AW::CLEAR)
+    }
+}
+#[doc = "Field `TXDRDY` reader - Disable interrupt on TXRDY event."]
+pub type TXDRDY_R = crate::BitReader<TXDRDY_A>;
+#[doc = "Disable interrupt on TXRDY event.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum TXDRDY_A {
+    #[doc = "0: Interrupt disabled."]
+    DISABLED = 0,
+    #[doc = "1: Interrupt enabled."]
+    ENABLED = 1,
+}
+impl From<TXDRDY_A> for bool {
+    #[inline(always)]
+    fn from(variant: TXDRDY_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl TXDRDY_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> TXDRDY_A {
+        match self.bits {
+            false => TXDRDY_A::DISABLED,
+            true => TXDRDY_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == TXDRDY_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == TXDRDY_A::ENABLED
+    }
+}
+#[doc = "Disable interrupt on TXRDY event.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum TXDRDY_AW {
+    #[doc = "1: Disable interrupt on write."]
+    CLEAR = 1,
+}
+impl From<TXDRDY_AW> for bool {
+    #[inline(always)]
+    fn from(variant: TXDRDY_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `TXDRDY` writer - Disable interrupt on TXRDY event."]
+pub type TXDRDY_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, TXDRDY_AW, O>;
+impl<'a, const O: u8> TXDRDY_W<'a, O> {
+    #[doc = "Disable interrupt on write."]
+    #[inline(always)]
+    pub fn clear(self) -> &'a mut W {
+        self.variant(TXDRDY_AW::CLEAR)
+    }
+}
+#[doc = "Field `ERROR` reader - Disable interrupt on ERROR event."]
+pub type ERROR_R = crate::BitReader<ERROR_A>;
+#[doc = "Disable interrupt on ERROR event.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum ERROR_A {
+    #[doc = "0: Interrupt disabled."]
+    DISABLED = 0,
+    #[doc = "1: Interrupt enabled."]
+    ENABLED = 1,
+}
+impl From<ERROR_A> for bool {
+    #[inline(always)]
+    fn from(variant: ERROR_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl ERROR_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> ERROR_A {
+        match self.bits {
+            false => ERROR_A::DISABLED,
+            true => ERROR_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == ERROR_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == ERROR_A::ENABLED
+    }
+}
+#[doc = "Disable interrupt on ERROR event.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum ERROR_AW {
+    #[doc = "1: Disable interrupt on write."]
+    CLEAR = 1,
+}
+impl From<ERROR_AW> for bool {
+    #[inline(always)]
+    fn from(variant: ERROR_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `ERROR` writer - Disable interrupt on ERROR event."]
+pub type ERROR_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, ERROR_AW, O>;
+impl<'a, const O: u8> ERROR_W<'a, O> {
+    #[doc = "Disable interrupt on write."]
+    #[inline(always)]
+    pub fn clear(self) -> &'a mut W {
+        self.variant(ERROR_AW::CLEAR)
+    }
+}
+#[doc = "Field `RXTO` reader - Disable interrupt on RXTO event."]
+pub type RXTO_R = crate::BitReader<RXTO_A>;
+#[doc = "Disable interrupt on RXTO event.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum RXTO_A {
+    #[doc = "0: Interrupt disabled."]
+    DISABLED = 0,
+    #[doc = "1: Interrupt enabled."]
+    ENABLED = 1,
+}
+impl From<RXTO_A> for bool {
+    #[inline(always)]
+    fn from(variant: RXTO_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl RXTO_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> RXTO_A {
+        match self.bits {
+            false => RXTO_A::DISABLED,
+            true => RXTO_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == RXTO_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == RXTO_A::ENABLED
+    }
+}
+#[doc = "Disable interrupt on RXTO event.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum RXTO_AW {
+    #[doc = "1: Disable interrupt on write."]
+    CLEAR = 1,
+}
+impl From<RXTO_AW> for bool {
+    #[inline(always)]
+    fn from(variant: RXTO_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `RXTO` writer - Disable interrupt on RXTO event."]
+pub type RXTO_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, RXTO_AW, O>;
+impl<'a, const O: u8> RXTO_W<'a, O> {
+    #[doc = "Disable interrupt on write."]
+    #[inline(always)]
+    pub fn clear(self) -> &'a mut W {
+        self.variant(RXTO_AW::CLEAR)
+    }
+}
+impl R {
+    #[doc = "Bit 0 - Disable interrupt on CTS event."]
+    #[inline(always)]
+    pub fn cts(&self) -> CTS_R {
+        CTS_R::new((self.bits & 1) != 0)
+    }
+    #[doc = "Bit 1 - Disable interrupt on NCTS event."]
+    #[inline(always)]
+    pub fn ncts(&self) -> NCTS_R {
+        NCTS_R::new(((self.bits >> 1) & 1) != 0)
+    }
+    #[doc = "Bit 2 - Disable interrupt on RXRDY event."]
+    #[inline(always)]
+    pub fn rxdrdy(&self) -> RXDRDY_R {
+        RXDRDY_R::new(((self.bits >> 2) & 1) != 0)
+    }
+    #[doc = "Bit 7 - Disable interrupt on TXRDY event."]
+    #[inline(always)]
+    pub fn txdrdy(&self) -> TXDRDY_R {
+        TXDRDY_R::new(((self.bits >> 7) & 1) != 0)
+    }
+    #[doc = "Bit 9 - Disable interrupt on ERROR event."]
+    #[inline(always)]
+    pub fn error(&self) -> ERROR_R {
+        ERROR_R::new(((self.bits >> 9) & 1) != 0)
+    }
+    #[doc = "Bit 17 - Disable interrupt on RXTO event."]
+    #[inline(always)]
+    pub fn rxto(&self) -> RXTO_R {
+        RXTO_R::new(((self.bits >> 17) & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bit 0 - Disable interrupt on CTS event."]
+    #[inline(always)]
+    pub fn cts(&mut self) -> CTS_W<0> {
+        CTS_W::new(self)
+    }
+    #[doc = "Bit 1 - Disable interrupt on NCTS event."]
+    #[inline(always)]
+    pub fn ncts(&mut self) -> NCTS_W<1> {
+        NCTS_W::new(self)
+    }
+    #[doc = "Bit 2 - Disable interrupt on RXRDY event."]
+    #[inline(always)]
+    pub fn rxdrdy(&mut self) -> RXDRDY_W<2> {
+        RXDRDY_W::new(self)
+    }
+    #[doc = "Bit 7 - Disable interrupt on TXRDY event."]
+    #[inline(always)]
+    pub fn txdrdy(&mut self) -> TXDRDY_W<7> {
+        TXDRDY_W::new(self)
+    }
+    #[doc = "Bit 9 - Disable interrupt on ERROR event."]
+    #[inline(always)]
+    pub fn error(&mut self) -> ERROR_W<9> {
+        ERROR_W::new(self)
+    }
+    #[doc = "Bit 17 - Disable interrupt on RXTO event."]
+    #[inline(always)]
+    pub fn rxto(&mut self) -> RXTO_W<17> {
+        RXTO_W::new(self)
+    }
+    #[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 = "Interrupt enable clear register.\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 [intenclr](index.html) module"]
+pub struct INTENCLR_SPEC;
+impl crate::RegisterSpec for INTENCLR_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [intenclr::R](R) reader structure"]
+impl crate::Readable for INTENCLR_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [intenclr::W](W) writer structure"]
+impl crate::Writable for INTENCLR_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets INTENCLR to value 0"]
+impl crate::Resettable for INTENCLR_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf51-pac/src/uart0/intenset.rs

@@ -0,0 +1,468 @@
+#[doc = "Register `INTENSET` reader"]
+pub struct R(crate::R<INTENSET_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<INTENSET_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<INTENSET_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<INTENSET_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `INTENSET` writer"]
+pub struct W(crate::W<INTENSET_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<INTENSET_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<INTENSET_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<INTENSET_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `CTS` reader - Enable interrupt on CTS event."]
+pub type CTS_R = crate::BitReader<CTS_A>;
+#[doc = "Enable interrupt on CTS event.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum CTS_A {
+    #[doc = "0: Interrupt disabled."]
+    DISABLED = 0,
+    #[doc = "1: Interrupt enabled."]
+    ENABLED = 1,
+}
+impl From<CTS_A> for bool {
+    #[inline(always)]
+    fn from(variant: CTS_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl CTS_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> CTS_A {
+        match self.bits {
+            false => CTS_A::DISABLED,
+            true => CTS_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == CTS_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == CTS_A::ENABLED
+    }
+}
+#[doc = "Enable interrupt on CTS event.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum CTS_AW {
+    #[doc = "1: Enable interrupt on write."]
+    SET = 1,
+}
+impl From<CTS_AW> for bool {
+    #[inline(always)]
+    fn from(variant: CTS_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `CTS` writer - Enable interrupt on CTS event."]
+pub type CTS_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, CTS_AW, O>;
+impl<'a, const O: u8> CTS_W<'a, O> {
+    #[doc = "Enable interrupt on write."]
+    #[inline(always)]
+    pub fn set(self) -> &'a mut W {
+        self.variant(CTS_AW::SET)
+    }
+}
+#[doc = "Field `NCTS` reader - Enable interrupt on NCTS event."]
+pub type NCTS_R = crate::BitReader<NCTS_A>;
+#[doc = "Enable interrupt on NCTS event.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum NCTS_A {
+    #[doc = "0: Interrupt disabled."]
+    DISABLED = 0,
+    #[doc = "1: Interrupt enabled."]
+    ENABLED = 1,
+}
+impl From<NCTS_A> for bool {
+    #[inline(always)]
+    fn from(variant: NCTS_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl NCTS_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> NCTS_A {
+        match self.bits {
+            false => NCTS_A::DISABLED,
+            true => NCTS_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == NCTS_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == NCTS_A::ENABLED
+    }
+}
+#[doc = "Enable interrupt on NCTS event.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum NCTS_AW {
+    #[doc = "1: Enable interrupt on write."]
+    SET = 1,
+}
+impl From<NCTS_AW> for bool {
+    #[inline(always)]
+    fn from(variant: NCTS_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `NCTS` writer - Enable interrupt on NCTS event."]
+pub type NCTS_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, NCTS_AW, O>;
+impl<'a, const O: u8> NCTS_W<'a, O> {
+    #[doc = "Enable interrupt on write."]
+    #[inline(always)]
+    pub fn set(self) -> &'a mut W {
+        self.variant(NCTS_AW::SET)
+    }
+}
+#[doc = "Field `RXDRDY` reader - Enable interrupt on RXRDY event."]
+pub type RXDRDY_R = crate::BitReader<RXDRDY_A>;
+#[doc = "Enable interrupt on RXRDY event.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum RXDRDY_A {
+    #[doc = "0: Interrupt disabled."]
+    DISABLED = 0,
+    #[doc = "1: Interrupt enabled."]
+    ENABLED = 1,
+}
+impl From<RXDRDY_A> for bool {
+    #[inline(always)]
+    fn from(variant: RXDRDY_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl RXDRDY_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> RXDRDY_A {
+        match self.bits {
+            false => RXDRDY_A::DISABLED,
+            true => RXDRDY_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == RXDRDY_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == RXDRDY_A::ENABLED
+    }
+}
+#[doc = "Enable interrupt on RXRDY event.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum RXDRDY_AW {
+    #[doc = "1: Enable interrupt on write."]
+    SET = 1,
+}
+impl From<RXDRDY_AW> for bool {
+    #[inline(always)]
+    fn from(variant: RXDRDY_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `RXDRDY` writer - Enable interrupt on RXRDY event."]
+pub type RXDRDY_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, RXDRDY_AW, O>;
+impl<'a, const O: u8> RXDRDY_W<'a, O> {
+    #[doc = "Enable interrupt on write."]
+    #[inline(always)]
+    pub fn set(self) -> &'a mut W {
+        self.variant(RXDRDY_AW::SET)
+    }
+}
+#[doc = "Field `TXDRDY` reader - Enable interrupt on TXRDY event."]
+pub type TXDRDY_R = crate::BitReader<TXDRDY_A>;
+#[doc = "Enable interrupt on TXRDY event.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum TXDRDY_A {
+    #[doc = "0: Interrupt disabled."]
+    DISABLED = 0,
+    #[doc = "1: Interrupt enabled."]
+    ENABLED = 1,
+}
+impl From<TXDRDY_A> for bool {
+    #[inline(always)]
+    fn from(variant: TXDRDY_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl TXDRDY_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> TXDRDY_A {
+        match self.bits {
+            false => TXDRDY_A::DISABLED,
+            true => TXDRDY_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == TXDRDY_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == TXDRDY_A::ENABLED
+    }
+}
+#[doc = "Enable interrupt on TXRDY event.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum TXDRDY_AW {
+    #[doc = "1: Enable interrupt on write."]
+    SET = 1,
+}
+impl From<TXDRDY_AW> for bool {
+    #[inline(always)]
+    fn from(variant: TXDRDY_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `TXDRDY` writer - Enable interrupt on TXRDY event."]
+pub type TXDRDY_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, TXDRDY_AW, O>;
+impl<'a, const O: u8> TXDRDY_W<'a, O> {
+    #[doc = "Enable interrupt on write."]
+    #[inline(always)]
+    pub fn set(self) -> &'a mut W {
+        self.variant(TXDRDY_AW::SET)
+    }
+}
+#[doc = "Field `ERROR` reader - Enable interrupt on ERROR event."]
+pub type ERROR_R = crate::BitReader<ERROR_A>;
+#[doc = "Enable interrupt on ERROR event.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum ERROR_A {
+    #[doc = "0: Interrupt disabled."]
+    DISABLED = 0,
+    #[doc = "1: Interrupt enabled."]
+    ENABLED = 1,
+}
+impl From<ERROR_A> for bool {
+    #[inline(always)]
+    fn from(variant: ERROR_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl ERROR_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> ERROR_A {
+        match self.bits {
+            false => ERROR_A::DISABLED,
+            true => ERROR_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == ERROR_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == ERROR_A::ENABLED
+    }
+}
+#[doc = "Enable interrupt on ERROR event.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum ERROR_AW {
+    #[doc = "1: Enable interrupt on write."]
+    SET = 1,
+}
+impl From<ERROR_AW> for bool {
+    #[inline(always)]
+    fn from(variant: ERROR_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `ERROR` writer - Enable interrupt on ERROR event."]
+pub type ERROR_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, ERROR_AW, O>;
+impl<'a, const O: u8> ERROR_W<'a, O> {
+    #[doc = "Enable interrupt on write."]
+    #[inline(always)]
+    pub fn set(self) -> &'a mut W {
+        self.variant(ERROR_AW::SET)
+    }
+}
+#[doc = "Field `RXTO` reader - Enable interrupt on RXTO event."]
+pub type RXTO_R = crate::BitReader<RXTO_A>;
+#[doc = "Enable interrupt on RXTO event.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum RXTO_A {
+    #[doc = "0: Interrupt disabled."]
+    DISABLED = 0,
+    #[doc = "1: Interrupt enabled."]
+    ENABLED = 1,
+}
+impl From<RXTO_A> for bool {
+    #[inline(always)]
+    fn from(variant: RXTO_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl RXTO_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> RXTO_A {
+        match self.bits {
+            false => RXTO_A::DISABLED,
+            true => RXTO_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == RXTO_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == RXTO_A::ENABLED
+    }
+}
+#[doc = "Enable interrupt on RXTO event.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum RXTO_AW {
+    #[doc = "1: Enable interrupt on write."]
+    SET = 1,
+}
+impl From<RXTO_AW> for bool {
+    #[inline(always)]
+    fn from(variant: RXTO_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `RXTO` writer - Enable interrupt on RXTO event."]
+pub type RXTO_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, RXTO_AW, O>;
+impl<'a, const O: u8> RXTO_W<'a, O> {
+    #[doc = "Enable interrupt on write."]
+    #[inline(always)]
+    pub fn set(self) -> &'a mut W {
+        self.variant(RXTO_AW::SET)
+    }
+}
+impl R {
+    #[doc = "Bit 0 - Enable interrupt on CTS event."]
+    #[inline(always)]
+    pub fn cts(&self) -> CTS_R {
+        CTS_R::new((self.bits & 1) != 0)
+    }
+    #[doc = "Bit 1 - Enable interrupt on NCTS event."]
+    #[inline(always)]
+    pub fn ncts(&self) -> NCTS_R {
+        NCTS_R::new(((self.bits >> 1) & 1) != 0)
+    }
+    #[doc = "Bit 2 - Enable interrupt on RXRDY event."]
+    #[inline(always)]
+    pub fn rxdrdy(&self) -> RXDRDY_R {
+        RXDRDY_R::new(((self.bits >> 2) & 1) != 0)
+    }
+    #[doc = "Bit 7 - Enable interrupt on TXRDY event."]
+    #[inline(always)]
+    pub fn txdrdy(&self) -> TXDRDY_R {
+        TXDRDY_R::new(((self.bits >> 7) & 1) != 0)
+    }
+    #[doc = "Bit 9 - Enable interrupt on ERROR event."]
+    #[inline(always)]
+    pub fn error(&self) -> ERROR_R {
+        ERROR_R::new(((self.bits >> 9) & 1) != 0)
+    }
+    #[doc = "Bit 17 - Enable interrupt on RXTO event."]
+    #[inline(always)]
+    pub fn rxto(&self) -> RXTO_R {
+        RXTO_R::new(((self.bits >> 17) & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bit 0 - Enable interrupt on CTS event."]
+    #[inline(always)]
+    pub fn cts(&mut self) -> CTS_W<0> {
+        CTS_W::new(self)
+    }
+    #[doc = "Bit 1 - Enable interrupt on NCTS event."]
+    #[inline(always)]
+    pub fn ncts(&mut self) -> NCTS_W<1> {
+        NCTS_W::new(self)
+    }
+    #[doc = "Bit 2 - Enable interrupt on RXRDY event."]
+    #[inline(always)]
+    pub fn rxdrdy(&mut self) -> RXDRDY_W<2> {
+        RXDRDY_W::new(self)
+    }
+    #[doc = "Bit 7 - Enable interrupt on TXRDY event."]
+    #[inline(always)]
+    pub fn txdrdy(&mut self) -> TXDRDY_W<7> {
+        TXDRDY_W::new(self)
+    }
+    #[doc = "Bit 9 - Enable interrupt on ERROR event."]
+    #[inline(always)]
+    pub fn error(&mut self) -> ERROR_W<9> {
+        ERROR_W::new(self)
+    }
+    #[doc = "Bit 17 - Enable interrupt on RXTO event."]
+    #[inline(always)]
+    pub fn rxto(&mut self) -> RXTO_W<17> {
+        RXTO_W::new(self)
+    }
+    #[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 = "Interrupt enable set register.\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 [intenset](index.html) module"]
+pub struct INTENSET_SPEC;
+impl crate::RegisterSpec for INTENSET_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [intenset::R](R) reader structure"]
+impl crate::Readable for INTENSET_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [intenset::W](W) writer structure"]
+impl crate::Writable for INTENSET_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets INTENSET to value 0"]
+impl crate::Resettable for INTENSET_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf51-pac/src/uart0/power.rs

@@ -0,0 +1,126 @@
+#[doc = "Register `POWER` reader"]
+pub struct R(crate::R<POWER_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<POWER_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<POWER_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<POWER_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `POWER` writer"]
+pub struct W(crate::W<POWER_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<POWER_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<POWER_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<POWER_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `POWER` reader - Peripheral power control."]
+pub type POWER_R = crate::BitReader<POWER_A>;
+#[doc = "Peripheral power control.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum POWER_A {
+    #[doc = "0: Module power disabled."]
+    DISABLED = 0,
+    #[doc = "1: Module power enabled."]
+    ENABLED = 1,
+}
+impl From<POWER_A> for bool {
+    #[inline(always)]
+    fn from(variant: POWER_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl POWER_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> POWER_A {
+        match self.bits {
+            false => POWER_A::DISABLED,
+            true => POWER_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == POWER_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == POWER_A::ENABLED
+    }
+}
+#[doc = "Field `POWER` writer - Peripheral power control."]
+pub type POWER_W<'a, const O: u8> = crate::BitWriter<'a, u32, POWER_SPEC, POWER_A, O>;
+impl<'a, const O: u8> POWER_W<'a, O> {
+    #[doc = "Module power disabled."]
+    #[inline(always)]
+    pub fn disabled(self) -> &'a mut W {
+        self.variant(POWER_A::DISABLED)
+    }
+    #[doc = "Module power enabled."]
+    #[inline(always)]
+    pub fn enabled(self) -> &'a mut W {
+        self.variant(POWER_A::ENABLED)
+    }
+}
+impl R {
+    #[doc = "Bit 0 - Peripheral power control."]
+    #[inline(always)]
+    pub fn power(&self) -> POWER_R {
+        POWER_R::new((self.bits & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bit 0 - Peripheral power control."]
+    #[inline(always)]
+    pub fn power(&mut self) -> POWER_W<0> {
+        POWER_W::new(self)
+    }
+    #[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 = "Peripheral power control.\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 [power](index.html) module"]
+pub struct POWER_SPEC;
+impl crate::RegisterSpec for POWER_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [power::R](R) reader structure"]
+impl crate::Readable for POWER_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [power::W](W) writer structure"]
+impl crate::Writable for POWER_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets POWER to value 0"]
+impl crate::Resettable for POWER_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf51-pac/src/uart0/pselcts.rs

@@ -0,0 +1,64 @@
+#[doc = "Register `PSELCTS` reader"]
+pub struct R(crate::R<PSELCTS_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<PSELCTS_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<PSELCTS_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<PSELCTS_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `PSELCTS` writer"]
+pub struct W(crate::W<PSELCTS_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<PSELCTS_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<PSELCTS_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<PSELCTS_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 = "Pin select for CTS.\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 [pselcts](index.html) module"]
+pub struct PSELCTS_SPEC;
+impl crate::RegisterSpec for PSELCTS_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [pselcts::R](R) reader structure"]
+impl crate::Readable for PSELCTS_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [pselcts::W](W) writer structure"]
+impl crate::Writable for PSELCTS_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets PSELCTS to value 0xffff_ffff"]
+impl crate::Resettable for PSELCTS_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0xffff_ffff
+    }
+}

vendor/nrf51-pac/src/uart0/pselrts.rs

@@ -0,0 +1,64 @@
+#[doc = "Register `PSELRTS` reader"]
+pub struct R(crate::R<PSELRTS_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<PSELRTS_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<PSELRTS_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<PSELRTS_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `PSELRTS` writer"]
+pub struct W(crate::W<PSELRTS_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<PSELRTS_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<PSELRTS_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<PSELRTS_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 = "Pin select for RTS.\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 [pselrts](index.html) module"]
+pub struct PSELRTS_SPEC;
+impl crate::RegisterSpec for PSELRTS_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [pselrts::R](R) reader structure"]
+impl crate::Readable for PSELRTS_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [pselrts::W](W) writer structure"]
+impl crate::Writable for PSELRTS_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets PSELRTS to value 0xffff_ffff"]
+impl crate::Resettable for PSELRTS_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0xffff_ffff
+    }
+}

vendor/nrf51-pac/src/uart0/pselrxd.rs

@@ -0,0 +1,64 @@
+#[doc = "Register `PSELRXD` reader"]
+pub struct R(crate::R<PSELRXD_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<PSELRXD_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<PSELRXD_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<PSELRXD_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `PSELRXD` writer"]
+pub struct W(crate::W<PSELRXD_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<PSELRXD_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<PSELRXD_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<PSELRXD_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 = "Pin select for RXD.\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 [pselrxd](index.html) module"]
+pub struct PSELRXD_SPEC;
+impl crate::RegisterSpec for PSELRXD_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [pselrxd::R](R) reader structure"]
+impl crate::Readable for PSELRXD_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [pselrxd::W](W) writer structure"]
+impl crate::Writable for PSELRXD_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets PSELRXD to value 0xffff_ffff"]
+impl crate::Resettable for PSELRXD_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0xffff_ffff
+    }
+}

vendor/nrf51-pac/src/uart0/pseltxd.rs

@@ -0,0 +1,64 @@
+#[doc = "Register `PSELTXD` reader"]
+pub struct R(crate::R<PSELTXD_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<PSELTXD_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<PSELTXD_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<PSELTXD_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `PSELTXD` writer"]
+pub struct W(crate::W<PSELTXD_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<PSELTXD_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<PSELTXD_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<PSELTXD_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 = "Pin select for TXD.\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 [pseltxd](index.html) module"]
+pub struct PSELTXD_SPEC;
+impl crate::RegisterSpec for PSELTXD_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [pseltxd::R](R) reader structure"]
+impl crate::Readable for PSELTXD_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [pseltxd::W](W) writer structure"]
+impl crate::Writable for PSELTXD_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets PSELTXD to value 0xffff_ffff"]
+impl crate::Resettable for PSELTXD_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0xffff_ffff
+    }
+}

vendor/nrf51-pac/src/uart0/rxd.rs

@@ -0,0 +1,40 @@
+#[doc = "Register `RXD` reader"]
+pub struct R(crate::R<RXD_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<RXD_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<RXD_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<RXD_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `RXD` reader - RX data from previous transfer. Double buffered."]
+pub type RXD_R = crate::FieldReader<u8, u8>;
+impl R {
+    #[doc = "Bits 0:7 - RX data from previous transfer. Double buffered."]
+    #[inline(always)]
+    pub fn rxd(&self) -> RXD_R {
+        RXD_R::new((self.bits & 0xff) as u8)
+    }
+}
+#[doc = "RXD register. On read action the buffer pointer is displaced. Once read the character is consumed. If read when no character available, the UART will stop working.\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 [rxd](index.html) module\n\nOne or more dependent resources other than the current register are immediately affected by a read operation."]
+pub struct RXD_SPEC;
+impl crate::RegisterSpec for RXD_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [rxd::R](R) reader structure"]
+impl crate::Readable for RXD_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets RXD to value 0"]
+impl crate::Resettable for RXD_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf51-pac/src/uart0/shorts.rs

@@ -0,0 +1,186 @@
+#[doc = "Register `SHORTS` reader"]
+pub struct R(crate::R<SHORTS_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<SHORTS_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<SHORTS_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<SHORTS_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `SHORTS` writer"]
+pub struct W(crate::W<SHORTS_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<SHORTS_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<SHORTS_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<SHORTS_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `CTS_STARTRX` reader - Shortcut between CTS event and STARTRX task."]
+pub type CTS_STARTRX_R = crate::BitReader<CTS_STARTRX_A>;
+#[doc = "Shortcut between CTS event and STARTRX task.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum CTS_STARTRX_A {
+    #[doc = "0: Shortcut disabled."]
+    DISABLED = 0,
+    #[doc = "1: Shortcut enabled."]
+    ENABLED = 1,
+}
+impl From<CTS_STARTRX_A> for bool {
+    #[inline(always)]
+    fn from(variant: CTS_STARTRX_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl CTS_STARTRX_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> CTS_STARTRX_A {
+        match self.bits {
+            false => CTS_STARTRX_A::DISABLED,
+            true => CTS_STARTRX_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == CTS_STARTRX_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == CTS_STARTRX_A::ENABLED
+    }
+}
+#[doc = "Field `CTS_STARTRX` writer - Shortcut between CTS event and STARTRX task."]
+pub type CTS_STARTRX_W<'a, const O: u8> = crate::BitWriter<'a, u32, SHORTS_SPEC, CTS_STARTRX_A, O>;
+impl<'a, const O: u8> CTS_STARTRX_W<'a, O> {
+    #[doc = "Shortcut disabled."]
+    #[inline(always)]
+    pub fn disabled(self) -> &'a mut W {
+        self.variant(CTS_STARTRX_A::DISABLED)
+    }
+    #[doc = "Shortcut enabled."]
+    #[inline(always)]
+    pub fn enabled(self) -> &'a mut W {
+        self.variant(CTS_STARTRX_A::ENABLED)
+    }
+}
+#[doc = "Field `NCTS_STOPRX` reader - Shortcut between NCTS event and STOPRX task."]
+pub type NCTS_STOPRX_R = crate::BitReader<NCTS_STOPRX_A>;
+#[doc = "Shortcut between NCTS event and STOPRX task.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum NCTS_STOPRX_A {
+    #[doc = "0: Shortcut disabled."]
+    DISABLED = 0,
+    #[doc = "1: Shortcut enabled."]
+    ENABLED = 1,
+}
+impl From<NCTS_STOPRX_A> for bool {
+    #[inline(always)]
+    fn from(variant: NCTS_STOPRX_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl NCTS_STOPRX_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> NCTS_STOPRX_A {
+        match self.bits {
+            false => NCTS_STOPRX_A::DISABLED,
+            true => NCTS_STOPRX_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == NCTS_STOPRX_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == NCTS_STOPRX_A::ENABLED
+    }
+}
+#[doc = "Field `NCTS_STOPRX` writer - Shortcut between NCTS event and STOPRX task."]
+pub type NCTS_STOPRX_W<'a, const O: u8> = crate::BitWriter<'a, u32, SHORTS_SPEC, NCTS_STOPRX_A, O>;
+impl<'a, const O: u8> NCTS_STOPRX_W<'a, O> {
+    #[doc = "Shortcut disabled."]
+    #[inline(always)]
+    pub fn disabled(self) -> &'a mut W {
+        self.variant(NCTS_STOPRX_A::DISABLED)
+    }
+    #[doc = "Shortcut enabled."]
+    #[inline(always)]
+    pub fn enabled(self) -> &'a mut W {
+        self.variant(NCTS_STOPRX_A::ENABLED)
+    }
+}
+impl R {
+    #[doc = "Bit 3 - Shortcut between CTS event and STARTRX task."]
+    #[inline(always)]
+    pub fn cts_startrx(&self) -> CTS_STARTRX_R {
+        CTS_STARTRX_R::new(((self.bits >> 3) & 1) != 0)
+    }
+    #[doc = "Bit 4 - Shortcut between NCTS event and STOPRX task."]
+    #[inline(always)]
+    pub fn ncts_stoprx(&self) -> NCTS_STOPRX_R {
+        NCTS_STOPRX_R::new(((self.bits >> 4) & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bit 3 - Shortcut between CTS event and STARTRX task."]
+    #[inline(always)]
+    pub fn cts_startrx(&mut self) -> CTS_STARTRX_W<3> {
+        CTS_STARTRX_W::new(self)
+    }
+    #[doc = "Bit 4 - Shortcut between NCTS event and STOPRX task."]
+    #[inline(always)]
+    pub fn ncts_stoprx(&mut self) -> NCTS_STOPRX_W<4> {
+        NCTS_STOPRX_W::new(self)
+    }
+    #[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 = "Shortcuts for UART.\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 [shorts](index.html) module"]
+pub struct SHORTS_SPEC;
+impl crate::RegisterSpec for SHORTS_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [shorts::R](R) reader structure"]
+impl crate::Readable for SHORTS_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [shorts::W](W) writer structure"]
+impl crate::Writable for SHORTS_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets SHORTS to value 0"]
+impl crate::Resettable for SHORTS_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf51-pac/src/uart0/tasks_startrx.rs

@@ -0,0 +1,45 @@
+#[doc = "Register `TASKS_STARTRX` writer"]
+pub struct W(crate::W<TASKS_STARTRX_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<TASKS_STARTRX_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<TASKS_STARTRX_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<TASKS_STARTRX_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 = "Start UART receiver.\n\nThis register you can [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [tasks_startrx](index.html) module"]
+pub struct TASKS_STARTRX_SPEC;
+impl crate::RegisterSpec for TASKS_STARTRX_SPEC {
+    type Ux = u32;
+}
+#[doc = "`write(|w| ..)` method takes [tasks_startrx::W](W) writer structure"]
+impl crate::Writable for TASKS_STARTRX_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets TASKS_STARTRX to value 0"]
+impl crate::Resettable for TASKS_STARTRX_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf51-pac/src/uart0/tasks_starttx.rs

@@ -0,0 +1,45 @@
+#[doc = "Register `TASKS_STARTTX` writer"]
+pub struct W(crate::W<TASKS_STARTTX_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<TASKS_STARTTX_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<TASKS_STARTTX_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<TASKS_STARTTX_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 = "Start UART transmitter.\n\nThis register you can [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [tasks_starttx](index.html) module"]
+pub struct TASKS_STARTTX_SPEC;
+impl crate::RegisterSpec for TASKS_STARTTX_SPEC {
+    type Ux = u32;
+}
+#[doc = "`write(|w| ..)` method takes [tasks_starttx::W](W) writer structure"]
+impl crate::Writable for TASKS_STARTTX_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets TASKS_STARTTX to value 0"]
+impl crate::Resettable for TASKS_STARTTX_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf51-pac/src/uart0/tasks_stoprx.rs

@@ -0,0 +1,45 @@
+#[doc = "Register `TASKS_STOPRX` writer"]
+pub struct W(crate::W<TASKS_STOPRX_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<TASKS_STOPRX_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<TASKS_STOPRX_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<TASKS_STOPRX_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 = "Stop UART receiver.\n\nThis register you can [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [tasks_stoprx](index.html) module"]
+pub struct TASKS_STOPRX_SPEC;
+impl crate::RegisterSpec for TASKS_STOPRX_SPEC {
+    type Ux = u32;
+}
+#[doc = "`write(|w| ..)` method takes [tasks_stoprx::W](W) writer structure"]
+impl crate::Writable for TASKS_STOPRX_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets TASKS_STOPRX to value 0"]
+impl crate::Resettable for TASKS_STOPRX_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf51-pac/src/uart0/tasks_stoptx.rs

@@ -0,0 +1,45 @@
+#[doc = "Register `TASKS_STOPTX` writer"]
+pub struct W(crate::W<TASKS_STOPTX_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<TASKS_STOPTX_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<TASKS_STOPTX_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<TASKS_STOPTX_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 = "Stop UART transmitter.\n\nThis register you can [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [tasks_stoptx](index.html) module"]
+pub struct TASKS_STOPTX_SPEC;
+impl crate::RegisterSpec for TASKS_STOPTX_SPEC {
+    type Ux = u32;
+}
+#[doc = "`write(|w| ..)` method takes [tasks_stoptx::W](W) writer structure"]
+impl crate::Writable for TASKS_STOPTX_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets TASKS_STOPTX to value 0"]
+impl crate::Resettable for TASKS_STOPTX_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf51-pac/src/uart0/tasks_suspend.rs

@@ -0,0 +1,45 @@
+#[doc = "Register `TASKS_SUSPEND` writer"]
+pub struct W(crate::W<TASKS_SUSPEND_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<TASKS_SUSPEND_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<TASKS_SUSPEND_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<TASKS_SUSPEND_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 = "Suspend UART.\n\nThis register you can [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [tasks_suspend](index.html) module"]
+pub struct TASKS_SUSPEND_SPEC;
+impl crate::RegisterSpec for TASKS_SUSPEND_SPEC {
+    type Ux = u32;
+}
+#[doc = "`write(|w| ..)` method takes [tasks_suspend::W](W) writer structure"]
+impl crate::Writable for TASKS_SUSPEND_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets TASKS_SUSPEND to value 0"]
+impl crate::Resettable for TASKS_SUSPEND_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf51-pac/src/uart0/txd.rs

@@ -0,0 +1,52 @@
+#[doc = "Register `TXD` writer"]
+pub struct W(crate::W<TXD_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<TXD_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<TXD_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<TXD_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `TXD` writer - TX data for transfer."]
+pub type TXD_W<'a, const O: u8> = crate::FieldWriter<'a, u32, TXD_SPEC, u8, u8, 8, O>;
+impl W {
+    #[doc = "Bits 0:7 - TX data for transfer."]
+    #[inline(always)]
+    pub fn txd(&mut self) -> TXD_W<0> {
+        TXD_W::new(self)
+    }
+    #[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 = "TXD register.\n\nThis register you can [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [txd](index.html) module"]
+pub struct TXD_SPEC;
+impl crate::RegisterSpec for TXD_SPEC {
+    type Ux = u32;
+}
+#[doc = "`write(|w| ..)` method takes [txd::W](W) writer structure"]
+impl crate::Writable for TXD_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets TXD to value 0"]
+impl crate::Resettable for TXD_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}