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/nrf52833-pac/src/twim0/address.rs

@@ -0,0 +1,80 @@
+#[doc = "Register `ADDRESS` reader"]
+pub struct R(crate::R<ADDRESS_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<ADDRESS_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<ADDRESS_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<ADDRESS_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `ADDRESS` writer"]
+pub struct W(crate::W<ADDRESS_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<ADDRESS_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<ADDRESS_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<ADDRESS_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `ADDRESS` reader - Address used in the TWI transfer"]
+pub type ADDRESS_R = crate::FieldReader<u8, u8>;
+#[doc = "Field `ADDRESS` writer - Address used in the TWI transfer"]
+pub type ADDRESS_W<'a, const O: u8> = crate::FieldWriter<'a, u32, ADDRESS_SPEC, u8, u8, 7, O>;
+impl R {
+    #[doc = "Bits 0:6 - Address used in the TWI transfer"]
+    #[inline(always)]
+    pub fn address(&self) -> ADDRESS_R {
+        ADDRESS_R::new((self.bits & 0x7f) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:6 - Address used in the TWI transfer"]
+    #[inline(always)]
+    pub fn address(&mut self) -> ADDRESS_W<0> {
+        ADDRESS_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 = "Address used in the TWI transfer\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 [address](index.html) module"]
+pub struct ADDRESS_SPEC;
+impl crate::RegisterSpec for ADDRESS_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [address::R](R) reader structure"]
+impl crate::Readable for ADDRESS_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [address::W](W) writer structure"]
+impl crate::Writable for ADDRESS_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets ADDRESS to value 0"]
+impl crate::Resettable for ADDRESS_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf52833-pac/src/twim0/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 TWIM"]
+pub type ENABLE_R = crate::FieldReader<u8, ENABLE_A>;
+#[doc = "Enable or disable TWIM\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+#[repr(u8)]
+pub enum ENABLE_A {
+    #[doc = "0: Disable TWIM"]
+    DISABLED = 0,
+    #[doc = "6: Enable TWIM"]
+    ENABLED = 6,
+}
+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),
+            6 => 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 TWIM"]
+pub type ENABLE_W<'a, const O: u8> = crate::FieldWriter<'a, u32, ENABLE_SPEC, u8, ENABLE_A, 4, O>;
+impl<'a, const O: u8> ENABLE_W<'a, O> {
+    #[doc = "Disable TWIM"]
+    #[inline(always)]
+    pub fn disabled(self) -> &'a mut W {
+        self.variant(ENABLE_A::DISABLED)
+    }
+    #[doc = "Enable TWIM"]
+    #[inline(always)]
+    pub fn enabled(self) -> &'a mut W {
+        self.variant(ENABLE_A::ENABLED)
+    }
+}
+impl R {
+    #[doc = "Bits 0:3 - Enable or disable TWIM"]
+    #[inline(always)]
+    pub fn enable(&self) -> ENABLE_R {
+        ENABLE_R::new((self.bits & 0x0f) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:3 - Enable or disable TWIM"]
+    #[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 TWIM\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/nrf52833-pac/src/twim0/errorsrc.rs

@@ -0,0 +1,246 @@
+#[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 - Overrun error"]
+pub type OVERRUN_R = crate::BitReader<OVERRUN_A>;
+#[doc = "Overrun error\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum OVERRUN_A {
+    #[doc = "0: Error did not occur"]
+    NOT_RECEIVED = 0,
+    #[doc = "1: Error occurred"]
+    RECEIVED = 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_RECEIVED,
+            true => OVERRUN_A::RECEIVED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `NOT_RECEIVED`"]
+    #[inline(always)]
+    pub fn is_not_received(&self) -> bool {
+        *self == OVERRUN_A::NOT_RECEIVED
+    }
+    #[doc = "Checks if the value of the field is `RECEIVED`"]
+    #[inline(always)]
+    pub fn is_received(&self) -> bool {
+        *self == OVERRUN_A::RECEIVED
+    }
+}
+#[doc = "Field `OVERRUN` writer - Overrun error"]
+pub type OVERRUN_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, ERRORSRC_SPEC, OVERRUN_A, O>;
+impl<'a, const O: u8> OVERRUN_W<'a, O> {
+    #[doc = "Error did not occur"]
+    #[inline(always)]
+    pub fn not_received(self) -> &'a mut W {
+        self.variant(OVERRUN_A::NOT_RECEIVED)
+    }
+    #[doc = "Error occurred"]
+    #[inline(always)]
+    pub fn received(self) -> &'a mut W {
+        self.variant(OVERRUN_A::RECEIVED)
+    }
+}
+#[doc = "Field `ANACK` reader - NACK received after sending the address (write '1' to clear)"]
+pub type ANACK_R = crate::BitReader<ANACK_A>;
+#[doc = "NACK received after sending the address (write '1' to clear)\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum ANACK_A {
+    #[doc = "0: Error did not occur"]
+    NOT_RECEIVED = 0,
+    #[doc = "1: Error occurred"]
+    RECEIVED = 1,
+}
+impl From<ANACK_A> for bool {
+    #[inline(always)]
+    fn from(variant: ANACK_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl ANACK_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> ANACK_A {
+        match self.bits {
+            false => ANACK_A::NOT_RECEIVED,
+            true => ANACK_A::RECEIVED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `NOT_RECEIVED`"]
+    #[inline(always)]
+    pub fn is_not_received(&self) -> bool {
+        *self == ANACK_A::NOT_RECEIVED
+    }
+    #[doc = "Checks if the value of the field is `RECEIVED`"]
+    #[inline(always)]
+    pub fn is_received(&self) -> bool {
+        *self == ANACK_A::RECEIVED
+    }
+}
+#[doc = "Field `ANACK` writer - NACK received after sending the address (write '1' to clear)"]
+pub type ANACK_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, ERRORSRC_SPEC, ANACK_A, O>;
+impl<'a, const O: u8> ANACK_W<'a, O> {
+    #[doc = "Error did not occur"]
+    #[inline(always)]
+    pub fn not_received(self) -> &'a mut W {
+        self.variant(ANACK_A::NOT_RECEIVED)
+    }
+    #[doc = "Error occurred"]
+    #[inline(always)]
+    pub fn received(self) -> &'a mut W {
+        self.variant(ANACK_A::RECEIVED)
+    }
+}
+#[doc = "Field `DNACK` reader - NACK received after sending a data byte (write '1' to clear)"]
+pub type DNACK_R = crate::BitReader<DNACK_A>;
+#[doc = "NACK received after sending a data byte (write '1' to clear)\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum DNACK_A {
+    #[doc = "0: Error did not occur"]
+    NOT_RECEIVED = 0,
+    #[doc = "1: Error occurred"]
+    RECEIVED = 1,
+}
+impl From<DNACK_A> for bool {
+    #[inline(always)]
+    fn from(variant: DNACK_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl DNACK_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> DNACK_A {
+        match self.bits {
+            false => DNACK_A::NOT_RECEIVED,
+            true => DNACK_A::RECEIVED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `NOT_RECEIVED`"]
+    #[inline(always)]
+    pub fn is_not_received(&self) -> bool {
+        *self == DNACK_A::NOT_RECEIVED
+    }
+    #[doc = "Checks if the value of the field is `RECEIVED`"]
+    #[inline(always)]
+    pub fn is_received(&self) -> bool {
+        *self == DNACK_A::RECEIVED
+    }
+}
+#[doc = "Field `DNACK` writer - NACK received after sending a data byte (write '1' to clear)"]
+pub type DNACK_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, ERRORSRC_SPEC, DNACK_A, O>;
+impl<'a, const O: u8> DNACK_W<'a, O> {
+    #[doc = "Error did not occur"]
+    #[inline(always)]
+    pub fn not_received(self) -> &'a mut W {
+        self.variant(DNACK_A::NOT_RECEIVED)
+    }
+    #[doc = "Error occurred"]
+    #[inline(always)]
+    pub fn received(self) -> &'a mut W {
+        self.variant(DNACK_A::RECEIVED)
+    }
+}
+impl R {
+    #[doc = "Bit 0 - Overrun error"]
+    #[inline(always)]
+    pub fn overrun(&self) -> OVERRUN_R {
+        OVERRUN_R::new((self.bits & 1) != 0)
+    }
+    #[doc = "Bit 1 - NACK received after sending the address (write '1' to clear)"]
+    #[inline(always)]
+    pub fn anack(&self) -> ANACK_R {
+        ANACK_R::new(((self.bits >> 1) & 1) != 0)
+    }
+    #[doc = "Bit 2 - NACK received after sending a data byte (write '1' to clear)"]
+    #[inline(always)]
+    pub fn dnack(&self) -> DNACK_R {
+        DNACK_R::new(((self.bits >> 2) & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bit 0 - Overrun error"]
+    #[inline(always)]
+    pub fn overrun(&mut self) -> OVERRUN_W<0> {
+        OVERRUN_W::new(self)
+    }
+    #[doc = "Bit 1 - NACK received after sending the address (write '1' to clear)"]
+    #[inline(always)]
+    pub fn anack(&mut self) -> ANACK_W<1> {
+        ANACK_W::new(self)
+    }
+    #[doc = "Bit 2 - NACK received after sending a data byte (write '1' to clear)"]
+    #[inline(always)]
+    pub fn dnack(&mut self) -> DNACK_W<2> {
+        DNACK_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\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/nrf52833-pac/src/twim0/events_error.rs

@@ -0,0 +1,127 @@
+#[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)
+    }
+}
+#[doc = "Field `EVENTS_ERROR` reader - TWI error"]
+pub type EVENTS_ERROR_R = crate::BitReader<EVENTS_ERROR_A>;
+#[doc = "TWI error\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum EVENTS_ERROR_A {
+    #[doc = "0: Event not generated"]
+    NOT_GENERATED = 0,
+    #[doc = "1: Event generated"]
+    GENERATED = 1,
+}
+impl From<EVENTS_ERROR_A> for bool {
+    #[inline(always)]
+    fn from(variant: EVENTS_ERROR_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl EVENTS_ERROR_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> EVENTS_ERROR_A {
+        match self.bits {
+            false => EVENTS_ERROR_A::NOT_GENERATED,
+            true => EVENTS_ERROR_A::GENERATED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `NOT_GENERATED`"]
+    #[inline(always)]
+    pub fn is_not_generated(&self) -> bool {
+        *self == EVENTS_ERROR_A::NOT_GENERATED
+    }
+    #[doc = "Checks if the value of the field is `GENERATED`"]
+    #[inline(always)]
+    pub fn is_generated(&self) -> bool {
+        *self == EVENTS_ERROR_A::GENERATED
+    }
+}
+#[doc = "Field `EVENTS_ERROR` writer - TWI error"]
+pub type EVENTS_ERROR_W<'a, const O: u8> =
+    crate::BitWriter<'a, u32, EVENTS_ERROR_SPEC, EVENTS_ERROR_A, O>;
+impl<'a, const O: u8> EVENTS_ERROR_W<'a, O> {
+    #[doc = "Event not generated"]
+    #[inline(always)]
+    pub fn not_generated(self) -> &'a mut W {
+        self.variant(EVENTS_ERROR_A::NOT_GENERATED)
+    }
+    #[doc = "Event generated"]
+    #[inline(always)]
+    pub fn generated(self) -> &'a mut W {
+        self.variant(EVENTS_ERROR_A::GENERATED)
+    }
+}
+impl R {
+    #[doc = "Bit 0 - TWI error"]
+    #[inline(always)]
+    pub fn events_error(&self) -> EVENTS_ERROR_R {
+        EVENTS_ERROR_R::new((self.bits & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bit 0 - TWI error"]
+    #[inline(always)]
+    pub fn events_error(&mut self) -> EVENTS_ERROR_W<0> {
+        EVENTS_ERROR_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 = "TWI 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 [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/nrf52833-pac/src/twim0/events_lastrx.rs

@@ -0,0 +1,127 @@
+#[doc = "Register `EVENTS_LASTRX` reader"]
+pub struct R(crate::R<EVENTS_LASTRX_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<EVENTS_LASTRX_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<EVENTS_LASTRX_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<EVENTS_LASTRX_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `EVENTS_LASTRX` writer"]
+pub struct W(crate::W<EVENTS_LASTRX_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<EVENTS_LASTRX_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_LASTRX_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<EVENTS_LASTRX_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `EVENTS_LASTRX` reader - Byte boundary, starting to receive the last byte"]
+pub type EVENTS_LASTRX_R = crate::BitReader<EVENTS_LASTRX_A>;
+#[doc = "Byte boundary, starting to receive the last byte\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum EVENTS_LASTRX_A {
+    #[doc = "0: Event not generated"]
+    NOT_GENERATED = 0,
+    #[doc = "1: Event generated"]
+    GENERATED = 1,
+}
+impl From<EVENTS_LASTRX_A> for bool {
+    #[inline(always)]
+    fn from(variant: EVENTS_LASTRX_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl EVENTS_LASTRX_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> EVENTS_LASTRX_A {
+        match self.bits {
+            false => EVENTS_LASTRX_A::NOT_GENERATED,
+            true => EVENTS_LASTRX_A::GENERATED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `NOT_GENERATED`"]
+    #[inline(always)]
+    pub fn is_not_generated(&self) -> bool {
+        *self == EVENTS_LASTRX_A::NOT_GENERATED
+    }
+    #[doc = "Checks if the value of the field is `GENERATED`"]
+    #[inline(always)]
+    pub fn is_generated(&self) -> bool {
+        *self == EVENTS_LASTRX_A::GENERATED
+    }
+}
+#[doc = "Field `EVENTS_LASTRX` writer - Byte boundary, starting to receive the last byte"]
+pub type EVENTS_LASTRX_W<'a, const O: u8> =
+    crate::BitWriter<'a, u32, EVENTS_LASTRX_SPEC, EVENTS_LASTRX_A, O>;
+impl<'a, const O: u8> EVENTS_LASTRX_W<'a, O> {
+    #[doc = "Event not generated"]
+    #[inline(always)]
+    pub fn not_generated(self) -> &'a mut W {
+        self.variant(EVENTS_LASTRX_A::NOT_GENERATED)
+    }
+    #[doc = "Event generated"]
+    #[inline(always)]
+    pub fn generated(self) -> &'a mut W {
+        self.variant(EVENTS_LASTRX_A::GENERATED)
+    }
+}
+impl R {
+    #[doc = "Bit 0 - Byte boundary, starting to receive the last byte"]
+    #[inline(always)]
+    pub fn events_lastrx(&self) -> EVENTS_LASTRX_R {
+        EVENTS_LASTRX_R::new((self.bits & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bit 0 - Byte boundary, starting to receive the last byte"]
+    #[inline(always)]
+    pub fn events_lastrx(&mut self) -> EVENTS_LASTRX_W<0> {
+        EVENTS_LASTRX_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 = "Byte boundary, starting to receive the last byte\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_lastrx](index.html) module"]
+pub struct EVENTS_LASTRX_SPEC;
+impl crate::RegisterSpec for EVENTS_LASTRX_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [events_lastrx::R](R) reader structure"]
+impl crate::Readable for EVENTS_LASTRX_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [events_lastrx::W](W) writer structure"]
+impl crate::Writable for EVENTS_LASTRX_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets EVENTS_LASTRX to value 0"]
+impl crate::Resettable for EVENTS_LASTRX_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf52833-pac/src/twim0/events_lasttx.rs

@@ -0,0 +1,127 @@
+#[doc = "Register `EVENTS_LASTTX` reader"]
+pub struct R(crate::R<EVENTS_LASTTX_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<EVENTS_LASTTX_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<EVENTS_LASTTX_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<EVENTS_LASTTX_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `EVENTS_LASTTX` writer"]
+pub struct W(crate::W<EVENTS_LASTTX_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<EVENTS_LASTTX_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_LASTTX_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<EVENTS_LASTTX_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `EVENTS_LASTTX` reader - Byte boundary, starting to transmit the last byte"]
+pub type EVENTS_LASTTX_R = crate::BitReader<EVENTS_LASTTX_A>;
+#[doc = "Byte boundary, starting to transmit the last byte\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum EVENTS_LASTTX_A {
+    #[doc = "0: Event not generated"]
+    NOT_GENERATED = 0,
+    #[doc = "1: Event generated"]
+    GENERATED = 1,
+}
+impl From<EVENTS_LASTTX_A> for bool {
+    #[inline(always)]
+    fn from(variant: EVENTS_LASTTX_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl EVENTS_LASTTX_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> EVENTS_LASTTX_A {
+        match self.bits {
+            false => EVENTS_LASTTX_A::NOT_GENERATED,
+            true => EVENTS_LASTTX_A::GENERATED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `NOT_GENERATED`"]
+    #[inline(always)]
+    pub fn is_not_generated(&self) -> bool {
+        *self == EVENTS_LASTTX_A::NOT_GENERATED
+    }
+    #[doc = "Checks if the value of the field is `GENERATED`"]
+    #[inline(always)]
+    pub fn is_generated(&self) -> bool {
+        *self == EVENTS_LASTTX_A::GENERATED
+    }
+}
+#[doc = "Field `EVENTS_LASTTX` writer - Byte boundary, starting to transmit the last byte"]
+pub type EVENTS_LASTTX_W<'a, const O: u8> =
+    crate::BitWriter<'a, u32, EVENTS_LASTTX_SPEC, EVENTS_LASTTX_A, O>;
+impl<'a, const O: u8> EVENTS_LASTTX_W<'a, O> {
+    #[doc = "Event not generated"]
+    #[inline(always)]
+    pub fn not_generated(self) -> &'a mut W {
+        self.variant(EVENTS_LASTTX_A::NOT_GENERATED)
+    }
+    #[doc = "Event generated"]
+    #[inline(always)]
+    pub fn generated(self) -> &'a mut W {
+        self.variant(EVENTS_LASTTX_A::GENERATED)
+    }
+}
+impl R {
+    #[doc = "Bit 0 - Byte boundary, starting to transmit the last byte"]
+    #[inline(always)]
+    pub fn events_lasttx(&self) -> EVENTS_LASTTX_R {
+        EVENTS_LASTTX_R::new((self.bits & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bit 0 - Byte boundary, starting to transmit the last byte"]
+    #[inline(always)]
+    pub fn events_lasttx(&mut self) -> EVENTS_LASTTX_W<0> {
+        EVENTS_LASTTX_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 = "Byte boundary, starting to transmit the last byte\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_lasttx](index.html) module"]
+pub struct EVENTS_LASTTX_SPEC;
+impl crate::RegisterSpec for EVENTS_LASTTX_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [events_lasttx::R](R) reader structure"]
+impl crate::Readable for EVENTS_LASTTX_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [events_lasttx::W](W) writer structure"]
+impl crate::Writable for EVENTS_LASTTX_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets EVENTS_LASTTX to value 0"]
+impl crate::Resettable for EVENTS_LASTTX_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf52833-pac/src/twim0/events_rxstarted.rs

@@ -0,0 +1,127 @@
+#[doc = "Register `EVENTS_RXSTARTED` reader"]
+pub struct R(crate::R<EVENTS_RXSTARTED_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<EVENTS_RXSTARTED_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<EVENTS_RXSTARTED_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<EVENTS_RXSTARTED_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `EVENTS_RXSTARTED` writer"]
+pub struct W(crate::W<EVENTS_RXSTARTED_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<EVENTS_RXSTARTED_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_RXSTARTED_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<EVENTS_RXSTARTED_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `EVENTS_RXSTARTED` reader - Receive sequence started"]
+pub type EVENTS_RXSTARTED_R = crate::BitReader<EVENTS_RXSTARTED_A>;
+#[doc = "Receive sequence started\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum EVENTS_RXSTARTED_A {
+    #[doc = "0: Event not generated"]
+    NOT_GENERATED = 0,
+    #[doc = "1: Event generated"]
+    GENERATED = 1,
+}
+impl From<EVENTS_RXSTARTED_A> for bool {
+    #[inline(always)]
+    fn from(variant: EVENTS_RXSTARTED_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl EVENTS_RXSTARTED_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> EVENTS_RXSTARTED_A {
+        match self.bits {
+            false => EVENTS_RXSTARTED_A::NOT_GENERATED,
+            true => EVENTS_RXSTARTED_A::GENERATED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `NOT_GENERATED`"]
+    #[inline(always)]
+    pub fn is_not_generated(&self) -> bool {
+        *self == EVENTS_RXSTARTED_A::NOT_GENERATED
+    }
+    #[doc = "Checks if the value of the field is `GENERATED`"]
+    #[inline(always)]
+    pub fn is_generated(&self) -> bool {
+        *self == EVENTS_RXSTARTED_A::GENERATED
+    }
+}
+#[doc = "Field `EVENTS_RXSTARTED` writer - Receive sequence started"]
+pub type EVENTS_RXSTARTED_W<'a, const O: u8> =
+    crate::BitWriter<'a, u32, EVENTS_RXSTARTED_SPEC, EVENTS_RXSTARTED_A, O>;
+impl<'a, const O: u8> EVENTS_RXSTARTED_W<'a, O> {
+    #[doc = "Event not generated"]
+    #[inline(always)]
+    pub fn not_generated(self) -> &'a mut W {
+        self.variant(EVENTS_RXSTARTED_A::NOT_GENERATED)
+    }
+    #[doc = "Event generated"]
+    #[inline(always)]
+    pub fn generated(self) -> &'a mut W {
+        self.variant(EVENTS_RXSTARTED_A::GENERATED)
+    }
+}
+impl R {
+    #[doc = "Bit 0 - Receive sequence started"]
+    #[inline(always)]
+    pub fn events_rxstarted(&self) -> EVENTS_RXSTARTED_R {
+        EVENTS_RXSTARTED_R::new((self.bits & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bit 0 - Receive sequence started"]
+    #[inline(always)]
+    pub fn events_rxstarted(&mut self) -> EVENTS_RXSTARTED_W<0> {
+        EVENTS_RXSTARTED_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 = "Receive sequence started\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_rxstarted](index.html) module"]
+pub struct EVENTS_RXSTARTED_SPEC;
+impl crate::RegisterSpec for EVENTS_RXSTARTED_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [events_rxstarted::R](R) reader structure"]
+impl crate::Readable for EVENTS_RXSTARTED_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [events_rxstarted::W](W) writer structure"]
+impl crate::Writable for EVENTS_RXSTARTED_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets EVENTS_RXSTARTED to value 0"]
+impl crate::Resettable for EVENTS_RXSTARTED_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf52833-pac/src/twim0/events_stopped.rs

@@ -0,0 +1,127 @@
+#[doc = "Register `EVENTS_STOPPED` reader"]
+pub struct R(crate::R<EVENTS_STOPPED_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<EVENTS_STOPPED_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<EVENTS_STOPPED_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<EVENTS_STOPPED_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `EVENTS_STOPPED` writer"]
+pub struct W(crate::W<EVENTS_STOPPED_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<EVENTS_STOPPED_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_STOPPED_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<EVENTS_STOPPED_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `EVENTS_STOPPED` reader - TWI stopped"]
+pub type EVENTS_STOPPED_R = crate::BitReader<EVENTS_STOPPED_A>;
+#[doc = "TWI stopped\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum EVENTS_STOPPED_A {
+    #[doc = "0: Event not generated"]
+    NOT_GENERATED = 0,
+    #[doc = "1: Event generated"]
+    GENERATED = 1,
+}
+impl From<EVENTS_STOPPED_A> for bool {
+    #[inline(always)]
+    fn from(variant: EVENTS_STOPPED_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl EVENTS_STOPPED_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> EVENTS_STOPPED_A {
+        match self.bits {
+            false => EVENTS_STOPPED_A::NOT_GENERATED,
+            true => EVENTS_STOPPED_A::GENERATED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `NOT_GENERATED`"]
+    #[inline(always)]
+    pub fn is_not_generated(&self) -> bool {
+        *self == EVENTS_STOPPED_A::NOT_GENERATED
+    }
+    #[doc = "Checks if the value of the field is `GENERATED`"]
+    #[inline(always)]
+    pub fn is_generated(&self) -> bool {
+        *self == EVENTS_STOPPED_A::GENERATED
+    }
+}
+#[doc = "Field `EVENTS_STOPPED` writer - TWI stopped"]
+pub type EVENTS_STOPPED_W<'a, const O: u8> =
+    crate::BitWriter<'a, u32, EVENTS_STOPPED_SPEC, EVENTS_STOPPED_A, O>;
+impl<'a, const O: u8> EVENTS_STOPPED_W<'a, O> {
+    #[doc = "Event not generated"]
+    #[inline(always)]
+    pub fn not_generated(self) -> &'a mut W {
+        self.variant(EVENTS_STOPPED_A::NOT_GENERATED)
+    }
+    #[doc = "Event generated"]
+    #[inline(always)]
+    pub fn generated(self) -> &'a mut W {
+        self.variant(EVENTS_STOPPED_A::GENERATED)
+    }
+}
+impl R {
+    #[doc = "Bit 0 - TWI stopped"]
+    #[inline(always)]
+    pub fn events_stopped(&self) -> EVENTS_STOPPED_R {
+        EVENTS_STOPPED_R::new((self.bits & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bit 0 - TWI stopped"]
+    #[inline(always)]
+    pub fn events_stopped(&mut self) -> EVENTS_STOPPED_W<0> {
+        EVENTS_STOPPED_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 = "TWI stopped\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_stopped](index.html) module"]
+pub struct EVENTS_STOPPED_SPEC;
+impl crate::RegisterSpec for EVENTS_STOPPED_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [events_stopped::R](R) reader structure"]
+impl crate::Readable for EVENTS_STOPPED_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [events_stopped::W](W) writer structure"]
+impl crate::Writable for EVENTS_STOPPED_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets EVENTS_STOPPED to value 0"]
+impl crate::Resettable for EVENTS_STOPPED_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf52833-pac/src/twim0/events_suspended.rs

@@ -0,0 +1,127 @@
+#[doc = "Register `EVENTS_SUSPENDED` reader"]
+pub struct R(crate::R<EVENTS_SUSPENDED_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<EVENTS_SUSPENDED_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<EVENTS_SUSPENDED_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<EVENTS_SUSPENDED_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `EVENTS_SUSPENDED` writer"]
+pub struct W(crate::W<EVENTS_SUSPENDED_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<EVENTS_SUSPENDED_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_SUSPENDED_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<EVENTS_SUSPENDED_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `EVENTS_SUSPENDED` reader - Last byte has been sent out after the SUSPEND task has been issued, TWI traffic is now suspended."]
+pub type EVENTS_SUSPENDED_R = crate::BitReader<EVENTS_SUSPENDED_A>;
+#[doc = "Last byte has been sent out after the SUSPEND task has been issued, TWI traffic is now suspended.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum EVENTS_SUSPENDED_A {
+    #[doc = "0: Event not generated"]
+    NOT_GENERATED = 0,
+    #[doc = "1: Event generated"]
+    GENERATED = 1,
+}
+impl From<EVENTS_SUSPENDED_A> for bool {
+    #[inline(always)]
+    fn from(variant: EVENTS_SUSPENDED_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl EVENTS_SUSPENDED_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> EVENTS_SUSPENDED_A {
+        match self.bits {
+            false => EVENTS_SUSPENDED_A::NOT_GENERATED,
+            true => EVENTS_SUSPENDED_A::GENERATED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `NOT_GENERATED`"]
+    #[inline(always)]
+    pub fn is_not_generated(&self) -> bool {
+        *self == EVENTS_SUSPENDED_A::NOT_GENERATED
+    }
+    #[doc = "Checks if the value of the field is `GENERATED`"]
+    #[inline(always)]
+    pub fn is_generated(&self) -> bool {
+        *self == EVENTS_SUSPENDED_A::GENERATED
+    }
+}
+#[doc = "Field `EVENTS_SUSPENDED` writer - Last byte has been sent out after the SUSPEND task has been issued, TWI traffic is now suspended."]
+pub type EVENTS_SUSPENDED_W<'a, const O: u8> =
+    crate::BitWriter<'a, u32, EVENTS_SUSPENDED_SPEC, EVENTS_SUSPENDED_A, O>;
+impl<'a, const O: u8> EVENTS_SUSPENDED_W<'a, O> {
+    #[doc = "Event not generated"]
+    #[inline(always)]
+    pub fn not_generated(self) -> &'a mut W {
+        self.variant(EVENTS_SUSPENDED_A::NOT_GENERATED)
+    }
+    #[doc = "Event generated"]
+    #[inline(always)]
+    pub fn generated(self) -> &'a mut W {
+        self.variant(EVENTS_SUSPENDED_A::GENERATED)
+    }
+}
+impl R {
+    #[doc = "Bit 0 - Last byte has been sent out after the SUSPEND task has been issued, TWI traffic is now suspended."]
+    #[inline(always)]
+    pub fn events_suspended(&self) -> EVENTS_SUSPENDED_R {
+        EVENTS_SUSPENDED_R::new((self.bits & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bit 0 - Last byte has been sent out after the SUSPEND task has been issued, TWI traffic is now suspended."]
+    #[inline(always)]
+    pub fn events_suspended(&mut self) -> EVENTS_SUSPENDED_W<0> {
+        EVENTS_SUSPENDED_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 = "Last byte has been sent out after the SUSPEND task has been issued, TWI traffic is now suspended.\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_suspended](index.html) module"]
+pub struct EVENTS_SUSPENDED_SPEC;
+impl crate::RegisterSpec for EVENTS_SUSPENDED_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [events_suspended::R](R) reader structure"]
+impl crate::Readable for EVENTS_SUSPENDED_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [events_suspended::W](W) writer structure"]
+impl crate::Writable for EVENTS_SUSPENDED_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets EVENTS_SUSPENDED to value 0"]
+impl crate::Resettable for EVENTS_SUSPENDED_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf52833-pac/src/twim0/events_txstarted.rs

@@ -0,0 +1,127 @@
+#[doc = "Register `EVENTS_TXSTARTED` reader"]
+pub struct R(crate::R<EVENTS_TXSTARTED_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<EVENTS_TXSTARTED_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<EVENTS_TXSTARTED_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<EVENTS_TXSTARTED_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `EVENTS_TXSTARTED` writer"]
+pub struct W(crate::W<EVENTS_TXSTARTED_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<EVENTS_TXSTARTED_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_TXSTARTED_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<EVENTS_TXSTARTED_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `EVENTS_TXSTARTED` reader - Transmit sequence started"]
+pub type EVENTS_TXSTARTED_R = crate::BitReader<EVENTS_TXSTARTED_A>;
+#[doc = "Transmit sequence started\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum EVENTS_TXSTARTED_A {
+    #[doc = "0: Event not generated"]
+    NOT_GENERATED = 0,
+    #[doc = "1: Event generated"]
+    GENERATED = 1,
+}
+impl From<EVENTS_TXSTARTED_A> for bool {
+    #[inline(always)]
+    fn from(variant: EVENTS_TXSTARTED_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl EVENTS_TXSTARTED_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> EVENTS_TXSTARTED_A {
+        match self.bits {
+            false => EVENTS_TXSTARTED_A::NOT_GENERATED,
+            true => EVENTS_TXSTARTED_A::GENERATED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `NOT_GENERATED`"]
+    #[inline(always)]
+    pub fn is_not_generated(&self) -> bool {
+        *self == EVENTS_TXSTARTED_A::NOT_GENERATED
+    }
+    #[doc = "Checks if the value of the field is `GENERATED`"]
+    #[inline(always)]
+    pub fn is_generated(&self) -> bool {
+        *self == EVENTS_TXSTARTED_A::GENERATED
+    }
+}
+#[doc = "Field `EVENTS_TXSTARTED` writer - Transmit sequence started"]
+pub type EVENTS_TXSTARTED_W<'a, const O: u8> =
+    crate::BitWriter<'a, u32, EVENTS_TXSTARTED_SPEC, EVENTS_TXSTARTED_A, O>;
+impl<'a, const O: u8> EVENTS_TXSTARTED_W<'a, O> {
+    #[doc = "Event not generated"]
+    #[inline(always)]
+    pub fn not_generated(self) -> &'a mut W {
+        self.variant(EVENTS_TXSTARTED_A::NOT_GENERATED)
+    }
+    #[doc = "Event generated"]
+    #[inline(always)]
+    pub fn generated(self) -> &'a mut W {
+        self.variant(EVENTS_TXSTARTED_A::GENERATED)
+    }
+}
+impl R {
+    #[doc = "Bit 0 - Transmit sequence started"]
+    #[inline(always)]
+    pub fn events_txstarted(&self) -> EVENTS_TXSTARTED_R {
+        EVENTS_TXSTARTED_R::new((self.bits & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bit 0 - Transmit sequence started"]
+    #[inline(always)]
+    pub fn events_txstarted(&mut self) -> EVENTS_TXSTARTED_W<0> {
+        EVENTS_TXSTARTED_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 = "Transmit sequence started\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_txstarted](index.html) module"]
+pub struct EVENTS_TXSTARTED_SPEC;
+impl crate::RegisterSpec for EVENTS_TXSTARTED_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [events_txstarted::R](R) reader structure"]
+impl crate::Readable for EVENTS_TXSTARTED_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [events_txstarted::W](W) writer structure"]
+impl crate::Writable for EVENTS_TXSTARTED_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets EVENTS_TXSTARTED to value 0"]
+impl crate::Resettable for EVENTS_TXSTARTED_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf52833-pac/src/twim0/frequency.rs

@@ -0,0 +1,142 @@
+#[doc = "Register `FREQUENCY` reader"]
+pub struct R(crate::R<FREQUENCY_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<FREQUENCY_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<FREQUENCY_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<FREQUENCY_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `FREQUENCY` writer"]
+pub struct W(crate::W<FREQUENCY_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<FREQUENCY_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<FREQUENCY_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<FREQUENCY_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `FREQUENCY` reader - TWI master clock frequency"]
+pub type FREQUENCY_R = crate::FieldReader<u32, FREQUENCY_A>;
+#[doc = "TWI master clock frequency\n\nValue on reset: 67108864"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+#[repr(u32)]
+pub enum FREQUENCY_A {
+    #[doc = "26738688: 100 kbps"]
+    K100 = 26738688,
+    #[doc = "67108864: 250 kbps"]
+    K250 = 67108864,
+    #[doc = "104857600: 400 kbps"]
+    K400 = 104857600,
+}
+impl From<FREQUENCY_A> for u32 {
+    #[inline(always)]
+    fn from(variant: FREQUENCY_A) -> Self {
+        variant as _
+    }
+}
+impl FREQUENCY_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> Option<FREQUENCY_A> {
+        match self.bits {
+            26738688 => Some(FREQUENCY_A::K100),
+            67108864 => Some(FREQUENCY_A::K250),
+            104857600 => Some(FREQUENCY_A::K400),
+            _ => None,
+        }
+    }
+    #[doc = "Checks if the value of the field is `K100`"]
+    #[inline(always)]
+    pub fn is_k100(&self) -> bool {
+        *self == FREQUENCY_A::K100
+    }
+    #[doc = "Checks if the value of the field is `K250`"]
+    #[inline(always)]
+    pub fn is_k250(&self) -> bool {
+        *self == FREQUENCY_A::K250
+    }
+    #[doc = "Checks if the value of the field is `K400`"]
+    #[inline(always)]
+    pub fn is_k400(&self) -> bool {
+        *self == FREQUENCY_A::K400
+    }
+}
+#[doc = "Field `FREQUENCY` writer - TWI master clock frequency"]
+pub type FREQUENCY_W<'a, const O: u8> =
+    crate::FieldWriter<'a, u32, FREQUENCY_SPEC, u32, FREQUENCY_A, 32, O>;
+impl<'a, const O: u8> FREQUENCY_W<'a, O> {
+    #[doc = "100 kbps"]
+    #[inline(always)]
+    pub fn k100(self) -> &'a mut W {
+        self.variant(FREQUENCY_A::K100)
+    }
+    #[doc = "250 kbps"]
+    #[inline(always)]
+    pub fn k250(self) -> &'a mut W {
+        self.variant(FREQUENCY_A::K250)
+    }
+    #[doc = "400 kbps"]
+    #[inline(always)]
+    pub fn k400(self) -> &'a mut W {
+        self.variant(FREQUENCY_A::K400)
+    }
+}
+impl R {
+    #[doc = "Bits 0:31 - TWI master clock frequency"]
+    #[inline(always)]
+    pub fn frequency(&self) -> FREQUENCY_R {
+        FREQUENCY_R::new(self.bits)
+    }
+}
+impl W {
+    #[doc = "Bits 0:31 - TWI master clock frequency"]
+    #[inline(always)]
+    pub fn frequency(&mut self) -> FREQUENCY_W<0> {
+        FREQUENCY_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 = "TWI frequency. Accuracy depends on the HFCLK source selected.\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 [frequency](index.html) module"]
+pub struct FREQUENCY_SPEC;
+impl crate::RegisterSpec for FREQUENCY_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [frequency::R](R) reader structure"]
+impl crate::Readable for FREQUENCY_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [frequency::W](W) writer structure"]
+impl crate::Writable for FREQUENCY_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets FREQUENCY to value 0x0400_0000"]
+impl crate::Resettable for FREQUENCY_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0x0400_0000
+    }
+}

vendor/nrf52833-pac/src/twim0/inten.rs

@@ -0,0 +1,486 @@
+#[doc = "Register `INTEN` reader"]
+pub struct R(crate::R<INTEN_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<INTEN_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<INTEN_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<INTEN_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `INTEN` writer"]
+pub struct W(crate::W<INTEN_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<INTEN_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<INTEN_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<INTEN_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `STOPPED` reader - Enable or disable interrupt for event STOPPED"]
+pub type STOPPED_R = crate::BitReader<STOPPED_A>;
+#[doc = "Enable or disable interrupt for event STOPPED\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum STOPPED_A {
+    #[doc = "0: Disable"]
+    DISABLED = 0,
+    #[doc = "1: Enable"]
+    ENABLED = 1,
+}
+impl From<STOPPED_A> for bool {
+    #[inline(always)]
+    fn from(variant: STOPPED_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl STOPPED_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> STOPPED_A {
+        match self.bits {
+            false => STOPPED_A::DISABLED,
+            true => STOPPED_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == STOPPED_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == STOPPED_A::ENABLED
+    }
+}
+#[doc = "Field `STOPPED` writer - Enable or disable interrupt for event STOPPED"]
+pub type STOPPED_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, STOPPED_A, O>;
+impl<'a, const O: u8> STOPPED_W<'a, O> {
+    #[doc = "Disable"]
+    #[inline(always)]
+    pub fn disabled(self) -> &'a mut W {
+        self.variant(STOPPED_A::DISABLED)
+    }
+    #[doc = "Enable"]
+    #[inline(always)]
+    pub fn enabled(self) -> &'a mut W {
+        self.variant(STOPPED_A::ENABLED)
+    }
+}
+#[doc = "Field `ERROR` reader - Enable or disable interrupt for event ERROR"]
+pub type ERROR_R = crate::BitReader<ERROR_A>;
+#[doc = "Enable or disable interrupt for event ERROR\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum ERROR_A {
+    #[doc = "0: Disable"]
+    DISABLED = 0,
+    #[doc = "1: Enable"]
+    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 = "Field `ERROR` writer - Enable or disable interrupt for event ERROR"]
+pub type ERROR_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, ERROR_A, O>;
+impl<'a, const O: u8> ERROR_W<'a, O> {
+    #[doc = "Disable"]
+    #[inline(always)]
+    pub fn disabled(self) -> &'a mut W {
+        self.variant(ERROR_A::DISABLED)
+    }
+    #[doc = "Enable"]
+    #[inline(always)]
+    pub fn enabled(self) -> &'a mut W {
+        self.variant(ERROR_A::ENABLED)
+    }
+}
+#[doc = "Field `SUSPENDED` reader - Enable or disable interrupt for event SUSPENDED"]
+pub type SUSPENDED_R = crate::BitReader<SUSPENDED_A>;
+#[doc = "Enable or disable interrupt for event SUSPENDED\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum SUSPENDED_A {
+    #[doc = "0: Disable"]
+    DISABLED = 0,
+    #[doc = "1: Enable"]
+    ENABLED = 1,
+}
+impl From<SUSPENDED_A> for bool {
+    #[inline(always)]
+    fn from(variant: SUSPENDED_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl SUSPENDED_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> SUSPENDED_A {
+        match self.bits {
+            false => SUSPENDED_A::DISABLED,
+            true => SUSPENDED_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == SUSPENDED_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == SUSPENDED_A::ENABLED
+    }
+}
+#[doc = "Field `SUSPENDED` writer - Enable or disable interrupt for event SUSPENDED"]
+pub type SUSPENDED_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, SUSPENDED_A, O>;
+impl<'a, const O: u8> SUSPENDED_W<'a, O> {
+    #[doc = "Disable"]
+    #[inline(always)]
+    pub fn disabled(self) -> &'a mut W {
+        self.variant(SUSPENDED_A::DISABLED)
+    }
+    #[doc = "Enable"]
+    #[inline(always)]
+    pub fn enabled(self) -> &'a mut W {
+        self.variant(SUSPENDED_A::ENABLED)
+    }
+}
+#[doc = "Field `RXSTARTED` reader - Enable or disable interrupt for event RXSTARTED"]
+pub type RXSTARTED_R = crate::BitReader<RXSTARTED_A>;
+#[doc = "Enable or disable interrupt for event RXSTARTED\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum RXSTARTED_A {
+    #[doc = "0: Disable"]
+    DISABLED = 0,
+    #[doc = "1: Enable"]
+    ENABLED = 1,
+}
+impl From<RXSTARTED_A> for bool {
+    #[inline(always)]
+    fn from(variant: RXSTARTED_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl RXSTARTED_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> RXSTARTED_A {
+        match self.bits {
+            false => RXSTARTED_A::DISABLED,
+            true => RXSTARTED_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == RXSTARTED_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == RXSTARTED_A::ENABLED
+    }
+}
+#[doc = "Field `RXSTARTED` writer - Enable or disable interrupt for event RXSTARTED"]
+pub type RXSTARTED_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, RXSTARTED_A, O>;
+impl<'a, const O: u8> RXSTARTED_W<'a, O> {
+    #[doc = "Disable"]
+    #[inline(always)]
+    pub fn disabled(self) -> &'a mut W {
+        self.variant(RXSTARTED_A::DISABLED)
+    }
+    #[doc = "Enable"]
+    #[inline(always)]
+    pub fn enabled(self) -> &'a mut W {
+        self.variant(RXSTARTED_A::ENABLED)
+    }
+}
+#[doc = "Field `TXSTARTED` reader - Enable or disable interrupt for event TXSTARTED"]
+pub type TXSTARTED_R = crate::BitReader<TXSTARTED_A>;
+#[doc = "Enable or disable interrupt for event TXSTARTED\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum TXSTARTED_A {
+    #[doc = "0: Disable"]
+    DISABLED = 0,
+    #[doc = "1: Enable"]
+    ENABLED = 1,
+}
+impl From<TXSTARTED_A> for bool {
+    #[inline(always)]
+    fn from(variant: TXSTARTED_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl TXSTARTED_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> TXSTARTED_A {
+        match self.bits {
+            false => TXSTARTED_A::DISABLED,
+            true => TXSTARTED_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == TXSTARTED_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == TXSTARTED_A::ENABLED
+    }
+}
+#[doc = "Field `TXSTARTED` writer - Enable or disable interrupt for event TXSTARTED"]
+pub type TXSTARTED_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, TXSTARTED_A, O>;
+impl<'a, const O: u8> TXSTARTED_W<'a, O> {
+    #[doc = "Disable"]
+    #[inline(always)]
+    pub fn disabled(self) -> &'a mut W {
+        self.variant(TXSTARTED_A::DISABLED)
+    }
+    #[doc = "Enable"]
+    #[inline(always)]
+    pub fn enabled(self) -> &'a mut W {
+        self.variant(TXSTARTED_A::ENABLED)
+    }
+}
+#[doc = "Field `LASTRX` reader - Enable or disable interrupt for event LASTRX"]
+pub type LASTRX_R = crate::BitReader<LASTRX_A>;
+#[doc = "Enable or disable interrupt for event LASTRX\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum LASTRX_A {
+    #[doc = "0: Disable"]
+    DISABLED = 0,
+    #[doc = "1: Enable"]
+    ENABLED = 1,
+}
+impl From<LASTRX_A> for bool {
+    #[inline(always)]
+    fn from(variant: LASTRX_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl LASTRX_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> LASTRX_A {
+        match self.bits {
+            false => LASTRX_A::DISABLED,
+            true => LASTRX_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == LASTRX_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == LASTRX_A::ENABLED
+    }
+}
+#[doc = "Field `LASTRX` writer - Enable or disable interrupt for event LASTRX"]
+pub type LASTRX_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, LASTRX_A, O>;
+impl<'a, const O: u8> LASTRX_W<'a, O> {
+    #[doc = "Disable"]
+    #[inline(always)]
+    pub fn disabled(self) -> &'a mut W {
+        self.variant(LASTRX_A::DISABLED)
+    }
+    #[doc = "Enable"]
+    #[inline(always)]
+    pub fn enabled(self) -> &'a mut W {
+        self.variant(LASTRX_A::ENABLED)
+    }
+}
+#[doc = "Field `LASTTX` reader - Enable or disable interrupt for event LASTTX"]
+pub type LASTTX_R = crate::BitReader<LASTTX_A>;
+#[doc = "Enable or disable interrupt for event LASTTX\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum LASTTX_A {
+    #[doc = "0: Disable"]
+    DISABLED = 0,
+    #[doc = "1: Enable"]
+    ENABLED = 1,
+}
+impl From<LASTTX_A> for bool {
+    #[inline(always)]
+    fn from(variant: LASTTX_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl LASTTX_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> LASTTX_A {
+        match self.bits {
+            false => LASTTX_A::DISABLED,
+            true => LASTTX_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == LASTTX_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == LASTTX_A::ENABLED
+    }
+}
+#[doc = "Field `LASTTX` writer - Enable or disable interrupt for event LASTTX"]
+pub type LASTTX_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, LASTTX_A, O>;
+impl<'a, const O: u8> LASTTX_W<'a, O> {
+    #[doc = "Disable"]
+    #[inline(always)]
+    pub fn disabled(self) -> &'a mut W {
+        self.variant(LASTTX_A::DISABLED)
+    }
+    #[doc = "Enable"]
+    #[inline(always)]
+    pub fn enabled(self) -> &'a mut W {
+        self.variant(LASTTX_A::ENABLED)
+    }
+}
+impl R {
+    #[doc = "Bit 1 - Enable or disable interrupt for event STOPPED"]
+    #[inline(always)]
+    pub fn stopped(&self) -> STOPPED_R {
+        STOPPED_R::new(((self.bits >> 1) & 1) != 0)
+    }
+    #[doc = "Bit 9 - Enable or disable interrupt for event ERROR"]
+    #[inline(always)]
+    pub fn error(&self) -> ERROR_R {
+        ERROR_R::new(((self.bits >> 9) & 1) != 0)
+    }
+    #[doc = "Bit 18 - Enable or disable interrupt for event SUSPENDED"]
+    #[inline(always)]
+    pub fn suspended(&self) -> SUSPENDED_R {
+        SUSPENDED_R::new(((self.bits >> 18) & 1) != 0)
+    }
+    #[doc = "Bit 19 - Enable or disable interrupt for event RXSTARTED"]
+    #[inline(always)]
+    pub fn rxstarted(&self) -> RXSTARTED_R {
+        RXSTARTED_R::new(((self.bits >> 19) & 1) != 0)
+    }
+    #[doc = "Bit 20 - Enable or disable interrupt for event TXSTARTED"]
+    #[inline(always)]
+    pub fn txstarted(&self) -> TXSTARTED_R {
+        TXSTARTED_R::new(((self.bits >> 20) & 1) != 0)
+    }
+    #[doc = "Bit 23 - Enable or disable interrupt for event LASTRX"]
+    #[inline(always)]
+    pub fn lastrx(&self) -> LASTRX_R {
+        LASTRX_R::new(((self.bits >> 23) & 1) != 0)
+    }
+    #[doc = "Bit 24 - Enable or disable interrupt for event LASTTX"]
+    #[inline(always)]
+    pub fn lasttx(&self) -> LASTTX_R {
+        LASTTX_R::new(((self.bits >> 24) & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bit 1 - Enable or disable interrupt for event STOPPED"]
+    #[inline(always)]
+    pub fn stopped(&mut self) -> STOPPED_W<1> {
+        STOPPED_W::new(self)
+    }
+    #[doc = "Bit 9 - Enable or disable interrupt for event ERROR"]
+    #[inline(always)]
+    pub fn error(&mut self) -> ERROR_W<9> {
+        ERROR_W::new(self)
+    }
+    #[doc = "Bit 18 - Enable or disable interrupt for event SUSPENDED"]
+    #[inline(always)]
+    pub fn suspended(&mut self) -> SUSPENDED_W<18> {
+        SUSPENDED_W::new(self)
+    }
+    #[doc = "Bit 19 - Enable or disable interrupt for event RXSTARTED"]
+    #[inline(always)]
+    pub fn rxstarted(&mut self) -> RXSTARTED_W<19> {
+        RXSTARTED_W::new(self)
+    }
+    #[doc = "Bit 20 - Enable or disable interrupt for event TXSTARTED"]
+    #[inline(always)]
+    pub fn txstarted(&mut self) -> TXSTARTED_W<20> {
+        TXSTARTED_W::new(self)
+    }
+    #[doc = "Bit 23 - Enable or disable interrupt for event LASTRX"]
+    #[inline(always)]
+    pub fn lastrx(&mut self) -> LASTRX_W<23> {
+        LASTRX_W::new(self)
+    }
+    #[doc = "Bit 24 - Enable or disable interrupt for event LASTTX"]
+    #[inline(always)]
+    pub fn lasttx(&mut self) -> LASTTX_W<24> {
+        LASTTX_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 or disable interrupt\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 [inten](index.html) module"]
+pub struct INTEN_SPEC;
+impl crate::RegisterSpec for INTEN_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [inten::R](R) reader structure"]
+impl crate::Readable for INTEN_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [inten::W](W) writer structure"]
+impl crate::Writable for INTEN_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets INTEN to value 0"]
+impl crate::Resettable for INTEN_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf52833-pac/src/twim0/intenclr.rs

@@ -0,0 +1,535 @@
+#[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 `STOPPED` reader - Write '1' to disable interrupt for event STOPPED"]
+pub type STOPPED_R = crate::BitReader<STOPPED_A>;
+#[doc = "Write '1' to disable interrupt for event STOPPED\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum STOPPED_A {
+    #[doc = "0: Read: Disabled"]
+    DISABLED = 0,
+    #[doc = "1: Read: Enabled"]
+    ENABLED = 1,
+}
+impl From<STOPPED_A> for bool {
+    #[inline(always)]
+    fn from(variant: STOPPED_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl STOPPED_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> STOPPED_A {
+        match self.bits {
+            false => STOPPED_A::DISABLED,
+            true => STOPPED_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == STOPPED_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == STOPPED_A::ENABLED
+    }
+}
+#[doc = "Write '1' to disable interrupt for event STOPPED\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum STOPPED_AW {
+    #[doc = "1: Disable"]
+    CLEAR = 1,
+}
+impl From<STOPPED_AW> for bool {
+    #[inline(always)]
+    fn from(variant: STOPPED_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `STOPPED` writer - Write '1' to disable interrupt for event STOPPED"]
+pub type STOPPED_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, STOPPED_AW, O>;
+impl<'a, const O: u8> STOPPED_W<'a, O> {
+    #[doc = "Disable"]
+    #[inline(always)]
+    pub fn clear(self) -> &'a mut W {
+        self.variant(STOPPED_AW::CLEAR)
+    }
+}
+#[doc = "Field `ERROR` reader - Write '1' to disable interrupt for event ERROR"]
+pub type ERROR_R = crate::BitReader<ERROR_A>;
+#[doc = "Write '1' to disable interrupt for event ERROR\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum ERROR_A {
+    #[doc = "0: Read: Disabled"]
+    DISABLED = 0,
+    #[doc = "1: Read: 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 = "Write '1' to disable interrupt for event ERROR\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum ERROR_AW {
+    #[doc = "1: Disable"]
+    CLEAR = 1,
+}
+impl From<ERROR_AW> for bool {
+    #[inline(always)]
+    fn from(variant: ERROR_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `ERROR` writer - Write '1' to disable interrupt for event ERROR"]
+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"]
+    #[inline(always)]
+    pub fn clear(self) -> &'a mut W {
+        self.variant(ERROR_AW::CLEAR)
+    }
+}
+#[doc = "Field `SUSPENDED` reader - Write '1' to disable interrupt for event SUSPENDED"]
+pub type SUSPENDED_R = crate::BitReader<SUSPENDED_A>;
+#[doc = "Write '1' to disable interrupt for event SUSPENDED\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum SUSPENDED_A {
+    #[doc = "0: Read: Disabled"]
+    DISABLED = 0,
+    #[doc = "1: Read: Enabled"]
+    ENABLED = 1,
+}
+impl From<SUSPENDED_A> for bool {
+    #[inline(always)]
+    fn from(variant: SUSPENDED_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl SUSPENDED_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> SUSPENDED_A {
+        match self.bits {
+            false => SUSPENDED_A::DISABLED,
+            true => SUSPENDED_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == SUSPENDED_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == SUSPENDED_A::ENABLED
+    }
+}
+#[doc = "Write '1' to disable interrupt for event SUSPENDED\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum SUSPENDED_AW {
+    #[doc = "1: Disable"]
+    CLEAR = 1,
+}
+impl From<SUSPENDED_AW> for bool {
+    #[inline(always)]
+    fn from(variant: SUSPENDED_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `SUSPENDED` writer - Write '1' to disable interrupt for event SUSPENDED"]
+pub type SUSPENDED_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, SUSPENDED_AW, O>;
+impl<'a, const O: u8> SUSPENDED_W<'a, O> {
+    #[doc = "Disable"]
+    #[inline(always)]
+    pub fn clear(self) -> &'a mut W {
+        self.variant(SUSPENDED_AW::CLEAR)
+    }
+}
+#[doc = "Field `RXSTARTED` reader - Write '1' to disable interrupt for event RXSTARTED"]
+pub type RXSTARTED_R = crate::BitReader<RXSTARTED_A>;
+#[doc = "Write '1' to disable interrupt for event RXSTARTED\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum RXSTARTED_A {
+    #[doc = "0: Read: Disabled"]
+    DISABLED = 0,
+    #[doc = "1: Read: Enabled"]
+    ENABLED = 1,
+}
+impl From<RXSTARTED_A> for bool {
+    #[inline(always)]
+    fn from(variant: RXSTARTED_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl RXSTARTED_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> RXSTARTED_A {
+        match self.bits {
+            false => RXSTARTED_A::DISABLED,
+            true => RXSTARTED_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == RXSTARTED_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == RXSTARTED_A::ENABLED
+    }
+}
+#[doc = "Write '1' to disable interrupt for event RXSTARTED\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum RXSTARTED_AW {
+    #[doc = "1: Disable"]
+    CLEAR = 1,
+}
+impl From<RXSTARTED_AW> for bool {
+    #[inline(always)]
+    fn from(variant: RXSTARTED_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `RXSTARTED` writer - Write '1' to disable interrupt for event RXSTARTED"]
+pub type RXSTARTED_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, RXSTARTED_AW, O>;
+impl<'a, const O: u8> RXSTARTED_W<'a, O> {
+    #[doc = "Disable"]
+    #[inline(always)]
+    pub fn clear(self) -> &'a mut W {
+        self.variant(RXSTARTED_AW::CLEAR)
+    }
+}
+#[doc = "Field `TXSTARTED` reader - Write '1' to disable interrupt for event TXSTARTED"]
+pub type TXSTARTED_R = crate::BitReader<TXSTARTED_A>;
+#[doc = "Write '1' to disable interrupt for event TXSTARTED\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum TXSTARTED_A {
+    #[doc = "0: Read: Disabled"]
+    DISABLED = 0,
+    #[doc = "1: Read: Enabled"]
+    ENABLED = 1,
+}
+impl From<TXSTARTED_A> for bool {
+    #[inline(always)]
+    fn from(variant: TXSTARTED_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl TXSTARTED_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> TXSTARTED_A {
+        match self.bits {
+            false => TXSTARTED_A::DISABLED,
+            true => TXSTARTED_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == TXSTARTED_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == TXSTARTED_A::ENABLED
+    }
+}
+#[doc = "Write '1' to disable interrupt for event TXSTARTED\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum TXSTARTED_AW {
+    #[doc = "1: Disable"]
+    CLEAR = 1,
+}
+impl From<TXSTARTED_AW> for bool {
+    #[inline(always)]
+    fn from(variant: TXSTARTED_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `TXSTARTED` writer - Write '1' to disable interrupt for event TXSTARTED"]
+pub type TXSTARTED_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, TXSTARTED_AW, O>;
+impl<'a, const O: u8> TXSTARTED_W<'a, O> {
+    #[doc = "Disable"]
+    #[inline(always)]
+    pub fn clear(self) -> &'a mut W {
+        self.variant(TXSTARTED_AW::CLEAR)
+    }
+}
+#[doc = "Field `LASTRX` reader - Write '1' to disable interrupt for event LASTRX"]
+pub type LASTRX_R = crate::BitReader<LASTRX_A>;
+#[doc = "Write '1' to disable interrupt for event LASTRX\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum LASTRX_A {
+    #[doc = "0: Read: Disabled"]
+    DISABLED = 0,
+    #[doc = "1: Read: Enabled"]
+    ENABLED = 1,
+}
+impl From<LASTRX_A> for bool {
+    #[inline(always)]
+    fn from(variant: LASTRX_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl LASTRX_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> LASTRX_A {
+        match self.bits {
+            false => LASTRX_A::DISABLED,
+            true => LASTRX_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == LASTRX_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == LASTRX_A::ENABLED
+    }
+}
+#[doc = "Write '1' to disable interrupt for event LASTRX\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum LASTRX_AW {
+    #[doc = "1: Disable"]
+    CLEAR = 1,
+}
+impl From<LASTRX_AW> for bool {
+    #[inline(always)]
+    fn from(variant: LASTRX_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `LASTRX` writer - Write '1' to disable interrupt for event LASTRX"]
+pub type LASTRX_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, LASTRX_AW, O>;
+impl<'a, const O: u8> LASTRX_W<'a, O> {
+    #[doc = "Disable"]
+    #[inline(always)]
+    pub fn clear(self) -> &'a mut W {
+        self.variant(LASTRX_AW::CLEAR)
+    }
+}
+#[doc = "Field `LASTTX` reader - Write '1' to disable interrupt for event LASTTX"]
+pub type LASTTX_R = crate::BitReader<LASTTX_A>;
+#[doc = "Write '1' to disable interrupt for event LASTTX\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum LASTTX_A {
+    #[doc = "0: Read: Disabled"]
+    DISABLED = 0,
+    #[doc = "1: Read: Enabled"]
+    ENABLED = 1,
+}
+impl From<LASTTX_A> for bool {
+    #[inline(always)]
+    fn from(variant: LASTTX_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl LASTTX_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> LASTTX_A {
+        match self.bits {
+            false => LASTTX_A::DISABLED,
+            true => LASTTX_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == LASTTX_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == LASTTX_A::ENABLED
+    }
+}
+#[doc = "Write '1' to disable interrupt for event LASTTX\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum LASTTX_AW {
+    #[doc = "1: Disable"]
+    CLEAR = 1,
+}
+impl From<LASTTX_AW> for bool {
+    #[inline(always)]
+    fn from(variant: LASTTX_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `LASTTX` writer - Write '1' to disable interrupt for event LASTTX"]
+pub type LASTTX_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, LASTTX_AW, O>;
+impl<'a, const O: u8> LASTTX_W<'a, O> {
+    #[doc = "Disable"]
+    #[inline(always)]
+    pub fn clear(self) -> &'a mut W {
+        self.variant(LASTTX_AW::CLEAR)
+    }
+}
+impl R {
+    #[doc = "Bit 1 - Write '1' to disable interrupt for event STOPPED"]
+    #[inline(always)]
+    pub fn stopped(&self) -> STOPPED_R {
+        STOPPED_R::new(((self.bits >> 1) & 1) != 0)
+    }
+    #[doc = "Bit 9 - Write '1' to disable interrupt for event ERROR"]
+    #[inline(always)]
+    pub fn error(&self) -> ERROR_R {
+        ERROR_R::new(((self.bits >> 9) & 1) != 0)
+    }
+    #[doc = "Bit 18 - Write '1' to disable interrupt for event SUSPENDED"]
+    #[inline(always)]
+    pub fn suspended(&self) -> SUSPENDED_R {
+        SUSPENDED_R::new(((self.bits >> 18) & 1) != 0)
+    }
+    #[doc = "Bit 19 - Write '1' to disable interrupt for event RXSTARTED"]
+    #[inline(always)]
+    pub fn rxstarted(&self) -> RXSTARTED_R {
+        RXSTARTED_R::new(((self.bits >> 19) & 1) != 0)
+    }
+    #[doc = "Bit 20 - Write '1' to disable interrupt for event TXSTARTED"]
+    #[inline(always)]
+    pub fn txstarted(&self) -> TXSTARTED_R {
+        TXSTARTED_R::new(((self.bits >> 20) & 1) != 0)
+    }
+    #[doc = "Bit 23 - Write '1' to disable interrupt for event LASTRX"]
+    #[inline(always)]
+    pub fn lastrx(&self) -> LASTRX_R {
+        LASTRX_R::new(((self.bits >> 23) & 1) != 0)
+    }
+    #[doc = "Bit 24 - Write '1' to disable interrupt for event LASTTX"]
+    #[inline(always)]
+    pub fn lasttx(&self) -> LASTTX_R {
+        LASTTX_R::new(((self.bits >> 24) & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bit 1 - Write '1' to disable interrupt for event STOPPED"]
+    #[inline(always)]
+    pub fn stopped(&mut self) -> STOPPED_W<1> {
+        STOPPED_W::new(self)
+    }
+    #[doc = "Bit 9 - Write '1' to disable interrupt for event ERROR"]
+    #[inline(always)]
+    pub fn error(&mut self) -> ERROR_W<9> {
+        ERROR_W::new(self)
+    }
+    #[doc = "Bit 18 - Write '1' to disable interrupt for event SUSPENDED"]
+    #[inline(always)]
+    pub fn suspended(&mut self) -> SUSPENDED_W<18> {
+        SUSPENDED_W::new(self)
+    }
+    #[doc = "Bit 19 - Write '1' to disable interrupt for event RXSTARTED"]
+    #[inline(always)]
+    pub fn rxstarted(&mut self) -> RXSTARTED_W<19> {
+        RXSTARTED_W::new(self)
+    }
+    #[doc = "Bit 20 - Write '1' to disable interrupt for event TXSTARTED"]
+    #[inline(always)]
+    pub fn txstarted(&mut self) -> TXSTARTED_W<20> {
+        TXSTARTED_W::new(self)
+    }
+    #[doc = "Bit 23 - Write '1' to disable interrupt for event LASTRX"]
+    #[inline(always)]
+    pub fn lastrx(&mut self) -> LASTRX_W<23> {
+        LASTRX_W::new(self)
+    }
+    #[doc = "Bit 24 - Write '1' to disable interrupt for event LASTTX"]
+    #[inline(always)]
+    pub fn lasttx(&mut self) -> LASTTX_W<24> {
+        LASTTX_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 = "Disable interrupt\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/nrf52833-pac/src/twim0/intenset.rs

@@ -0,0 +1,535 @@
+#[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 `STOPPED` reader - Write '1' to enable interrupt for event STOPPED"]
+pub type STOPPED_R = crate::BitReader<STOPPED_A>;
+#[doc = "Write '1' to enable interrupt for event STOPPED\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum STOPPED_A {
+    #[doc = "0: Read: Disabled"]
+    DISABLED = 0,
+    #[doc = "1: Read: Enabled"]
+    ENABLED = 1,
+}
+impl From<STOPPED_A> for bool {
+    #[inline(always)]
+    fn from(variant: STOPPED_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl STOPPED_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> STOPPED_A {
+        match self.bits {
+            false => STOPPED_A::DISABLED,
+            true => STOPPED_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == STOPPED_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == STOPPED_A::ENABLED
+    }
+}
+#[doc = "Write '1' to enable interrupt for event STOPPED\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum STOPPED_AW {
+    #[doc = "1: Enable"]
+    SET = 1,
+}
+impl From<STOPPED_AW> for bool {
+    #[inline(always)]
+    fn from(variant: STOPPED_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `STOPPED` writer - Write '1' to enable interrupt for event STOPPED"]
+pub type STOPPED_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, STOPPED_AW, O>;
+impl<'a, const O: u8> STOPPED_W<'a, O> {
+    #[doc = "Enable"]
+    #[inline(always)]
+    pub fn set(self) -> &'a mut W {
+        self.variant(STOPPED_AW::SET)
+    }
+}
+#[doc = "Field `ERROR` reader - Write '1' to enable interrupt for event ERROR"]
+pub type ERROR_R = crate::BitReader<ERROR_A>;
+#[doc = "Write '1' to enable interrupt for event ERROR\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum ERROR_A {
+    #[doc = "0: Read: Disabled"]
+    DISABLED = 0,
+    #[doc = "1: Read: 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 = "Write '1' to enable interrupt for event ERROR\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum ERROR_AW {
+    #[doc = "1: Enable"]
+    SET = 1,
+}
+impl From<ERROR_AW> for bool {
+    #[inline(always)]
+    fn from(variant: ERROR_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `ERROR` writer - Write '1' to enable interrupt for event ERROR"]
+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"]
+    #[inline(always)]
+    pub fn set(self) -> &'a mut W {
+        self.variant(ERROR_AW::SET)
+    }
+}
+#[doc = "Field `SUSPENDED` reader - Write '1' to enable interrupt for event SUSPENDED"]
+pub type SUSPENDED_R = crate::BitReader<SUSPENDED_A>;
+#[doc = "Write '1' to enable interrupt for event SUSPENDED\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum SUSPENDED_A {
+    #[doc = "0: Read: Disabled"]
+    DISABLED = 0,
+    #[doc = "1: Read: Enabled"]
+    ENABLED = 1,
+}
+impl From<SUSPENDED_A> for bool {
+    #[inline(always)]
+    fn from(variant: SUSPENDED_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl SUSPENDED_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> SUSPENDED_A {
+        match self.bits {
+            false => SUSPENDED_A::DISABLED,
+            true => SUSPENDED_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == SUSPENDED_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == SUSPENDED_A::ENABLED
+    }
+}
+#[doc = "Write '1' to enable interrupt for event SUSPENDED\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum SUSPENDED_AW {
+    #[doc = "1: Enable"]
+    SET = 1,
+}
+impl From<SUSPENDED_AW> for bool {
+    #[inline(always)]
+    fn from(variant: SUSPENDED_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `SUSPENDED` writer - Write '1' to enable interrupt for event SUSPENDED"]
+pub type SUSPENDED_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, SUSPENDED_AW, O>;
+impl<'a, const O: u8> SUSPENDED_W<'a, O> {
+    #[doc = "Enable"]
+    #[inline(always)]
+    pub fn set(self) -> &'a mut W {
+        self.variant(SUSPENDED_AW::SET)
+    }
+}
+#[doc = "Field `RXSTARTED` reader - Write '1' to enable interrupt for event RXSTARTED"]
+pub type RXSTARTED_R = crate::BitReader<RXSTARTED_A>;
+#[doc = "Write '1' to enable interrupt for event RXSTARTED\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum RXSTARTED_A {
+    #[doc = "0: Read: Disabled"]
+    DISABLED = 0,
+    #[doc = "1: Read: Enabled"]
+    ENABLED = 1,
+}
+impl From<RXSTARTED_A> for bool {
+    #[inline(always)]
+    fn from(variant: RXSTARTED_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl RXSTARTED_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> RXSTARTED_A {
+        match self.bits {
+            false => RXSTARTED_A::DISABLED,
+            true => RXSTARTED_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == RXSTARTED_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == RXSTARTED_A::ENABLED
+    }
+}
+#[doc = "Write '1' to enable interrupt for event RXSTARTED\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum RXSTARTED_AW {
+    #[doc = "1: Enable"]
+    SET = 1,
+}
+impl From<RXSTARTED_AW> for bool {
+    #[inline(always)]
+    fn from(variant: RXSTARTED_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `RXSTARTED` writer - Write '1' to enable interrupt for event RXSTARTED"]
+pub type RXSTARTED_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, RXSTARTED_AW, O>;
+impl<'a, const O: u8> RXSTARTED_W<'a, O> {
+    #[doc = "Enable"]
+    #[inline(always)]
+    pub fn set(self) -> &'a mut W {
+        self.variant(RXSTARTED_AW::SET)
+    }
+}
+#[doc = "Field `TXSTARTED` reader - Write '1' to enable interrupt for event TXSTARTED"]
+pub type TXSTARTED_R = crate::BitReader<TXSTARTED_A>;
+#[doc = "Write '1' to enable interrupt for event TXSTARTED\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum TXSTARTED_A {
+    #[doc = "0: Read: Disabled"]
+    DISABLED = 0,
+    #[doc = "1: Read: Enabled"]
+    ENABLED = 1,
+}
+impl From<TXSTARTED_A> for bool {
+    #[inline(always)]
+    fn from(variant: TXSTARTED_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl TXSTARTED_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> TXSTARTED_A {
+        match self.bits {
+            false => TXSTARTED_A::DISABLED,
+            true => TXSTARTED_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == TXSTARTED_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == TXSTARTED_A::ENABLED
+    }
+}
+#[doc = "Write '1' to enable interrupt for event TXSTARTED\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum TXSTARTED_AW {
+    #[doc = "1: Enable"]
+    SET = 1,
+}
+impl From<TXSTARTED_AW> for bool {
+    #[inline(always)]
+    fn from(variant: TXSTARTED_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `TXSTARTED` writer - Write '1' to enable interrupt for event TXSTARTED"]
+pub type TXSTARTED_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, TXSTARTED_AW, O>;
+impl<'a, const O: u8> TXSTARTED_W<'a, O> {
+    #[doc = "Enable"]
+    #[inline(always)]
+    pub fn set(self) -> &'a mut W {
+        self.variant(TXSTARTED_AW::SET)
+    }
+}
+#[doc = "Field `LASTRX` reader - Write '1' to enable interrupt for event LASTRX"]
+pub type LASTRX_R = crate::BitReader<LASTRX_A>;
+#[doc = "Write '1' to enable interrupt for event LASTRX\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum LASTRX_A {
+    #[doc = "0: Read: Disabled"]
+    DISABLED = 0,
+    #[doc = "1: Read: Enabled"]
+    ENABLED = 1,
+}
+impl From<LASTRX_A> for bool {
+    #[inline(always)]
+    fn from(variant: LASTRX_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl LASTRX_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> LASTRX_A {
+        match self.bits {
+            false => LASTRX_A::DISABLED,
+            true => LASTRX_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == LASTRX_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == LASTRX_A::ENABLED
+    }
+}
+#[doc = "Write '1' to enable interrupt for event LASTRX\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum LASTRX_AW {
+    #[doc = "1: Enable"]
+    SET = 1,
+}
+impl From<LASTRX_AW> for bool {
+    #[inline(always)]
+    fn from(variant: LASTRX_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `LASTRX` writer - Write '1' to enable interrupt for event LASTRX"]
+pub type LASTRX_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, LASTRX_AW, O>;
+impl<'a, const O: u8> LASTRX_W<'a, O> {
+    #[doc = "Enable"]
+    #[inline(always)]
+    pub fn set(self) -> &'a mut W {
+        self.variant(LASTRX_AW::SET)
+    }
+}
+#[doc = "Field `LASTTX` reader - Write '1' to enable interrupt for event LASTTX"]
+pub type LASTTX_R = crate::BitReader<LASTTX_A>;
+#[doc = "Write '1' to enable interrupt for event LASTTX\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum LASTTX_A {
+    #[doc = "0: Read: Disabled"]
+    DISABLED = 0,
+    #[doc = "1: Read: Enabled"]
+    ENABLED = 1,
+}
+impl From<LASTTX_A> for bool {
+    #[inline(always)]
+    fn from(variant: LASTTX_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl LASTTX_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> LASTTX_A {
+        match self.bits {
+            false => LASTTX_A::DISABLED,
+            true => LASTTX_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == LASTTX_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == LASTTX_A::ENABLED
+    }
+}
+#[doc = "Write '1' to enable interrupt for event LASTTX\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum LASTTX_AW {
+    #[doc = "1: Enable"]
+    SET = 1,
+}
+impl From<LASTTX_AW> for bool {
+    #[inline(always)]
+    fn from(variant: LASTTX_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `LASTTX` writer - Write '1' to enable interrupt for event LASTTX"]
+pub type LASTTX_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, LASTTX_AW, O>;
+impl<'a, const O: u8> LASTTX_W<'a, O> {
+    #[doc = "Enable"]
+    #[inline(always)]
+    pub fn set(self) -> &'a mut W {
+        self.variant(LASTTX_AW::SET)
+    }
+}
+impl R {
+    #[doc = "Bit 1 - Write '1' to enable interrupt for event STOPPED"]
+    #[inline(always)]
+    pub fn stopped(&self) -> STOPPED_R {
+        STOPPED_R::new(((self.bits >> 1) & 1) != 0)
+    }
+    #[doc = "Bit 9 - Write '1' to enable interrupt for event ERROR"]
+    #[inline(always)]
+    pub fn error(&self) -> ERROR_R {
+        ERROR_R::new(((self.bits >> 9) & 1) != 0)
+    }
+    #[doc = "Bit 18 - Write '1' to enable interrupt for event SUSPENDED"]
+    #[inline(always)]
+    pub fn suspended(&self) -> SUSPENDED_R {
+        SUSPENDED_R::new(((self.bits >> 18) & 1) != 0)
+    }
+    #[doc = "Bit 19 - Write '1' to enable interrupt for event RXSTARTED"]
+    #[inline(always)]
+    pub fn rxstarted(&self) -> RXSTARTED_R {
+        RXSTARTED_R::new(((self.bits >> 19) & 1) != 0)
+    }
+    #[doc = "Bit 20 - Write '1' to enable interrupt for event TXSTARTED"]
+    #[inline(always)]
+    pub fn txstarted(&self) -> TXSTARTED_R {
+        TXSTARTED_R::new(((self.bits >> 20) & 1) != 0)
+    }
+    #[doc = "Bit 23 - Write '1' to enable interrupt for event LASTRX"]
+    #[inline(always)]
+    pub fn lastrx(&self) -> LASTRX_R {
+        LASTRX_R::new(((self.bits >> 23) & 1) != 0)
+    }
+    #[doc = "Bit 24 - Write '1' to enable interrupt for event LASTTX"]
+    #[inline(always)]
+    pub fn lasttx(&self) -> LASTTX_R {
+        LASTTX_R::new(((self.bits >> 24) & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bit 1 - Write '1' to enable interrupt for event STOPPED"]
+    #[inline(always)]
+    pub fn stopped(&mut self) -> STOPPED_W<1> {
+        STOPPED_W::new(self)
+    }
+    #[doc = "Bit 9 - Write '1' to enable interrupt for event ERROR"]
+    #[inline(always)]
+    pub fn error(&mut self) -> ERROR_W<9> {
+        ERROR_W::new(self)
+    }
+    #[doc = "Bit 18 - Write '1' to enable interrupt for event SUSPENDED"]
+    #[inline(always)]
+    pub fn suspended(&mut self) -> SUSPENDED_W<18> {
+        SUSPENDED_W::new(self)
+    }
+    #[doc = "Bit 19 - Write '1' to enable interrupt for event RXSTARTED"]
+    #[inline(always)]
+    pub fn rxstarted(&mut self) -> RXSTARTED_W<19> {
+        RXSTARTED_W::new(self)
+    }
+    #[doc = "Bit 20 - Write '1' to enable interrupt for event TXSTARTED"]
+    #[inline(always)]
+    pub fn txstarted(&mut self) -> TXSTARTED_W<20> {
+        TXSTARTED_W::new(self)
+    }
+    #[doc = "Bit 23 - Write '1' to enable interrupt for event LASTRX"]
+    #[inline(always)]
+    pub fn lastrx(&mut self) -> LASTRX_W<23> {
+        LASTRX_W::new(self)
+    }
+    #[doc = "Bit 24 - Write '1' to enable interrupt for event LASTTX"]
+    #[inline(always)]
+    pub fn lasttx(&mut self) -> LASTTX_W<24> {
+        LASTTX_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 interrupt\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/nrf52833-pac/src/twim0/psel.rs

@@ -0,0 +1,16 @@
+#[doc = r"Register block"]
+#[repr(C)]
+pub struct PSEL {
+    #[doc = "0x00 - Pin select for SCL signal"]
+    pub scl: SCL,
+    #[doc = "0x04 - Pin select for SDA signal"]
+    pub sda: SDA,
+}
+#[doc = "SCL (rw) register accessor: an alias for `Reg<SCL_SPEC>`"]
+pub type SCL = crate::Reg<scl::SCL_SPEC>;
+#[doc = "Pin select for SCL signal"]
+pub mod scl;
+#[doc = "SDA (rw) register accessor: an alias for `Reg<SDA_SPEC>`"]
+pub type SDA = crate::Reg<sda::SDA_SPEC>;
+#[doc = "Pin select for SDA signal"]
+pub mod sda;

vendor/nrf52833-pac/src/twim0/psel/scl.rs

@@ -0,0 +1,154 @@
+#[doc = "Register `SCL` reader"]
+pub struct R(crate::R<SCL_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<SCL_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<SCL_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<SCL_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `SCL` writer"]
+pub struct W(crate::W<SCL_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<SCL_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<SCL_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<SCL_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `PIN` reader - Pin number"]
+pub type PIN_R = crate::FieldReader<u8, u8>;
+#[doc = "Field `PIN` writer - Pin number"]
+pub type PIN_W<'a, const O: u8> = crate::FieldWriter<'a, u32, SCL_SPEC, u8, u8, 5, O>;
+#[doc = "Field `PORT` reader - Port number"]
+pub type PORT_R = crate::BitReader<bool>;
+#[doc = "Field `PORT` writer - Port number"]
+pub type PORT_W<'a, const O: u8> = crate::BitWriter<'a, u32, SCL_SPEC, bool, O>;
+#[doc = "Field `CONNECT` reader - Connection"]
+pub type CONNECT_R = crate::BitReader<CONNECT_A>;
+#[doc = "Connection\n\nValue on reset: 1"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum CONNECT_A {
+    #[doc = "1: Disconnect"]
+    DISCONNECTED = 1,
+    #[doc = "0: Connect"]
+    CONNECTED = 0,
+}
+impl From<CONNECT_A> for bool {
+    #[inline(always)]
+    fn from(variant: CONNECT_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl CONNECT_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> CONNECT_A {
+        match self.bits {
+            true => CONNECT_A::DISCONNECTED,
+            false => CONNECT_A::CONNECTED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISCONNECTED`"]
+    #[inline(always)]
+    pub fn is_disconnected(&self) -> bool {
+        *self == CONNECT_A::DISCONNECTED
+    }
+    #[doc = "Checks if the value of the field is `CONNECTED`"]
+    #[inline(always)]
+    pub fn is_connected(&self) -> bool {
+        *self == CONNECT_A::CONNECTED
+    }
+}
+#[doc = "Field `CONNECT` writer - Connection"]
+pub type CONNECT_W<'a, const O: u8> = crate::BitWriter<'a, u32, SCL_SPEC, CONNECT_A, O>;
+impl<'a, const O: u8> CONNECT_W<'a, O> {
+    #[doc = "Disconnect"]
+    #[inline(always)]
+    pub fn disconnected(self) -> &'a mut W {
+        self.variant(CONNECT_A::DISCONNECTED)
+    }
+    #[doc = "Connect"]
+    #[inline(always)]
+    pub fn connected(self) -> &'a mut W {
+        self.variant(CONNECT_A::CONNECTED)
+    }
+}
+impl R {
+    #[doc = "Bits 0:4 - Pin number"]
+    #[inline(always)]
+    pub fn pin(&self) -> PIN_R {
+        PIN_R::new((self.bits & 0x1f) as u8)
+    }
+    #[doc = "Bit 5 - Port number"]
+    #[inline(always)]
+    pub fn port(&self) -> PORT_R {
+        PORT_R::new(((self.bits >> 5) & 1) != 0)
+    }
+    #[doc = "Bit 31 - Connection"]
+    #[inline(always)]
+    pub fn connect(&self) -> CONNECT_R {
+        CONNECT_R::new(((self.bits >> 31) & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bits 0:4 - Pin number"]
+    #[inline(always)]
+    pub fn pin(&mut self) -> PIN_W<0> {
+        PIN_W::new(self)
+    }
+    #[doc = "Bit 5 - Port number"]
+    #[inline(always)]
+    pub fn port(&mut self) -> PORT_W<5> {
+        PORT_W::new(self)
+    }
+    #[doc = "Bit 31 - Connection"]
+    #[inline(always)]
+    pub fn connect(&mut self) -> CONNECT_W<31> {
+        CONNECT_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 = "Pin select for SCL signal\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 [scl](index.html) module"]
+pub struct SCL_SPEC;
+impl crate::RegisterSpec for SCL_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [scl::R](R) reader structure"]
+impl crate::Readable for SCL_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [scl::W](W) writer structure"]
+impl crate::Writable for SCL_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets SCL to value 0xffff_ffff"]
+impl crate::Resettable for SCL_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0xffff_ffff
+    }
+}

vendor/nrf52833-pac/src/twim0/psel/sda.rs

@@ -0,0 +1,154 @@
+#[doc = "Register `SDA` reader"]
+pub struct R(crate::R<SDA_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<SDA_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<SDA_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<SDA_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `SDA` writer"]
+pub struct W(crate::W<SDA_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<SDA_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<SDA_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<SDA_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `PIN` reader - Pin number"]
+pub type PIN_R = crate::FieldReader<u8, u8>;
+#[doc = "Field `PIN` writer - Pin number"]
+pub type PIN_W<'a, const O: u8> = crate::FieldWriter<'a, u32, SDA_SPEC, u8, u8, 5, O>;
+#[doc = "Field `PORT` reader - Port number"]
+pub type PORT_R = crate::BitReader<bool>;
+#[doc = "Field `PORT` writer - Port number"]
+pub type PORT_W<'a, const O: u8> = crate::BitWriter<'a, u32, SDA_SPEC, bool, O>;
+#[doc = "Field `CONNECT` reader - Connection"]
+pub type CONNECT_R = crate::BitReader<CONNECT_A>;
+#[doc = "Connection\n\nValue on reset: 1"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum CONNECT_A {
+    #[doc = "1: Disconnect"]
+    DISCONNECTED = 1,
+    #[doc = "0: Connect"]
+    CONNECTED = 0,
+}
+impl From<CONNECT_A> for bool {
+    #[inline(always)]
+    fn from(variant: CONNECT_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl CONNECT_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> CONNECT_A {
+        match self.bits {
+            true => CONNECT_A::DISCONNECTED,
+            false => CONNECT_A::CONNECTED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISCONNECTED`"]
+    #[inline(always)]
+    pub fn is_disconnected(&self) -> bool {
+        *self == CONNECT_A::DISCONNECTED
+    }
+    #[doc = "Checks if the value of the field is `CONNECTED`"]
+    #[inline(always)]
+    pub fn is_connected(&self) -> bool {
+        *self == CONNECT_A::CONNECTED
+    }
+}
+#[doc = "Field `CONNECT` writer - Connection"]
+pub type CONNECT_W<'a, const O: u8> = crate::BitWriter<'a, u32, SDA_SPEC, CONNECT_A, O>;
+impl<'a, const O: u8> CONNECT_W<'a, O> {
+    #[doc = "Disconnect"]
+    #[inline(always)]
+    pub fn disconnected(self) -> &'a mut W {
+        self.variant(CONNECT_A::DISCONNECTED)
+    }
+    #[doc = "Connect"]
+    #[inline(always)]
+    pub fn connected(self) -> &'a mut W {
+        self.variant(CONNECT_A::CONNECTED)
+    }
+}
+impl R {
+    #[doc = "Bits 0:4 - Pin number"]
+    #[inline(always)]
+    pub fn pin(&self) -> PIN_R {
+        PIN_R::new((self.bits & 0x1f) as u8)
+    }
+    #[doc = "Bit 5 - Port number"]
+    #[inline(always)]
+    pub fn port(&self) -> PORT_R {
+        PORT_R::new(((self.bits >> 5) & 1) != 0)
+    }
+    #[doc = "Bit 31 - Connection"]
+    #[inline(always)]
+    pub fn connect(&self) -> CONNECT_R {
+        CONNECT_R::new(((self.bits >> 31) & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bits 0:4 - Pin number"]
+    #[inline(always)]
+    pub fn pin(&mut self) -> PIN_W<0> {
+        PIN_W::new(self)
+    }
+    #[doc = "Bit 5 - Port number"]
+    #[inline(always)]
+    pub fn port(&mut self) -> PORT_W<5> {
+        PORT_W::new(self)
+    }
+    #[doc = "Bit 31 - Connection"]
+    #[inline(always)]
+    pub fn connect(&mut self) -> CONNECT_W<31> {
+        CONNECT_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 = "Pin select for SDA signal\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 [sda](index.html) module"]
+pub struct SDA_SPEC;
+impl crate::RegisterSpec for SDA_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [sda::R](R) reader structure"]
+impl crate::Readable for SDA_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [sda::W](W) writer structure"]
+impl crate::Writable for SDA_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets SDA to value 0xffff_ffff"]
+impl crate::Resettable for SDA_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0xffff_ffff
+    }
+}

vendor/nrf52833-pac/src/twim0/rxd.rs

@@ -0,0 +1,28 @@
+#[doc = r"Register block"]
+#[repr(C)]
+pub struct RXD {
+    #[doc = "0x00 - Data pointer"]
+    pub ptr: PTR,
+    #[doc = "0x04 - Maximum number of bytes in receive buffer"]
+    pub maxcnt: MAXCNT,
+    #[doc = "0x08 - Number of bytes transferred in the last transaction"]
+    pub amount: AMOUNT,
+    #[doc = "0x0c - EasyDMA list type"]
+    pub list: LIST,
+}
+#[doc = "PTR (rw) register accessor: an alias for `Reg<PTR_SPEC>`"]
+pub type PTR = crate::Reg<ptr::PTR_SPEC>;
+#[doc = "Data pointer"]
+pub mod ptr;
+#[doc = "MAXCNT (rw) register accessor: an alias for `Reg<MAXCNT_SPEC>`"]
+pub type MAXCNT = crate::Reg<maxcnt::MAXCNT_SPEC>;
+#[doc = "Maximum number of bytes in receive buffer"]
+pub mod maxcnt;
+#[doc = "AMOUNT (r) register accessor: an alias for `Reg<AMOUNT_SPEC>`"]
+pub type AMOUNT = crate::Reg<amount::AMOUNT_SPEC>;
+#[doc = "Number of bytes transferred in the last transaction"]
+pub mod amount;
+#[doc = "LIST (rw) register accessor: an alias for `Reg<LIST_SPEC>`"]
+pub type LIST = crate::Reg<list::LIST_SPEC>;
+#[doc = "EasyDMA list type"]
+pub mod list;

vendor/nrf52833-pac/src/twim0/rxd/amount.rs

@@ -0,0 +1,40 @@
+#[doc = "Register `AMOUNT` reader"]
+pub struct R(crate::R<AMOUNT_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<AMOUNT_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<AMOUNT_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<AMOUNT_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `AMOUNT` reader - Number of bytes transferred in the last transaction. In case of NACK error, includes the NACK'ed byte."]
+pub type AMOUNT_R = crate::FieldReader<u16, u16>;
+impl R {
+    #[doc = "Bits 0:15 - Number of bytes transferred in the last transaction. In case of NACK error, includes the NACK'ed byte."]
+    #[inline(always)]
+    pub fn amount(&self) -> AMOUNT_R {
+        AMOUNT_R::new((self.bits & 0xffff) as u16)
+    }
+}
+#[doc = "Number of bytes transferred in the last transaction\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 [amount](index.html) module"]
+pub struct AMOUNT_SPEC;
+impl crate::RegisterSpec for AMOUNT_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [amount::R](R) reader structure"]
+impl crate::Readable for AMOUNT_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets AMOUNT to value 0"]
+impl crate::Resettable for AMOUNT_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf52833-pac/src/twim0/rxd/list.rs

@@ -0,0 +1,128 @@
+#[doc = "Register `LIST` reader"]
+pub struct R(crate::R<LIST_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<LIST_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<LIST_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<LIST_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `LIST` writer"]
+pub struct W(crate::W<LIST_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<LIST_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<LIST_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<LIST_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `LIST` reader - List type"]
+pub type LIST_R = crate::FieldReader<u8, LIST_A>;
+#[doc = "List type\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+#[repr(u8)]
+pub enum LIST_A {
+    #[doc = "0: Disable EasyDMA list"]
+    DISABLED = 0,
+    #[doc = "1: Use array list"]
+    ARRAY_LIST = 1,
+}
+impl From<LIST_A> for u8 {
+    #[inline(always)]
+    fn from(variant: LIST_A) -> Self {
+        variant as _
+    }
+}
+impl LIST_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> Option<LIST_A> {
+        match self.bits {
+            0 => Some(LIST_A::DISABLED),
+            1 => Some(LIST_A::ARRAY_LIST),
+            _ => None,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == LIST_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ARRAY_LIST`"]
+    #[inline(always)]
+    pub fn is_array_list(&self) -> bool {
+        *self == LIST_A::ARRAY_LIST
+    }
+}
+#[doc = "Field `LIST` writer - List type"]
+pub type LIST_W<'a, const O: u8> = crate::FieldWriter<'a, u32, LIST_SPEC, u8, LIST_A, 3, O>;
+impl<'a, const O: u8> LIST_W<'a, O> {
+    #[doc = "Disable EasyDMA list"]
+    #[inline(always)]
+    pub fn disabled(self) -> &'a mut W {
+        self.variant(LIST_A::DISABLED)
+    }
+    #[doc = "Use array list"]
+    #[inline(always)]
+    pub fn array_list(self) -> &'a mut W {
+        self.variant(LIST_A::ARRAY_LIST)
+    }
+}
+impl R {
+    #[doc = "Bits 0:2 - List type"]
+    #[inline(always)]
+    pub fn list(&self) -> LIST_R {
+        LIST_R::new((self.bits & 7) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:2 - List type"]
+    #[inline(always)]
+    pub fn list(&mut self) -> LIST_W<0> {
+        LIST_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 = "EasyDMA list type\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 [list](index.html) module"]
+pub struct LIST_SPEC;
+impl crate::RegisterSpec for LIST_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [list::R](R) reader structure"]
+impl crate::Readable for LIST_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [list::W](W) writer structure"]
+impl crate::Writable for LIST_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets LIST to value 0"]
+impl crate::Resettable for LIST_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf52833-pac/src/twim0/rxd/maxcnt.rs

@@ -0,0 +1,80 @@
+#[doc = "Register `MAXCNT` reader"]
+pub struct R(crate::R<MAXCNT_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<MAXCNT_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<MAXCNT_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<MAXCNT_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `MAXCNT` writer"]
+pub struct W(crate::W<MAXCNT_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<MAXCNT_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<MAXCNT_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<MAXCNT_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `MAXCNT` reader - Maximum number of bytes in receive buffer"]
+pub type MAXCNT_R = crate::FieldReader<u16, u16>;
+#[doc = "Field `MAXCNT` writer - Maximum number of bytes in receive buffer"]
+pub type MAXCNT_W<'a, const O: u8> = crate::FieldWriter<'a, u32, MAXCNT_SPEC, u16, u16, 16, O>;
+impl R {
+    #[doc = "Bits 0:15 - Maximum number of bytes in receive buffer"]
+    #[inline(always)]
+    pub fn maxcnt(&self) -> MAXCNT_R {
+        MAXCNT_R::new((self.bits & 0xffff) as u16)
+    }
+}
+impl W {
+    #[doc = "Bits 0:15 - Maximum number of bytes in receive buffer"]
+    #[inline(always)]
+    pub fn maxcnt(&mut self) -> MAXCNT_W<0> {
+        MAXCNT_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 = "Maximum number of bytes in receive buffer\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 [maxcnt](index.html) module"]
+pub struct MAXCNT_SPEC;
+impl crate::RegisterSpec for MAXCNT_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [maxcnt::R](R) reader structure"]
+impl crate::Readable for MAXCNT_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [maxcnt::W](W) writer structure"]
+impl crate::Writable for MAXCNT_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets MAXCNT to value 0"]
+impl crate::Resettable for MAXCNT_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf52833-pac/src/twim0/rxd/ptr.rs

@@ -0,0 +1,80 @@
+#[doc = "Register `PTR` reader"]
+pub struct R(crate::R<PTR_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<PTR_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<PTR_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<PTR_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `PTR` writer"]
+pub struct W(crate::W<PTR_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<PTR_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<PTR_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<PTR_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `PTR` reader - Data pointer"]
+pub type PTR_R = crate::FieldReader<u32, u32>;
+#[doc = "Field `PTR` writer - Data pointer"]
+pub type PTR_W<'a, const O: u8> = crate::FieldWriter<'a, u32, PTR_SPEC, u32, u32, 32, O>;
+impl R {
+    #[doc = "Bits 0:31 - Data pointer"]
+    #[inline(always)]
+    pub fn ptr(&self) -> PTR_R {
+        PTR_R::new(self.bits)
+    }
+}
+impl W {
+    #[doc = "Bits 0:31 - Data pointer"]
+    #[inline(always)]
+    pub fn ptr(&mut self) -> PTR_W<0> {
+        PTR_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 = "Data pointer\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 [ptr](index.html) module"]
+pub struct PTR_SPEC;
+impl crate::RegisterSpec for PTR_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [ptr::R](R) reader structure"]
+impl crate::Readable for PTR_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [ptr::W](W) writer structure"]
+impl crate::Writable for PTR_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets PTR to value 0"]
+impl crate::Resettable for PTR_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf52833-pac/src/twim0/shorts.rs

@@ -0,0 +1,430 @@
+#[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 `LASTTX_STARTRX` reader - Shortcut between event LASTTX and task STARTRX"]
+pub type LASTTX_STARTRX_R = crate::BitReader<LASTTX_STARTRX_A>;
+#[doc = "Shortcut between event LASTTX and task STARTRX\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum LASTTX_STARTRX_A {
+    #[doc = "0: Disable shortcut"]
+    DISABLED = 0,
+    #[doc = "1: Enable shortcut"]
+    ENABLED = 1,
+}
+impl From<LASTTX_STARTRX_A> for bool {
+    #[inline(always)]
+    fn from(variant: LASTTX_STARTRX_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl LASTTX_STARTRX_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> LASTTX_STARTRX_A {
+        match self.bits {
+            false => LASTTX_STARTRX_A::DISABLED,
+            true => LASTTX_STARTRX_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == LASTTX_STARTRX_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == LASTTX_STARTRX_A::ENABLED
+    }
+}
+#[doc = "Field `LASTTX_STARTRX` writer - Shortcut between event LASTTX and task STARTRX"]
+pub type LASTTX_STARTRX_W<'a, const O: u8> =
+    crate::BitWriter<'a, u32, SHORTS_SPEC, LASTTX_STARTRX_A, O>;
+impl<'a, const O: u8> LASTTX_STARTRX_W<'a, O> {
+    #[doc = "Disable shortcut"]
+    #[inline(always)]
+    pub fn disabled(self) -> &'a mut W {
+        self.variant(LASTTX_STARTRX_A::DISABLED)
+    }
+    #[doc = "Enable shortcut"]
+    #[inline(always)]
+    pub fn enabled(self) -> &'a mut W {
+        self.variant(LASTTX_STARTRX_A::ENABLED)
+    }
+}
+#[doc = "Field `LASTTX_SUSPEND` reader - Shortcut between event LASTTX and task SUSPEND"]
+pub type LASTTX_SUSPEND_R = crate::BitReader<LASTTX_SUSPEND_A>;
+#[doc = "Shortcut between event LASTTX and task SUSPEND\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum LASTTX_SUSPEND_A {
+    #[doc = "0: Disable shortcut"]
+    DISABLED = 0,
+    #[doc = "1: Enable shortcut"]
+    ENABLED = 1,
+}
+impl From<LASTTX_SUSPEND_A> for bool {
+    #[inline(always)]
+    fn from(variant: LASTTX_SUSPEND_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl LASTTX_SUSPEND_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> LASTTX_SUSPEND_A {
+        match self.bits {
+            false => LASTTX_SUSPEND_A::DISABLED,
+            true => LASTTX_SUSPEND_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == LASTTX_SUSPEND_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == LASTTX_SUSPEND_A::ENABLED
+    }
+}
+#[doc = "Field `LASTTX_SUSPEND` writer - Shortcut between event LASTTX and task SUSPEND"]
+pub type LASTTX_SUSPEND_W<'a, const O: u8> =
+    crate::BitWriter<'a, u32, SHORTS_SPEC, LASTTX_SUSPEND_A, O>;
+impl<'a, const O: u8> LASTTX_SUSPEND_W<'a, O> {
+    #[doc = "Disable shortcut"]
+    #[inline(always)]
+    pub fn disabled(self) -> &'a mut W {
+        self.variant(LASTTX_SUSPEND_A::DISABLED)
+    }
+    #[doc = "Enable shortcut"]
+    #[inline(always)]
+    pub fn enabled(self) -> &'a mut W {
+        self.variant(LASTTX_SUSPEND_A::ENABLED)
+    }
+}
+#[doc = "Field `LASTTX_STOP` reader - Shortcut between event LASTTX and task STOP"]
+pub type LASTTX_STOP_R = crate::BitReader<LASTTX_STOP_A>;
+#[doc = "Shortcut between event LASTTX and task STOP\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum LASTTX_STOP_A {
+    #[doc = "0: Disable shortcut"]
+    DISABLED = 0,
+    #[doc = "1: Enable shortcut"]
+    ENABLED = 1,
+}
+impl From<LASTTX_STOP_A> for bool {
+    #[inline(always)]
+    fn from(variant: LASTTX_STOP_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl LASTTX_STOP_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> LASTTX_STOP_A {
+        match self.bits {
+            false => LASTTX_STOP_A::DISABLED,
+            true => LASTTX_STOP_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == LASTTX_STOP_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == LASTTX_STOP_A::ENABLED
+    }
+}
+#[doc = "Field `LASTTX_STOP` writer - Shortcut between event LASTTX and task STOP"]
+pub type LASTTX_STOP_W<'a, const O: u8> = crate::BitWriter<'a, u32, SHORTS_SPEC, LASTTX_STOP_A, O>;
+impl<'a, const O: u8> LASTTX_STOP_W<'a, O> {
+    #[doc = "Disable shortcut"]
+    #[inline(always)]
+    pub fn disabled(self) -> &'a mut W {
+        self.variant(LASTTX_STOP_A::DISABLED)
+    }
+    #[doc = "Enable shortcut"]
+    #[inline(always)]
+    pub fn enabled(self) -> &'a mut W {
+        self.variant(LASTTX_STOP_A::ENABLED)
+    }
+}
+#[doc = "Field `LASTRX_STARTTX` reader - Shortcut between event LASTRX and task STARTTX"]
+pub type LASTRX_STARTTX_R = crate::BitReader<LASTRX_STARTTX_A>;
+#[doc = "Shortcut between event LASTRX and task STARTTX\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum LASTRX_STARTTX_A {
+    #[doc = "0: Disable shortcut"]
+    DISABLED = 0,
+    #[doc = "1: Enable shortcut"]
+    ENABLED = 1,
+}
+impl From<LASTRX_STARTTX_A> for bool {
+    #[inline(always)]
+    fn from(variant: LASTRX_STARTTX_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl LASTRX_STARTTX_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> LASTRX_STARTTX_A {
+        match self.bits {
+            false => LASTRX_STARTTX_A::DISABLED,
+            true => LASTRX_STARTTX_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == LASTRX_STARTTX_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == LASTRX_STARTTX_A::ENABLED
+    }
+}
+#[doc = "Field `LASTRX_STARTTX` writer - Shortcut between event LASTRX and task STARTTX"]
+pub type LASTRX_STARTTX_W<'a, const O: u8> =
+    crate::BitWriter<'a, u32, SHORTS_SPEC, LASTRX_STARTTX_A, O>;
+impl<'a, const O: u8> LASTRX_STARTTX_W<'a, O> {
+    #[doc = "Disable shortcut"]
+    #[inline(always)]
+    pub fn disabled(self) -> &'a mut W {
+        self.variant(LASTRX_STARTTX_A::DISABLED)
+    }
+    #[doc = "Enable shortcut"]
+    #[inline(always)]
+    pub fn enabled(self) -> &'a mut W {
+        self.variant(LASTRX_STARTTX_A::ENABLED)
+    }
+}
+#[doc = "Field `LASTRX_SUSPEND` reader - Shortcut between event LASTRX and task SUSPEND"]
+pub type LASTRX_SUSPEND_R = crate::BitReader<LASTRX_SUSPEND_A>;
+#[doc = "Shortcut between event LASTRX and task SUSPEND\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum LASTRX_SUSPEND_A {
+    #[doc = "0: Disable shortcut"]
+    DISABLED = 0,
+    #[doc = "1: Enable shortcut"]
+    ENABLED = 1,
+}
+impl From<LASTRX_SUSPEND_A> for bool {
+    #[inline(always)]
+    fn from(variant: LASTRX_SUSPEND_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl LASTRX_SUSPEND_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> LASTRX_SUSPEND_A {
+        match self.bits {
+            false => LASTRX_SUSPEND_A::DISABLED,
+            true => LASTRX_SUSPEND_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == LASTRX_SUSPEND_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == LASTRX_SUSPEND_A::ENABLED
+    }
+}
+#[doc = "Field `LASTRX_SUSPEND` writer - Shortcut between event LASTRX and task SUSPEND"]
+pub type LASTRX_SUSPEND_W<'a, const O: u8> =
+    crate::BitWriter<'a, u32, SHORTS_SPEC, LASTRX_SUSPEND_A, O>;
+impl<'a, const O: u8> LASTRX_SUSPEND_W<'a, O> {
+    #[doc = "Disable shortcut"]
+    #[inline(always)]
+    pub fn disabled(self) -> &'a mut W {
+        self.variant(LASTRX_SUSPEND_A::DISABLED)
+    }
+    #[doc = "Enable shortcut"]
+    #[inline(always)]
+    pub fn enabled(self) -> &'a mut W {
+        self.variant(LASTRX_SUSPEND_A::ENABLED)
+    }
+}
+#[doc = "Field `LASTRX_STOP` reader - Shortcut between event LASTRX and task STOP"]
+pub type LASTRX_STOP_R = crate::BitReader<LASTRX_STOP_A>;
+#[doc = "Shortcut between event LASTRX and task STOP\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum LASTRX_STOP_A {
+    #[doc = "0: Disable shortcut"]
+    DISABLED = 0,
+    #[doc = "1: Enable shortcut"]
+    ENABLED = 1,
+}
+impl From<LASTRX_STOP_A> for bool {
+    #[inline(always)]
+    fn from(variant: LASTRX_STOP_A) -> Self {
+        variant as u8 != 0
+    }
+}
+impl LASTRX_STOP_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> LASTRX_STOP_A {
+        match self.bits {
+            false => LASTRX_STOP_A::DISABLED,
+            true => LASTRX_STOP_A::ENABLED,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == LASTRX_STOP_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ENABLED`"]
+    #[inline(always)]
+    pub fn is_enabled(&self) -> bool {
+        *self == LASTRX_STOP_A::ENABLED
+    }
+}
+#[doc = "Field `LASTRX_STOP` writer - Shortcut between event LASTRX and task STOP"]
+pub type LASTRX_STOP_W<'a, const O: u8> = crate::BitWriter<'a, u32, SHORTS_SPEC, LASTRX_STOP_A, O>;
+impl<'a, const O: u8> LASTRX_STOP_W<'a, O> {
+    #[doc = "Disable shortcut"]
+    #[inline(always)]
+    pub fn disabled(self) -> &'a mut W {
+        self.variant(LASTRX_STOP_A::DISABLED)
+    }
+    #[doc = "Enable shortcut"]
+    #[inline(always)]
+    pub fn enabled(self) -> &'a mut W {
+        self.variant(LASTRX_STOP_A::ENABLED)
+    }
+}
+impl R {
+    #[doc = "Bit 7 - Shortcut between event LASTTX and task STARTRX"]
+    #[inline(always)]
+    pub fn lasttx_startrx(&self) -> LASTTX_STARTRX_R {
+        LASTTX_STARTRX_R::new(((self.bits >> 7) & 1) != 0)
+    }
+    #[doc = "Bit 8 - Shortcut between event LASTTX and task SUSPEND"]
+    #[inline(always)]
+    pub fn lasttx_suspend(&self) -> LASTTX_SUSPEND_R {
+        LASTTX_SUSPEND_R::new(((self.bits >> 8) & 1) != 0)
+    }
+    #[doc = "Bit 9 - Shortcut between event LASTTX and task STOP"]
+    #[inline(always)]
+    pub fn lasttx_stop(&self) -> LASTTX_STOP_R {
+        LASTTX_STOP_R::new(((self.bits >> 9) & 1) != 0)
+    }
+    #[doc = "Bit 10 - Shortcut between event LASTRX and task STARTTX"]
+    #[inline(always)]
+    pub fn lastrx_starttx(&self) -> LASTRX_STARTTX_R {
+        LASTRX_STARTTX_R::new(((self.bits >> 10) & 1) != 0)
+    }
+    #[doc = "Bit 11 - Shortcut between event LASTRX and task SUSPEND"]
+    #[inline(always)]
+    pub fn lastrx_suspend(&self) -> LASTRX_SUSPEND_R {
+        LASTRX_SUSPEND_R::new(((self.bits >> 11) & 1) != 0)
+    }
+    #[doc = "Bit 12 - Shortcut between event LASTRX and task STOP"]
+    #[inline(always)]
+    pub fn lastrx_stop(&self) -> LASTRX_STOP_R {
+        LASTRX_STOP_R::new(((self.bits >> 12) & 1) != 0)
+    }
+}
+impl W {
+    #[doc = "Bit 7 - Shortcut between event LASTTX and task STARTRX"]
+    #[inline(always)]
+    pub fn lasttx_startrx(&mut self) -> LASTTX_STARTRX_W<7> {
+        LASTTX_STARTRX_W::new(self)
+    }
+    #[doc = "Bit 8 - Shortcut between event LASTTX and task SUSPEND"]
+    #[inline(always)]
+    pub fn lasttx_suspend(&mut self) -> LASTTX_SUSPEND_W<8> {
+        LASTTX_SUSPEND_W::new(self)
+    }
+    #[doc = "Bit 9 - Shortcut between event LASTTX and task STOP"]
+    #[inline(always)]
+    pub fn lasttx_stop(&mut self) -> LASTTX_STOP_W<9> {
+        LASTTX_STOP_W::new(self)
+    }
+    #[doc = "Bit 10 - Shortcut between event LASTRX and task STARTTX"]
+    #[inline(always)]
+    pub fn lastrx_starttx(&mut self) -> LASTRX_STARTTX_W<10> {
+        LASTRX_STARTTX_W::new(self)
+    }
+    #[doc = "Bit 11 - Shortcut between event LASTRX and task SUSPEND"]
+    #[inline(always)]
+    pub fn lastrx_suspend(&mut self) -> LASTRX_SUSPEND_W<11> {
+        LASTRX_SUSPEND_W::new(self)
+    }
+    #[doc = "Bit 12 - Shortcut between event LASTRX and task STOP"]
+    #[inline(always)]
+    pub fn lastrx_stop(&mut self) -> LASTRX_STOP_W<12> {
+        LASTRX_STOP_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 between local events and tasks\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/nrf52833-pac/src/twim0/tasks_resume.rs

@@ -0,0 +1,72 @@
+#[doc = "Register `TASKS_RESUME` writer"]
+pub struct W(crate::W<TASKS_RESUME_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<TASKS_RESUME_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_RESUME_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<TASKS_RESUME_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Resume TWI transaction\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum TASKS_RESUME_AW {
+    #[doc = "1: Trigger task"]
+    TRIGGER = 1,
+}
+impl From<TASKS_RESUME_AW> for bool {
+    #[inline(always)]
+    fn from(variant: TASKS_RESUME_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `TASKS_RESUME` writer - Resume TWI transaction"]
+pub type TASKS_RESUME_W<'a, const O: u8> =
+    crate::BitWriter<'a, u32, TASKS_RESUME_SPEC, TASKS_RESUME_AW, O>;
+impl<'a, const O: u8> TASKS_RESUME_W<'a, O> {
+    #[doc = "Trigger task"]
+    #[inline(always)]
+    pub fn trigger(self) -> &'a mut W {
+        self.variant(TASKS_RESUME_AW::TRIGGER)
+    }
+}
+impl W {
+    #[doc = "Bit 0 - Resume TWI transaction"]
+    #[inline(always)]
+    pub fn tasks_resume(&mut self) -> TASKS_RESUME_W<0> {
+        TASKS_RESUME_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 = "Resume TWI transaction\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_resume](index.html) module"]
+pub struct TASKS_RESUME_SPEC;
+impl crate::RegisterSpec for TASKS_RESUME_SPEC {
+    type Ux = u32;
+}
+#[doc = "`write(|w| ..)` method takes [tasks_resume::W](W) writer structure"]
+impl crate::Writable for TASKS_RESUME_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets TASKS_RESUME to value 0"]
+impl crate::Resettable for TASKS_RESUME_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf52833-pac/src/twim0/tasks_startrx.rs

@@ -0,0 +1,72 @@
+#[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)
+    }
+}
+#[doc = "Start TWI receive sequence\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum TASKS_STARTRX_AW {
+    #[doc = "1: Trigger task"]
+    TRIGGER = 1,
+}
+impl From<TASKS_STARTRX_AW> for bool {
+    #[inline(always)]
+    fn from(variant: TASKS_STARTRX_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `TASKS_STARTRX` writer - Start TWI receive sequence"]
+pub type TASKS_STARTRX_W<'a, const O: u8> =
+    crate::BitWriter<'a, u32, TASKS_STARTRX_SPEC, TASKS_STARTRX_AW, O>;
+impl<'a, const O: u8> TASKS_STARTRX_W<'a, O> {
+    #[doc = "Trigger task"]
+    #[inline(always)]
+    pub fn trigger(self) -> &'a mut W {
+        self.variant(TASKS_STARTRX_AW::TRIGGER)
+    }
+}
+impl W {
+    #[doc = "Bit 0 - Start TWI receive sequence"]
+    #[inline(always)]
+    pub fn tasks_startrx(&mut self) -> TASKS_STARTRX_W<0> {
+        TASKS_STARTRX_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 = "Start TWI receive sequence\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/nrf52833-pac/src/twim0/tasks_starttx.rs

@@ -0,0 +1,72 @@
+#[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)
+    }
+}
+#[doc = "Start TWI transmit sequence\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum TASKS_STARTTX_AW {
+    #[doc = "1: Trigger task"]
+    TRIGGER = 1,
+}
+impl From<TASKS_STARTTX_AW> for bool {
+    #[inline(always)]
+    fn from(variant: TASKS_STARTTX_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `TASKS_STARTTX` writer - Start TWI transmit sequence"]
+pub type TASKS_STARTTX_W<'a, const O: u8> =
+    crate::BitWriter<'a, u32, TASKS_STARTTX_SPEC, TASKS_STARTTX_AW, O>;
+impl<'a, const O: u8> TASKS_STARTTX_W<'a, O> {
+    #[doc = "Trigger task"]
+    #[inline(always)]
+    pub fn trigger(self) -> &'a mut W {
+        self.variant(TASKS_STARTTX_AW::TRIGGER)
+    }
+}
+impl W {
+    #[doc = "Bit 0 - Start TWI transmit sequence"]
+    #[inline(always)]
+    pub fn tasks_starttx(&mut self) -> TASKS_STARTTX_W<0> {
+        TASKS_STARTTX_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 = "Start TWI transmit sequence\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/nrf52833-pac/src/twim0/tasks_stop.rs

@@ -0,0 +1,72 @@
+#[doc = "Register `TASKS_STOP` writer"]
+pub struct W(crate::W<TASKS_STOP_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<TASKS_STOP_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_STOP_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<TASKS_STOP_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Stop TWI transaction. Must be issued while the TWI master is not suspended.\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum TASKS_STOP_AW {
+    #[doc = "1: Trigger task"]
+    TRIGGER = 1,
+}
+impl From<TASKS_STOP_AW> for bool {
+    #[inline(always)]
+    fn from(variant: TASKS_STOP_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `TASKS_STOP` writer - Stop TWI transaction. Must be issued while the TWI master is not suspended."]
+pub type TASKS_STOP_W<'a, const O: u8> =
+    crate::BitWriter<'a, u32, TASKS_STOP_SPEC, TASKS_STOP_AW, O>;
+impl<'a, const O: u8> TASKS_STOP_W<'a, O> {
+    #[doc = "Trigger task"]
+    #[inline(always)]
+    pub fn trigger(self) -> &'a mut W {
+        self.variant(TASKS_STOP_AW::TRIGGER)
+    }
+}
+impl W {
+    #[doc = "Bit 0 - Stop TWI transaction. Must be issued while the TWI master is not suspended."]
+    #[inline(always)]
+    pub fn tasks_stop(&mut self) -> TASKS_STOP_W<0> {
+        TASKS_STOP_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 = "Stop TWI transaction. Must be issued while the TWI master is not suspended.\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_stop](index.html) module"]
+pub struct TASKS_STOP_SPEC;
+impl crate::RegisterSpec for TASKS_STOP_SPEC {
+    type Ux = u32;
+}
+#[doc = "`write(|w| ..)` method takes [tasks_stop::W](W) writer structure"]
+impl crate::Writable for TASKS_STOP_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets TASKS_STOP to value 0"]
+impl crate::Resettable for TASKS_STOP_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf52833-pac/src/twim0/tasks_suspend.rs

@@ -0,0 +1,72 @@
+#[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)
+    }
+}
+#[doc = "Suspend TWI transaction\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum TASKS_SUSPEND_AW {
+    #[doc = "1: Trigger task"]
+    TRIGGER = 1,
+}
+impl From<TASKS_SUSPEND_AW> for bool {
+    #[inline(always)]
+    fn from(variant: TASKS_SUSPEND_AW) -> Self {
+        variant as u8 != 0
+    }
+}
+#[doc = "Field `TASKS_SUSPEND` writer - Suspend TWI transaction"]
+pub type TASKS_SUSPEND_W<'a, const O: u8> =
+    crate::BitWriter<'a, u32, TASKS_SUSPEND_SPEC, TASKS_SUSPEND_AW, O>;
+impl<'a, const O: u8> TASKS_SUSPEND_W<'a, O> {
+    #[doc = "Trigger task"]
+    #[inline(always)]
+    pub fn trigger(self) -> &'a mut W {
+        self.variant(TASKS_SUSPEND_AW::TRIGGER)
+    }
+}
+impl W {
+    #[doc = "Bit 0 - Suspend TWI transaction"]
+    #[inline(always)]
+    pub fn tasks_suspend(&mut self) -> TASKS_SUSPEND_W<0> {
+        TASKS_SUSPEND_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 = "Suspend TWI transaction\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/nrf52833-pac/src/twim0/txd.rs

@@ -0,0 +1,28 @@
+#[doc = r"Register block"]
+#[repr(C)]
+pub struct TXD {
+    #[doc = "0x00 - Data pointer"]
+    pub ptr: PTR,
+    #[doc = "0x04 - Maximum number of bytes in transmit buffer"]
+    pub maxcnt: MAXCNT,
+    #[doc = "0x08 - Number of bytes transferred in the last transaction"]
+    pub amount: AMOUNT,
+    #[doc = "0x0c - EasyDMA list type"]
+    pub list: LIST,
+}
+#[doc = "PTR (rw) register accessor: an alias for `Reg<PTR_SPEC>`"]
+pub type PTR = crate::Reg<ptr::PTR_SPEC>;
+#[doc = "Data pointer"]
+pub mod ptr;
+#[doc = "MAXCNT (rw) register accessor: an alias for `Reg<MAXCNT_SPEC>`"]
+pub type MAXCNT = crate::Reg<maxcnt::MAXCNT_SPEC>;
+#[doc = "Maximum number of bytes in transmit buffer"]
+pub mod maxcnt;
+#[doc = "AMOUNT (r) register accessor: an alias for `Reg<AMOUNT_SPEC>`"]
+pub type AMOUNT = crate::Reg<amount::AMOUNT_SPEC>;
+#[doc = "Number of bytes transferred in the last transaction"]
+pub mod amount;
+#[doc = "LIST (rw) register accessor: an alias for `Reg<LIST_SPEC>`"]
+pub type LIST = crate::Reg<list::LIST_SPEC>;
+#[doc = "EasyDMA list type"]
+pub mod list;

vendor/nrf52833-pac/src/twim0/txd/amount.rs

@@ -0,0 +1,40 @@
+#[doc = "Register `AMOUNT` reader"]
+pub struct R(crate::R<AMOUNT_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<AMOUNT_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<AMOUNT_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<AMOUNT_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Field `AMOUNT` reader - Number of bytes transferred in the last transaction. In case of NACK error, includes the NACK'ed byte."]
+pub type AMOUNT_R = crate::FieldReader<u16, u16>;
+impl R {
+    #[doc = "Bits 0:15 - Number of bytes transferred in the last transaction. In case of NACK error, includes the NACK'ed byte."]
+    #[inline(always)]
+    pub fn amount(&self) -> AMOUNT_R {
+        AMOUNT_R::new((self.bits & 0xffff) as u16)
+    }
+}
+#[doc = "Number of bytes transferred in the last transaction\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 [amount](index.html) module"]
+pub struct AMOUNT_SPEC;
+impl crate::RegisterSpec for AMOUNT_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [amount::R](R) reader structure"]
+impl crate::Readable for AMOUNT_SPEC {
+    type Reader = R;
+}
+#[doc = "`reset()` method sets AMOUNT to value 0"]
+impl crate::Resettable for AMOUNT_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf52833-pac/src/twim0/txd/list.rs

@@ -0,0 +1,128 @@
+#[doc = "Register `LIST` reader"]
+pub struct R(crate::R<LIST_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<LIST_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<LIST_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<LIST_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `LIST` writer"]
+pub struct W(crate::W<LIST_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<LIST_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<LIST_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<LIST_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `LIST` reader - List type"]
+pub type LIST_R = crate::FieldReader<u8, LIST_A>;
+#[doc = "List type\n\nValue on reset: 0"]
+#[derive(Clone, Copy, Debug, PartialEq)]
+#[repr(u8)]
+pub enum LIST_A {
+    #[doc = "0: Disable EasyDMA list"]
+    DISABLED = 0,
+    #[doc = "1: Use array list"]
+    ARRAY_LIST = 1,
+}
+impl From<LIST_A> for u8 {
+    #[inline(always)]
+    fn from(variant: LIST_A) -> Self {
+        variant as _
+    }
+}
+impl LIST_R {
+    #[doc = "Get enumerated values variant"]
+    #[inline(always)]
+    pub fn variant(&self) -> Option<LIST_A> {
+        match self.bits {
+            0 => Some(LIST_A::DISABLED),
+            1 => Some(LIST_A::ARRAY_LIST),
+            _ => None,
+        }
+    }
+    #[doc = "Checks if the value of the field is `DISABLED`"]
+    #[inline(always)]
+    pub fn is_disabled(&self) -> bool {
+        *self == LIST_A::DISABLED
+    }
+    #[doc = "Checks if the value of the field is `ARRAY_LIST`"]
+    #[inline(always)]
+    pub fn is_array_list(&self) -> bool {
+        *self == LIST_A::ARRAY_LIST
+    }
+}
+#[doc = "Field `LIST` writer - List type"]
+pub type LIST_W<'a, const O: u8> = crate::FieldWriter<'a, u32, LIST_SPEC, u8, LIST_A, 3, O>;
+impl<'a, const O: u8> LIST_W<'a, O> {
+    #[doc = "Disable EasyDMA list"]
+    #[inline(always)]
+    pub fn disabled(self) -> &'a mut W {
+        self.variant(LIST_A::DISABLED)
+    }
+    #[doc = "Use array list"]
+    #[inline(always)]
+    pub fn array_list(self) -> &'a mut W {
+        self.variant(LIST_A::ARRAY_LIST)
+    }
+}
+impl R {
+    #[doc = "Bits 0:2 - List type"]
+    #[inline(always)]
+    pub fn list(&self) -> LIST_R {
+        LIST_R::new((self.bits & 7) as u8)
+    }
+}
+impl W {
+    #[doc = "Bits 0:2 - List type"]
+    #[inline(always)]
+    pub fn list(&mut self) -> LIST_W<0> {
+        LIST_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 = "EasyDMA list type\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 [list](index.html) module"]
+pub struct LIST_SPEC;
+impl crate::RegisterSpec for LIST_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [list::R](R) reader structure"]
+impl crate::Readable for LIST_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [list::W](W) writer structure"]
+impl crate::Writable for LIST_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets LIST to value 0"]
+impl crate::Resettable for LIST_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf52833-pac/src/twim0/txd/maxcnt.rs

@@ -0,0 +1,80 @@
+#[doc = "Register `MAXCNT` reader"]
+pub struct R(crate::R<MAXCNT_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<MAXCNT_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<MAXCNT_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<MAXCNT_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `MAXCNT` writer"]
+pub struct W(crate::W<MAXCNT_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<MAXCNT_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<MAXCNT_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<MAXCNT_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `MAXCNT` reader - Maximum number of bytes in transmit buffer"]
+pub type MAXCNT_R = crate::FieldReader<u16, u16>;
+#[doc = "Field `MAXCNT` writer - Maximum number of bytes in transmit buffer"]
+pub type MAXCNT_W<'a, const O: u8> = crate::FieldWriter<'a, u32, MAXCNT_SPEC, u16, u16, 16, O>;
+impl R {
+    #[doc = "Bits 0:15 - Maximum number of bytes in transmit buffer"]
+    #[inline(always)]
+    pub fn maxcnt(&self) -> MAXCNT_R {
+        MAXCNT_R::new((self.bits & 0xffff) as u16)
+    }
+}
+impl W {
+    #[doc = "Bits 0:15 - Maximum number of bytes in transmit buffer"]
+    #[inline(always)]
+    pub fn maxcnt(&mut self) -> MAXCNT_W<0> {
+        MAXCNT_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 = "Maximum number of bytes in transmit buffer\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 [maxcnt](index.html) module"]
+pub struct MAXCNT_SPEC;
+impl crate::RegisterSpec for MAXCNT_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [maxcnt::R](R) reader structure"]
+impl crate::Readable for MAXCNT_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [maxcnt::W](W) writer structure"]
+impl crate::Writable for MAXCNT_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets MAXCNT to value 0"]
+impl crate::Resettable for MAXCNT_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}

vendor/nrf52833-pac/src/twim0/txd/ptr.rs

@@ -0,0 +1,80 @@
+#[doc = "Register `PTR` reader"]
+pub struct R(crate::R<PTR_SPEC>);
+impl core::ops::Deref for R {
+    type Target = crate::R<PTR_SPEC>;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl From<crate::R<PTR_SPEC>> for R {
+    #[inline(always)]
+    fn from(reader: crate::R<PTR_SPEC>) -> Self {
+        R(reader)
+    }
+}
+#[doc = "Register `PTR` writer"]
+pub struct W(crate::W<PTR_SPEC>);
+impl core::ops::Deref for W {
+    type Target = crate::W<PTR_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<PTR_SPEC>> for W {
+    #[inline(always)]
+    fn from(writer: crate::W<PTR_SPEC>) -> Self {
+        W(writer)
+    }
+}
+#[doc = "Field `PTR` reader - Data pointer"]
+pub type PTR_R = crate::FieldReader<u32, u32>;
+#[doc = "Field `PTR` writer - Data pointer"]
+pub type PTR_W<'a, const O: u8> = crate::FieldWriter<'a, u32, PTR_SPEC, u32, u32, 32, O>;
+impl R {
+    #[doc = "Bits 0:31 - Data pointer"]
+    #[inline(always)]
+    pub fn ptr(&self) -> PTR_R {
+        PTR_R::new(self.bits)
+    }
+}
+impl W {
+    #[doc = "Bits 0:31 - Data pointer"]
+    #[inline(always)]
+    pub fn ptr(&mut self) -> PTR_W<0> {
+        PTR_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 = "Data pointer\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 [ptr](index.html) module"]
+pub struct PTR_SPEC;
+impl crate::RegisterSpec for PTR_SPEC {
+    type Ux = u32;
+}
+#[doc = "`read()` method returns [ptr::R](R) reader structure"]
+impl crate::Readable for PTR_SPEC {
+    type Reader = R;
+}
+#[doc = "`write(|w| ..)` method takes [ptr::W](W) writer structure"]
+impl crate::Writable for PTR_SPEC {
+    type Writer = W;
+}
+#[doc = "`reset()` method sets PTR to value 0"]
+impl crate::Resettable for PTR_SPEC {
+    #[inline(always)]
+    fn reset_value() -> Self::Ux {
+        0
+    }
+}