feat: add display UI with splash screen, dashboard, and RSSI sparkline
Implement full SSD1306 OLED display support: - Splash screen on boot (1.5s) with project name, version, board - Dashboard showing radio state, config, counters, RSSI/SNR - RSSI history sparkline (64-sample ring buffer, 2px-wide bars) - DisplayOn/DisplayOff host commands routed via dedicated channel - Pure render functions against generic DrawTarget (no hardware coupling) - Display on/off control bypasses radio task entirely Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
This commit is contained in:
17624 files changed
+4564928
-38
No files matched your search
+128
@@ -0,0 +1,128 @@
|
||||
#[doc = "Register `EVENTS_RECEIVE[%s]` reader"]
|
||||
pub struct R(crate::R<EVENTS_RECEIVE_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<EVENTS_RECEIVE_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<EVENTS_RECEIVE_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<EVENTS_RECEIVE_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `EVENTS_RECEIVE[%s]` writer"]
|
||||
pub struct W(crate::W<EVENTS_RECEIVE_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<EVENTS_RECEIVE_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_RECEIVE_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<EVENTS_RECEIVE_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `EVENTS_RECEIVE` reader - Event received on one or more of the enabled channels in RECEIVE_CNF\\[n\\]."]
|
||||
pub type EVENTS_RECEIVE_R = crate::BitReader<EVENTS_RECEIVE_A>;
|
||||
#[doc = "Event received on one or more of the enabled channels in RECEIVE_CNF\\[n\\].\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum EVENTS_RECEIVE_A {
|
||||
#[doc = "0: Event not generated"]
|
||||
NOT_GENERATED = 0,
|
||||
#[doc = "1: Event generated"]
|
||||
GENERATED = 1,
|
||||
}
|
||||
impl From<EVENTS_RECEIVE_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: EVENTS_RECEIVE_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl EVENTS_RECEIVE_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> EVENTS_RECEIVE_A {
|
||||
match self.bits {
|
||||
false => EVENTS_RECEIVE_A::NOT_GENERATED,
|
||||
true => EVENTS_RECEIVE_A::GENERATED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `NOT_GENERATED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_not_generated(&self) -> bool {
|
||||
*self == EVENTS_RECEIVE_A::NOT_GENERATED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `GENERATED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_generated(&self) -> bool {
|
||||
*self == EVENTS_RECEIVE_A::GENERATED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `EVENTS_RECEIVE` writer - Event received on one or more of the enabled channels in RECEIVE_CNF\\[n\\]."]
|
||||
pub type EVENTS_RECEIVE_W<'a, const O: u8> =
|
||||
crate::BitWriter<'a, u32, EVENTS_RECEIVE_SPEC, EVENTS_RECEIVE_A, O>;
|
||||
impl<'a, const O: u8> EVENTS_RECEIVE_W<'a, O> {
|
||||
#[doc = "Event not generated"]
|
||||
#[inline(always)]
|
||||
pub fn not_generated(self) -> &'a mut W {
|
||||
self.variant(EVENTS_RECEIVE_A::NOT_GENERATED)
|
||||
}
|
||||
#[doc = "Event generated"]
|
||||
#[inline(always)]
|
||||
pub fn generated(self) -> &'a mut W {
|
||||
self.variant(EVENTS_RECEIVE_A::GENERATED)
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bit 0 - Event received on one or more of the enabled channels in RECEIVE_CNF\\[n\\]."]
|
||||
#[inline(always)]
|
||||
pub fn events_receive(&self) -> EVENTS_RECEIVE_R {
|
||||
EVENTS_RECEIVE_R::new((self.bits & 1) != 0)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 0 - Event received on one or more of the enabled channels in RECEIVE_CNF\\[n\\]."]
|
||||
#[inline(always)]
|
||||
pub fn events_receive(&mut self) -> EVENTS_RECEIVE_W<0> {
|
||||
EVENTS_RECEIVE_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 = "Description collection: Event received on one or more of the enabled channels in RECEIVE_CNF\\[n\\].\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_receive](index.html) module"]
|
||||
pub struct EVENTS_RECEIVE_SPEC;
|
||||
impl crate::RegisterSpec for EVENTS_RECEIVE_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [events_receive::R](R) reader structure"]
|
||||
impl crate::Readable for EVENTS_RECEIVE_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [events_receive::W](W) writer structure"]
|
||||
impl crate::Writable for EVENTS_RECEIVE_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets EVENTS_RECEIVE[%s]
|
||||
to value 0"]
|
||||
impl crate::Resettable for EVENTS_RECEIVE_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
+81
@@ -0,0 +1,81 @@
|
||||
#[doc = "Register `GPMEM[%s]` reader"]
|
||||
pub struct R(crate::R<GPMEM_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<GPMEM_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<GPMEM_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<GPMEM_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `GPMEM[%s]` writer"]
|
||||
pub struct W(crate::W<GPMEM_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<GPMEM_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<GPMEM_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<GPMEM_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `GPMEM` reader - General purpose memory"]
|
||||
pub type GPMEM_R = crate::FieldReader<u32, u32>;
|
||||
#[doc = "Field `GPMEM` writer - General purpose memory"]
|
||||
pub type GPMEM_W<'a, const O: u8> = crate::FieldWriter<'a, u32, GPMEM_SPEC, u32, u32, 32, O>;
|
||||
impl R {
|
||||
#[doc = "Bits 0:31 - General purpose memory"]
|
||||
#[inline(always)]
|
||||
pub fn gpmem(&self) -> GPMEM_R {
|
||||
GPMEM_R::new(self.bits)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 0:31 - General purpose memory"]
|
||||
#[inline(always)]
|
||||
pub fn gpmem(&mut self) -> GPMEM_W<0> {
|
||||
GPMEM_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 = "Description collection: General purpose memory.\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 [gpmem](index.html) module"]
|
||||
pub struct GPMEM_SPEC;
|
||||
impl crate::RegisterSpec for GPMEM_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [gpmem::R](R) reader structure"]
|
||||
impl crate::Readable for GPMEM_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [gpmem::W](W) writer structure"]
|
||||
impl crate::Writable for GPMEM_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets GPMEM[%s]
|
||||
to value 0"]
|
||||
impl crate::Resettable for GPMEM_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
+546
@@ -0,0 +1,546 @@
|
||||
#[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 `RECEIVE0` reader - Enable or disable interrupt for event RECEIVE\\[0\\]"]
|
||||
pub type RECEIVE0_R = crate::BitReader<RECEIVE0_A>;
|
||||
#[doc = "Enable or disable interrupt for event RECEIVE\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE0_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Enable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RECEIVE0_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE0_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RECEIVE0_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RECEIVE0_A {
|
||||
match self.bits {
|
||||
false => RECEIVE0_A::DISABLED,
|
||||
true => RECEIVE0_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RECEIVE0_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RECEIVE0_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE0` writer - Enable or disable interrupt for event RECEIVE\\[0\\]"]
|
||||
pub type RECEIVE0_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, RECEIVE0_A, O>;
|
||||
impl<'a, const O: u8> RECEIVE0_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(RECEIVE0_A::DISABLED)
|
||||
}
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(RECEIVE0_A::ENABLED)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE1` reader - Enable or disable interrupt for event RECEIVE\\[1\\]"]
|
||||
pub type RECEIVE1_R = crate::BitReader<RECEIVE1_A>;
|
||||
#[doc = "Enable or disable interrupt for event RECEIVE\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE1_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Enable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RECEIVE1_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE1_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RECEIVE1_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RECEIVE1_A {
|
||||
match self.bits {
|
||||
false => RECEIVE1_A::DISABLED,
|
||||
true => RECEIVE1_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RECEIVE1_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RECEIVE1_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE1` writer - Enable or disable interrupt for event RECEIVE\\[1\\]"]
|
||||
pub type RECEIVE1_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, RECEIVE1_A, O>;
|
||||
impl<'a, const O: u8> RECEIVE1_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(RECEIVE1_A::DISABLED)
|
||||
}
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(RECEIVE1_A::ENABLED)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE2` reader - Enable or disable interrupt for event RECEIVE\\[2\\]"]
|
||||
pub type RECEIVE2_R = crate::BitReader<RECEIVE2_A>;
|
||||
#[doc = "Enable or disable interrupt for event RECEIVE\\[2\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE2_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Enable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RECEIVE2_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE2_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RECEIVE2_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RECEIVE2_A {
|
||||
match self.bits {
|
||||
false => RECEIVE2_A::DISABLED,
|
||||
true => RECEIVE2_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RECEIVE2_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RECEIVE2_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE2` writer - Enable or disable interrupt for event RECEIVE\\[2\\]"]
|
||||
pub type RECEIVE2_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, RECEIVE2_A, O>;
|
||||
impl<'a, const O: u8> RECEIVE2_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(RECEIVE2_A::DISABLED)
|
||||
}
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(RECEIVE2_A::ENABLED)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE3` reader - Enable or disable interrupt for event RECEIVE\\[3\\]"]
|
||||
pub type RECEIVE3_R = crate::BitReader<RECEIVE3_A>;
|
||||
#[doc = "Enable or disable interrupt for event RECEIVE\\[3\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE3_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Enable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RECEIVE3_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE3_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RECEIVE3_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RECEIVE3_A {
|
||||
match self.bits {
|
||||
false => RECEIVE3_A::DISABLED,
|
||||
true => RECEIVE3_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RECEIVE3_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RECEIVE3_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE3` writer - Enable or disable interrupt for event RECEIVE\\[3\\]"]
|
||||
pub type RECEIVE3_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, RECEIVE3_A, O>;
|
||||
impl<'a, const O: u8> RECEIVE3_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(RECEIVE3_A::DISABLED)
|
||||
}
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(RECEIVE3_A::ENABLED)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE4` reader - Enable or disable interrupt for event RECEIVE\\[4\\]"]
|
||||
pub type RECEIVE4_R = crate::BitReader<RECEIVE4_A>;
|
||||
#[doc = "Enable or disable interrupt for event RECEIVE\\[4\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE4_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Enable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RECEIVE4_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE4_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RECEIVE4_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RECEIVE4_A {
|
||||
match self.bits {
|
||||
false => RECEIVE4_A::DISABLED,
|
||||
true => RECEIVE4_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RECEIVE4_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RECEIVE4_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE4` writer - Enable or disable interrupt for event RECEIVE\\[4\\]"]
|
||||
pub type RECEIVE4_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, RECEIVE4_A, O>;
|
||||
impl<'a, const O: u8> RECEIVE4_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(RECEIVE4_A::DISABLED)
|
||||
}
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(RECEIVE4_A::ENABLED)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE5` reader - Enable or disable interrupt for event RECEIVE\\[5\\]"]
|
||||
pub type RECEIVE5_R = crate::BitReader<RECEIVE5_A>;
|
||||
#[doc = "Enable or disable interrupt for event RECEIVE\\[5\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE5_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Enable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RECEIVE5_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE5_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RECEIVE5_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RECEIVE5_A {
|
||||
match self.bits {
|
||||
false => RECEIVE5_A::DISABLED,
|
||||
true => RECEIVE5_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RECEIVE5_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RECEIVE5_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE5` writer - Enable or disable interrupt for event RECEIVE\\[5\\]"]
|
||||
pub type RECEIVE5_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, RECEIVE5_A, O>;
|
||||
impl<'a, const O: u8> RECEIVE5_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(RECEIVE5_A::DISABLED)
|
||||
}
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(RECEIVE5_A::ENABLED)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE6` reader - Enable or disable interrupt for event RECEIVE\\[6\\]"]
|
||||
pub type RECEIVE6_R = crate::BitReader<RECEIVE6_A>;
|
||||
#[doc = "Enable or disable interrupt for event RECEIVE\\[6\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE6_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Enable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RECEIVE6_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE6_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RECEIVE6_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RECEIVE6_A {
|
||||
match self.bits {
|
||||
false => RECEIVE6_A::DISABLED,
|
||||
true => RECEIVE6_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RECEIVE6_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RECEIVE6_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE6` writer - Enable or disable interrupt for event RECEIVE\\[6\\]"]
|
||||
pub type RECEIVE6_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, RECEIVE6_A, O>;
|
||||
impl<'a, const O: u8> RECEIVE6_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(RECEIVE6_A::DISABLED)
|
||||
}
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(RECEIVE6_A::ENABLED)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE7` reader - Enable or disable interrupt for event RECEIVE\\[7\\]"]
|
||||
pub type RECEIVE7_R = crate::BitReader<RECEIVE7_A>;
|
||||
#[doc = "Enable or disable interrupt for event RECEIVE\\[7\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE7_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Enable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RECEIVE7_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE7_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RECEIVE7_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RECEIVE7_A {
|
||||
match self.bits {
|
||||
false => RECEIVE7_A::DISABLED,
|
||||
true => RECEIVE7_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RECEIVE7_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RECEIVE7_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE7` writer - Enable or disable interrupt for event RECEIVE\\[7\\]"]
|
||||
pub type RECEIVE7_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, RECEIVE7_A, O>;
|
||||
impl<'a, const O: u8> RECEIVE7_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(RECEIVE7_A::DISABLED)
|
||||
}
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(RECEIVE7_A::ENABLED)
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bit 0 - Enable or disable interrupt for event RECEIVE\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive0(&self) -> RECEIVE0_R {
|
||||
RECEIVE0_R::new((self.bits & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 1 - Enable or disable interrupt for event RECEIVE\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive1(&self) -> RECEIVE1_R {
|
||||
RECEIVE1_R::new(((self.bits >> 1) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 2 - Enable or disable interrupt for event RECEIVE\\[2\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive2(&self) -> RECEIVE2_R {
|
||||
RECEIVE2_R::new(((self.bits >> 2) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 3 - Enable or disable interrupt for event RECEIVE\\[3\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive3(&self) -> RECEIVE3_R {
|
||||
RECEIVE3_R::new(((self.bits >> 3) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 4 - Enable or disable interrupt for event RECEIVE\\[4\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive4(&self) -> RECEIVE4_R {
|
||||
RECEIVE4_R::new(((self.bits >> 4) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 5 - Enable or disable interrupt for event RECEIVE\\[5\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive5(&self) -> RECEIVE5_R {
|
||||
RECEIVE5_R::new(((self.bits >> 5) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 6 - Enable or disable interrupt for event RECEIVE\\[6\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive6(&self) -> RECEIVE6_R {
|
||||
RECEIVE6_R::new(((self.bits >> 6) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 7 - Enable or disable interrupt for event RECEIVE\\[7\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive7(&self) -> RECEIVE7_R {
|
||||
RECEIVE7_R::new(((self.bits >> 7) & 1) != 0)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 0 - Enable or disable interrupt for event RECEIVE\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive0(&mut self) -> RECEIVE0_W<0> {
|
||||
RECEIVE0_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 1 - Enable or disable interrupt for event RECEIVE\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive1(&mut self) -> RECEIVE1_W<1> {
|
||||
RECEIVE1_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 2 - Enable or disable interrupt for event RECEIVE\\[2\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive2(&mut self) -> RECEIVE2_W<2> {
|
||||
RECEIVE2_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 3 - Enable or disable interrupt for event RECEIVE\\[3\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive3(&mut self) -> RECEIVE3_W<3> {
|
||||
RECEIVE3_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 4 - Enable or disable interrupt for event RECEIVE\\[4\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive4(&mut self) -> RECEIVE4_W<4> {
|
||||
RECEIVE4_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 5 - Enable or disable interrupt for event RECEIVE\\[5\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive5(&mut self) -> RECEIVE5_W<5> {
|
||||
RECEIVE5_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 6 - Enable or disable interrupt for event RECEIVE\\[6\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive6(&mut self) -> RECEIVE6_W<6> {
|
||||
RECEIVE6_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 7 - Enable or disable interrupt for event RECEIVE\\[7\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive7(&mut self) -> RECEIVE7_W<7> {
|
||||
RECEIVE7_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
|
||||
}
|
||||
}
|
||||
+602
@@ -0,0 +1,602 @@
|
||||
#[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 `RECEIVE0` reader - Write '1' to disable interrupt for event RECEIVE\\[0\\]"]
|
||||
pub type RECEIVE0_R = crate::BitReader<RECEIVE0_A>;
|
||||
#[doc = "Write '1' to disable interrupt for event RECEIVE\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE0_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RECEIVE0_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE0_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RECEIVE0_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RECEIVE0_A {
|
||||
match self.bits {
|
||||
false => RECEIVE0_A::DISABLED,
|
||||
true => RECEIVE0_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RECEIVE0_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RECEIVE0_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable interrupt for event RECEIVE\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE0_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<RECEIVE0_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE0_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE0` writer - Write '1' to disable interrupt for event RECEIVE\\[0\\]"]
|
||||
pub type RECEIVE0_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, RECEIVE0_AW, O>;
|
||||
impl<'a, const O: u8> RECEIVE0_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(RECEIVE0_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE1` reader - Write '1' to disable interrupt for event RECEIVE\\[1\\]"]
|
||||
pub type RECEIVE1_R = crate::BitReader<RECEIVE1_A>;
|
||||
#[doc = "Write '1' to disable interrupt for event RECEIVE\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE1_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RECEIVE1_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE1_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RECEIVE1_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RECEIVE1_A {
|
||||
match self.bits {
|
||||
false => RECEIVE1_A::DISABLED,
|
||||
true => RECEIVE1_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RECEIVE1_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RECEIVE1_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable interrupt for event RECEIVE\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE1_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<RECEIVE1_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE1_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE1` writer - Write '1' to disable interrupt for event RECEIVE\\[1\\]"]
|
||||
pub type RECEIVE1_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, RECEIVE1_AW, O>;
|
||||
impl<'a, const O: u8> RECEIVE1_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(RECEIVE1_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE2` reader - Write '1' to disable interrupt for event RECEIVE\\[2\\]"]
|
||||
pub type RECEIVE2_R = crate::BitReader<RECEIVE2_A>;
|
||||
#[doc = "Write '1' to disable interrupt for event RECEIVE\\[2\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE2_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RECEIVE2_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE2_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RECEIVE2_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RECEIVE2_A {
|
||||
match self.bits {
|
||||
false => RECEIVE2_A::DISABLED,
|
||||
true => RECEIVE2_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RECEIVE2_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RECEIVE2_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable interrupt for event RECEIVE\\[2\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE2_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<RECEIVE2_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE2_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE2` writer - Write '1' to disable interrupt for event RECEIVE\\[2\\]"]
|
||||
pub type RECEIVE2_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, RECEIVE2_AW, O>;
|
||||
impl<'a, const O: u8> RECEIVE2_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(RECEIVE2_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE3` reader - Write '1' to disable interrupt for event RECEIVE\\[3\\]"]
|
||||
pub type RECEIVE3_R = crate::BitReader<RECEIVE3_A>;
|
||||
#[doc = "Write '1' to disable interrupt for event RECEIVE\\[3\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE3_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RECEIVE3_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE3_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RECEIVE3_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RECEIVE3_A {
|
||||
match self.bits {
|
||||
false => RECEIVE3_A::DISABLED,
|
||||
true => RECEIVE3_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RECEIVE3_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RECEIVE3_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable interrupt for event RECEIVE\\[3\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE3_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<RECEIVE3_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE3_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE3` writer - Write '1' to disable interrupt for event RECEIVE\\[3\\]"]
|
||||
pub type RECEIVE3_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, RECEIVE3_AW, O>;
|
||||
impl<'a, const O: u8> RECEIVE3_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(RECEIVE3_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE4` reader - Write '1' to disable interrupt for event RECEIVE\\[4\\]"]
|
||||
pub type RECEIVE4_R = crate::BitReader<RECEIVE4_A>;
|
||||
#[doc = "Write '1' to disable interrupt for event RECEIVE\\[4\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE4_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RECEIVE4_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE4_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RECEIVE4_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RECEIVE4_A {
|
||||
match self.bits {
|
||||
false => RECEIVE4_A::DISABLED,
|
||||
true => RECEIVE4_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RECEIVE4_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RECEIVE4_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable interrupt for event RECEIVE\\[4\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE4_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<RECEIVE4_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE4_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE4` writer - Write '1' to disable interrupt for event RECEIVE\\[4\\]"]
|
||||
pub type RECEIVE4_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, RECEIVE4_AW, O>;
|
||||
impl<'a, const O: u8> RECEIVE4_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(RECEIVE4_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE5` reader - Write '1' to disable interrupt for event RECEIVE\\[5\\]"]
|
||||
pub type RECEIVE5_R = crate::BitReader<RECEIVE5_A>;
|
||||
#[doc = "Write '1' to disable interrupt for event RECEIVE\\[5\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE5_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RECEIVE5_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE5_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RECEIVE5_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RECEIVE5_A {
|
||||
match self.bits {
|
||||
false => RECEIVE5_A::DISABLED,
|
||||
true => RECEIVE5_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RECEIVE5_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RECEIVE5_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable interrupt for event RECEIVE\\[5\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE5_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<RECEIVE5_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE5_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE5` writer - Write '1' to disable interrupt for event RECEIVE\\[5\\]"]
|
||||
pub type RECEIVE5_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, RECEIVE5_AW, O>;
|
||||
impl<'a, const O: u8> RECEIVE5_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(RECEIVE5_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE6` reader - Write '1' to disable interrupt for event RECEIVE\\[6\\]"]
|
||||
pub type RECEIVE6_R = crate::BitReader<RECEIVE6_A>;
|
||||
#[doc = "Write '1' to disable interrupt for event RECEIVE\\[6\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE6_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RECEIVE6_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE6_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RECEIVE6_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RECEIVE6_A {
|
||||
match self.bits {
|
||||
false => RECEIVE6_A::DISABLED,
|
||||
true => RECEIVE6_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RECEIVE6_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RECEIVE6_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable interrupt for event RECEIVE\\[6\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE6_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<RECEIVE6_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE6_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE6` writer - Write '1' to disable interrupt for event RECEIVE\\[6\\]"]
|
||||
pub type RECEIVE6_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, RECEIVE6_AW, O>;
|
||||
impl<'a, const O: u8> RECEIVE6_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(RECEIVE6_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE7` reader - Write '1' to disable interrupt for event RECEIVE\\[7\\]"]
|
||||
pub type RECEIVE7_R = crate::BitReader<RECEIVE7_A>;
|
||||
#[doc = "Write '1' to disable interrupt for event RECEIVE\\[7\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE7_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RECEIVE7_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE7_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RECEIVE7_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RECEIVE7_A {
|
||||
match self.bits {
|
||||
false => RECEIVE7_A::DISABLED,
|
||||
true => RECEIVE7_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RECEIVE7_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RECEIVE7_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable interrupt for event RECEIVE\\[7\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE7_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<RECEIVE7_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE7_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE7` writer - Write '1' to disable interrupt for event RECEIVE\\[7\\]"]
|
||||
pub type RECEIVE7_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, RECEIVE7_AW, O>;
|
||||
impl<'a, const O: u8> RECEIVE7_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(RECEIVE7_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bit 0 - Write '1' to disable interrupt for event RECEIVE\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive0(&self) -> RECEIVE0_R {
|
||||
RECEIVE0_R::new((self.bits & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 1 - Write '1' to disable interrupt for event RECEIVE\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive1(&self) -> RECEIVE1_R {
|
||||
RECEIVE1_R::new(((self.bits >> 1) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 2 - Write '1' to disable interrupt for event RECEIVE\\[2\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive2(&self) -> RECEIVE2_R {
|
||||
RECEIVE2_R::new(((self.bits >> 2) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 3 - Write '1' to disable interrupt for event RECEIVE\\[3\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive3(&self) -> RECEIVE3_R {
|
||||
RECEIVE3_R::new(((self.bits >> 3) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 4 - Write '1' to disable interrupt for event RECEIVE\\[4\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive4(&self) -> RECEIVE4_R {
|
||||
RECEIVE4_R::new(((self.bits >> 4) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 5 - Write '1' to disable interrupt for event RECEIVE\\[5\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive5(&self) -> RECEIVE5_R {
|
||||
RECEIVE5_R::new(((self.bits >> 5) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 6 - Write '1' to disable interrupt for event RECEIVE\\[6\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive6(&self) -> RECEIVE6_R {
|
||||
RECEIVE6_R::new(((self.bits >> 6) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 7 - Write '1' to disable interrupt for event RECEIVE\\[7\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive7(&self) -> RECEIVE7_R {
|
||||
RECEIVE7_R::new(((self.bits >> 7) & 1) != 0)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 0 - Write '1' to disable interrupt for event RECEIVE\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive0(&mut self) -> RECEIVE0_W<0> {
|
||||
RECEIVE0_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 1 - Write '1' to disable interrupt for event RECEIVE\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive1(&mut self) -> RECEIVE1_W<1> {
|
||||
RECEIVE1_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 2 - Write '1' to disable interrupt for event RECEIVE\\[2\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive2(&mut self) -> RECEIVE2_W<2> {
|
||||
RECEIVE2_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 3 - Write '1' to disable interrupt for event RECEIVE\\[3\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive3(&mut self) -> RECEIVE3_W<3> {
|
||||
RECEIVE3_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 4 - Write '1' to disable interrupt for event RECEIVE\\[4\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive4(&mut self) -> RECEIVE4_W<4> {
|
||||
RECEIVE4_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 5 - Write '1' to disable interrupt for event RECEIVE\\[5\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive5(&mut self) -> RECEIVE5_W<5> {
|
||||
RECEIVE5_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 6 - Write '1' to disable interrupt for event RECEIVE\\[6\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive6(&mut self) -> RECEIVE6_W<6> {
|
||||
RECEIVE6_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 7 - Write '1' to disable interrupt for event RECEIVE\\[7\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive7(&mut self) -> RECEIVE7_W<7> {
|
||||
RECEIVE7_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
|
||||
}
|
||||
}
|
||||
+602
@@ -0,0 +1,602 @@
|
||||
#[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 `RECEIVE0` reader - Write '1' to enable interrupt for event RECEIVE\\[0\\]"]
|
||||
pub type RECEIVE0_R = crate::BitReader<RECEIVE0_A>;
|
||||
#[doc = "Write '1' to enable interrupt for event RECEIVE\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE0_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RECEIVE0_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE0_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RECEIVE0_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RECEIVE0_A {
|
||||
match self.bits {
|
||||
false => RECEIVE0_A::DISABLED,
|
||||
true => RECEIVE0_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RECEIVE0_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RECEIVE0_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable interrupt for event RECEIVE\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE0_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<RECEIVE0_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE0_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE0` writer - Write '1' to enable interrupt for event RECEIVE\\[0\\]"]
|
||||
pub type RECEIVE0_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, RECEIVE0_AW, O>;
|
||||
impl<'a, const O: u8> RECEIVE0_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(RECEIVE0_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE1` reader - Write '1' to enable interrupt for event RECEIVE\\[1\\]"]
|
||||
pub type RECEIVE1_R = crate::BitReader<RECEIVE1_A>;
|
||||
#[doc = "Write '1' to enable interrupt for event RECEIVE\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE1_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RECEIVE1_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE1_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RECEIVE1_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RECEIVE1_A {
|
||||
match self.bits {
|
||||
false => RECEIVE1_A::DISABLED,
|
||||
true => RECEIVE1_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RECEIVE1_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RECEIVE1_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable interrupt for event RECEIVE\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE1_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<RECEIVE1_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE1_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE1` writer - Write '1' to enable interrupt for event RECEIVE\\[1\\]"]
|
||||
pub type RECEIVE1_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, RECEIVE1_AW, O>;
|
||||
impl<'a, const O: u8> RECEIVE1_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(RECEIVE1_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE2` reader - Write '1' to enable interrupt for event RECEIVE\\[2\\]"]
|
||||
pub type RECEIVE2_R = crate::BitReader<RECEIVE2_A>;
|
||||
#[doc = "Write '1' to enable interrupt for event RECEIVE\\[2\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE2_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RECEIVE2_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE2_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RECEIVE2_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RECEIVE2_A {
|
||||
match self.bits {
|
||||
false => RECEIVE2_A::DISABLED,
|
||||
true => RECEIVE2_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RECEIVE2_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RECEIVE2_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable interrupt for event RECEIVE\\[2\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE2_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<RECEIVE2_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE2_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE2` writer - Write '1' to enable interrupt for event RECEIVE\\[2\\]"]
|
||||
pub type RECEIVE2_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, RECEIVE2_AW, O>;
|
||||
impl<'a, const O: u8> RECEIVE2_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(RECEIVE2_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE3` reader - Write '1' to enable interrupt for event RECEIVE\\[3\\]"]
|
||||
pub type RECEIVE3_R = crate::BitReader<RECEIVE3_A>;
|
||||
#[doc = "Write '1' to enable interrupt for event RECEIVE\\[3\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE3_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RECEIVE3_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE3_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RECEIVE3_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RECEIVE3_A {
|
||||
match self.bits {
|
||||
false => RECEIVE3_A::DISABLED,
|
||||
true => RECEIVE3_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RECEIVE3_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RECEIVE3_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable interrupt for event RECEIVE\\[3\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE3_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<RECEIVE3_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE3_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE3` writer - Write '1' to enable interrupt for event RECEIVE\\[3\\]"]
|
||||
pub type RECEIVE3_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, RECEIVE3_AW, O>;
|
||||
impl<'a, const O: u8> RECEIVE3_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(RECEIVE3_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE4` reader - Write '1' to enable interrupt for event RECEIVE\\[4\\]"]
|
||||
pub type RECEIVE4_R = crate::BitReader<RECEIVE4_A>;
|
||||
#[doc = "Write '1' to enable interrupt for event RECEIVE\\[4\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE4_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RECEIVE4_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE4_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RECEIVE4_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RECEIVE4_A {
|
||||
match self.bits {
|
||||
false => RECEIVE4_A::DISABLED,
|
||||
true => RECEIVE4_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RECEIVE4_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RECEIVE4_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable interrupt for event RECEIVE\\[4\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE4_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<RECEIVE4_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE4_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE4` writer - Write '1' to enable interrupt for event RECEIVE\\[4\\]"]
|
||||
pub type RECEIVE4_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, RECEIVE4_AW, O>;
|
||||
impl<'a, const O: u8> RECEIVE4_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(RECEIVE4_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE5` reader - Write '1' to enable interrupt for event RECEIVE\\[5\\]"]
|
||||
pub type RECEIVE5_R = crate::BitReader<RECEIVE5_A>;
|
||||
#[doc = "Write '1' to enable interrupt for event RECEIVE\\[5\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE5_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RECEIVE5_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE5_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RECEIVE5_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RECEIVE5_A {
|
||||
match self.bits {
|
||||
false => RECEIVE5_A::DISABLED,
|
||||
true => RECEIVE5_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RECEIVE5_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RECEIVE5_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable interrupt for event RECEIVE\\[5\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE5_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<RECEIVE5_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE5_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE5` writer - Write '1' to enable interrupt for event RECEIVE\\[5\\]"]
|
||||
pub type RECEIVE5_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, RECEIVE5_AW, O>;
|
||||
impl<'a, const O: u8> RECEIVE5_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(RECEIVE5_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE6` reader - Write '1' to enable interrupt for event RECEIVE\\[6\\]"]
|
||||
pub type RECEIVE6_R = crate::BitReader<RECEIVE6_A>;
|
||||
#[doc = "Write '1' to enable interrupt for event RECEIVE\\[6\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE6_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RECEIVE6_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE6_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RECEIVE6_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RECEIVE6_A {
|
||||
match self.bits {
|
||||
false => RECEIVE6_A::DISABLED,
|
||||
true => RECEIVE6_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RECEIVE6_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RECEIVE6_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable interrupt for event RECEIVE\\[6\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE6_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<RECEIVE6_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE6_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE6` writer - Write '1' to enable interrupt for event RECEIVE\\[6\\]"]
|
||||
pub type RECEIVE6_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, RECEIVE6_AW, O>;
|
||||
impl<'a, const O: u8> RECEIVE6_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(RECEIVE6_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE7` reader - Write '1' to enable interrupt for event RECEIVE\\[7\\]"]
|
||||
pub type RECEIVE7_R = crate::BitReader<RECEIVE7_A>;
|
||||
#[doc = "Write '1' to enable interrupt for event RECEIVE\\[7\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE7_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<RECEIVE7_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE7_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RECEIVE7_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RECEIVE7_A {
|
||||
match self.bits {
|
||||
false => RECEIVE7_A::DISABLED,
|
||||
true => RECEIVE7_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == RECEIVE7_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == RECEIVE7_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable interrupt for event RECEIVE\\[7\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE7_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<RECEIVE7_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE7_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE7` writer - Write '1' to enable interrupt for event RECEIVE\\[7\\]"]
|
||||
pub type RECEIVE7_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, RECEIVE7_AW, O>;
|
||||
impl<'a, const O: u8> RECEIVE7_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(RECEIVE7_AW::SET)
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bit 0 - Write '1' to enable interrupt for event RECEIVE\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive0(&self) -> RECEIVE0_R {
|
||||
RECEIVE0_R::new((self.bits & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 1 - Write '1' to enable interrupt for event RECEIVE\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive1(&self) -> RECEIVE1_R {
|
||||
RECEIVE1_R::new(((self.bits >> 1) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 2 - Write '1' to enable interrupt for event RECEIVE\\[2\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive2(&self) -> RECEIVE2_R {
|
||||
RECEIVE2_R::new(((self.bits >> 2) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 3 - Write '1' to enable interrupt for event RECEIVE\\[3\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive3(&self) -> RECEIVE3_R {
|
||||
RECEIVE3_R::new(((self.bits >> 3) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 4 - Write '1' to enable interrupt for event RECEIVE\\[4\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive4(&self) -> RECEIVE4_R {
|
||||
RECEIVE4_R::new(((self.bits >> 4) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 5 - Write '1' to enable interrupt for event RECEIVE\\[5\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive5(&self) -> RECEIVE5_R {
|
||||
RECEIVE5_R::new(((self.bits >> 5) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 6 - Write '1' to enable interrupt for event RECEIVE\\[6\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive6(&self) -> RECEIVE6_R {
|
||||
RECEIVE6_R::new(((self.bits >> 6) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 7 - Write '1' to enable interrupt for event RECEIVE\\[7\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive7(&self) -> RECEIVE7_R {
|
||||
RECEIVE7_R::new(((self.bits >> 7) & 1) != 0)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 0 - Write '1' to enable interrupt for event RECEIVE\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive0(&mut self) -> RECEIVE0_W<0> {
|
||||
RECEIVE0_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 1 - Write '1' to enable interrupt for event RECEIVE\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive1(&mut self) -> RECEIVE1_W<1> {
|
||||
RECEIVE1_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 2 - Write '1' to enable interrupt for event RECEIVE\\[2\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive2(&mut self) -> RECEIVE2_W<2> {
|
||||
RECEIVE2_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 3 - Write '1' to enable interrupt for event RECEIVE\\[3\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive3(&mut self) -> RECEIVE3_W<3> {
|
||||
RECEIVE3_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 4 - Write '1' to enable interrupt for event RECEIVE\\[4\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive4(&mut self) -> RECEIVE4_W<4> {
|
||||
RECEIVE4_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 5 - Write '1' to enable interrupt for event RECEIVE\\[5\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive5(&mut self) -> RECEIVE5_W<5> {
|
||||
RECEIVE5_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 6 - Write '1' to enable interrupt for event RECEIVE\\[6\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive6(&mut self) -> RECEIVE6_W<6> {
|
||||
RECEIVE6_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 7 - Write '1' to enable interrupt for event RECEIVE\\[7\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive7(&mut self) -> RECEIVE7_W<7> {
|
||||
RECEIVE7_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
|
||||
}
|
||||
}
|
||||
+361
@@ -0,0 +1,361 @@
|
||||
#[doc = "Register `INTPEND` reader"]
|
||||
pub struct R(crate::R<INTPEND_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<INTPEND_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<INTPEND_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<INTPEND_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE0` reader - Read pending status of interrupt for event RECEIVE\\[0\\]"]
|
||||
pub type RECEIVE0_R = crate::BitReader<RECEIVE0_A>;
|
||||
#[doc = "Read pending status of interrupt for event RECEIVE\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE0_A {
|
||||
#[doc = "0: Read: Not pending"]
|
||||
NOT_PENDING = 0,
|
||||
#[doc = "1: Read: Pending"]
|
||||
PENDING = 1,
|
||||
}
|
||||
impl From<RECEIVE0_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE0_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RECEIVE0_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RECEIVE0_A {
|
||||
match self.bits {
|
||||
false => RECEIVE0_A::NOT_PENDING,
|
||||
true => RECEIVE0_A::PENDING,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `NOT_PENDING`"]
|
||||
#[inline(always)]
|
||||
pub fn is_not_pending(&self) -> bool {
|
||||
*self == RECEIVE0_A::NOT_PENDING
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `PENDING`"]
|
||||
#[inline(always)]
|
||||
pub fn is_pending(&self) -> bool {
|
||||
*self == RECEIVE0_A::PENDING
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE1` reader - Read pending status of interrupt for event RECEIVE\\[1\\]"]
|
||||
pub type RECEIVE1_R = crate::BitReader<RECEIVE1_A>;
|
||||
#[doc = "Read pending status of interrupt for event RECEIVE\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE1_A {
|
||||
#[doc = "0: Read: Not pending"]
|
||||
NOT_PENDING = 0,
|
||||
#[doc = "1: Read: Pending"]
|
||||
PENDING = 1,
|
||||
}
|
||||
impl From<RECEIVE1_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE1_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RECEIVE1_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RECEIVE1_A {
|
||||
match self.bits {
|
||||
false => RECEIVE1_A::NOT_PENDING,
|
||||
true => RECEIVE1_A::PENDING,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `NOT_PENDING`"]
|
||||
#[inline(always)]
|
||||
pub fn is_not_pending(&self) -> bool {
|
||||
*self == RECEIVE1_A::NOT_PENDING
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `PENDING`"]
|
||||
#[inline(always)]
|
||||
pub fn is_pending(&self) -> bool {
|
||||
*self == RECEIVE1_A::PENDING
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE2` reader - Read pending status of interrupt for event RECEIVE\\[2\\]"]
|
||||
pub type RECEIVE2_R = crate::BitReader<RECEIVE2_A>;
|
||||
#[doc = "Read pending status of interrupt for event RECEIVE\\[2\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE2_A {
|
||||
#[doc = "0: Read: Not pending"]
|
||||
NOT_PENDING = 0,
|
||||
#[doc = "1: Read: Pending"]
|
||||
PENDING = 1,
|
||||
}
|
||||
impl From<RECEIVE2_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE2_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RECEIVE2_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RECEIVE2_A {
|
||||
match self.bits {
|
||||
false => RECEIVE2_A::NOT_PENDING,
|
||||
true => RECEIVE2_A::PENDING,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `NOT_PENDING`"]
|
||||
#[inline(always)]
|
||||
pub fn is_not_pending(&self) -> bool {
|
||||
*self == RECEIVE2_A::NOT_PENDING
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `PENDING`"]
|
||||
#[inline(always)]
|
||||
pub fn is_pending(&self) -> bool {
|
||||
*self == RECEIVE2_A::PENDING
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE3` reader - Read pending status of interrupt for event RECEIVE\\[3\\]"]
|
||||
pub type RECEIVE3_R = crate::BitReader<RECEIVE3_A>;
|
||||
#[doc = "Read pending status of interrupt for event RECEIVE\\[3\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE3_A {
|
||||
#[doc = "0: Read: Not pending"]
|
||||
NOT_PENDING = 0,
|
||||
#[doc = "1: Read: Pending"]
|
||||
PENDING = 1,
|
||||
}
|
||||
impl From<RECEIVE3_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE3_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RECEIVE3_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RECEIVE3_A {
|
||||
match self.bits {
|
||||
false => RECEIVE3_A::NOT_PENDING,
|
||||
true => RECEIVE3_A::PENDING,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `NOT_PENDING`"]
|
||||
#[inline(always)]
|
||||
pub fn is_not_pending(&self) -> bool {
|
||||
*self == RECEIVE3_A::NOT_PENDING
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `PENDING`"]
|
||||
#[inline(always)]
|
||||
pub fn is_pending(&self) -> bool {
|
||||
*self == RECEIVE3_A::PENDING
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE4` reader - Read pending status of interrupt for event RECEIVE\\[4\\]"]
|
||||
pub type RECEIVE4_R = crate::BitReader<RECEIVE4_A>;
|
||||
#[doc = "Read pending status of interrupt for event RECEIVE\\[4\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE4_A {
|
||||
#[doc = "0: Read: Not pending"]
|
||||
NOT_PENDING = 0,
|
||||
#[doc = "1: Read: Pending"]
|
||||
PENDING = 1,
|
||||
}
|
||||
impl From<RECEIVE4_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE4_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RECEIVE4_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RECEIVE4_A {
|
||||
match self.bits {
|
||||
false => RECEIVE4_A::NOT_PENDING,
|
||||
true => RECEIVE4_A::PENDING,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `NOT_PENDING`"]
|
||||
#[inline(always)]
|
||||
pub fn is_not_pending(&self) -> bool {
|
||||
*self == RECEIVE4_A::NOT_PENDING
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `PENDING`"]
|
||||
#[inline(always)]
|
||||
pub fn is_pending(&self) -> bool {
|
||||
*self == RECEIVE4_A::PENDING
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE5` reader - Read pending status of interrupt for event RECEIVE\\[5\\]"]
|
||||
pub type RECEIVE5_R = crate::BitReader<RECEIVE5_A>;
|
||||
#[doc = "Read pending status of interrupt for event RECEIVE\\[5\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE5_A {
|
||||
#[doc = "0: Read: Not pending"]
|
||||
NOT_PENDING = 0,
|
||||
#[doc = "1: Read: Pending"]
|
||||
PENDING = 1,
|
||||
}
|
||||
impl From<RECEIVE5_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE5_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RECEIVE5_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RECEIVE5_A {
|
||||
match self.bits {
|
||||
false => RECEIVE5_A::NOT_PENDING,
|
||||
true => RECEIVE5_A::PENDING,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `NOT_PENDING`"]
|
||||
#[inline(always)]
|
||||
pub fn is_not_pending(&self) -> bool {
|
||||
*self == RECEIVE5_A::NOT_PENDING
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `PENDING`"]
|
||||
#[inline(always)]
|
||||
pub fn is_pending(&self) -> bool {
|
||||
*self == RECEIVE5_A::PENDING
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE6` reader - Read pending status of interrupt for event RECEIVE\\[6\\]"]
|
||||
pub type RECEIVE6_R = crate::BitReader<RECEIVE6_A>;
|
||||
#[doc = "Read pending status of interrupt for event RECEIVE\\[6\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE6_A {
|
||||
#[doc = "0: Read: Not pending"]
|
||||
NOT_PENDING = 0,
|
||||
#[doc = "1: Read: Pending"]
|
||||
PENDING = 1,
|
||||
}
|
||||
impl From<RECEIVE6_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE6_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RECEIVE6_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RECEIVE6_A {
|
||||
match self.bits {
|
||||
false => RECEIVE6_A::NOT_PENDING,
|
||||
true => RECEIVE6_A::PENDING,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `NOT_PENDING`"]
|
||||
#[inline(always)]
|
||||
pub fn is_not_pending(&self) -> bool {
|
||||
*self == RECEIVE6_A::NOT_PENDING
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `PENDING`"]
|
||||
#[inline(always)]
|
||||
pub fn is_pending(&self) -> bool {
|
||||
*self == RECEIVE6_A::PENDING
|
||||
}
|
||||
}
|
||||
#[doc = "Field `RECEIVE7` reader - Read pending status of interrupt for event RECEIVE\\[7\\]"]
|
||||
pub type RECEIVE7_R = crate::BitReader<RECEIVE7_A>;
|
||||
#[doc = "Read pending status of interrupt for event RECEIVE\\[7\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum RECEIVE7_A {
|
||||
#[doc = "0: Read: Not pending"]
|
||||
NOT_PENDING = 0,
|
||||
#[doc = "1: Read: Pending"]
|
||||
PENDING = 1,
|
||||
}
|
||||
impl From<RECEIVE7_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: RECEIVE7_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl RECEIVE7_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> RECEIVE7_A {
|
||||
match self.bits {
|
||||
false => RECEIVE7_A::NOT_PENDING,
|
||||
true => RECEIVE7_A::PENDING,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `NOT_PENDING`"]
|
||||
#[inline(always)]
|
||||
pub fn is_not_pending(&self) -> bool {
|
||||
*self == RECEIVE7_A::NOT_PENDING
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `PENDING`"]
|
||||
#[inline(always)]
|
||||
pub fn is_pending(&self) -> bool {
|
||||
*self == RECEIVE7_A::PENDING
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bit 0 - Read pending status of interrupt for event RECEIVE\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive0(&self) -> RECEIVE0_R {
|
||||
RECEIVE0_R::new((self.bits & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 1 - Read pending status of interrupt for event RECEIVE\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive1(&self) -> RECEIVE1_R {
|
||||
RECEIVE1_R::new(((self.bits >> 1) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 2 - Read pending status of interrupt for event RECEIVE\\[2\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive2(&self) -> RECEIVE2_R {
|
||||
RECEIVE2_R::new(((self.bits >> 2) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 3 - Read pending status of interrupt for event RECEIVE\\[3\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive3(&self) -> RECEIVE3_R {
|
||||
RECEIVE3_R::new(((self.bits >> 3) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 4 - Read pending status of interrupt for event RECEIVE\\[4\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive4(&self) -> RECEIVE4_R {
|
||||
RECEIVE4_R::new(((self.bits >> 4) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 5 - Read pending status of interrupt for event RECEIVE\\[5\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive5(&self) -> RECEIVE5_R {
|
||||
RECEIVE5_R::new(((self.bits >> 5) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 6 - Read pending status of interrupt for event RECEIVE\\[6\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive6(&self) -> RECEIVE6_R {
|
||||
RECEIVE6_R::new(((self.bits >> 6) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 7 - Read pending status of interrupt for event RECEIVE\\[7\\]"]
|
||||
#[inline(always)]
|
||||
pub fn receive7(&self) -> RECEIVE7_R {
|
||||
RECEIVE7_R::new(((self.bits >> 7) & 1) != 0)
|
||||
}
|
||||
}
|
||||
#[doc = "Pending interrupts\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 [intpend](index.html) module"]
|
||||
pub struct INTPEND_SPEC;
|
||||
impl crate::RegisterSpec for INTPEND_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [intpend::R](R) reader structure"]
|
||||
impl crate::Readable for INTPEND_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`reset()` method sets INTPEND to value 0"]
|
||||
impl crate::Resettable for INTPEND_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
+145
@@ -0,0 +1,145 @@
|
||||
#[doc = "Register `PUBLISH_RECEIVE[%s]` reader"]
|
||||
pub struct R(crate::R<PUBLISH_RECEIVE_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<PUBLISH_RECEIVE_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<PUBLISH_RECEIVE_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<PUBLISH_RECEIVE_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `PUBLISH_RECEIVE[%s]` writer"]
|
||||
pub struct W(crate::W<PUBLISH_RECEIVE_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<PUBLISH_RECEIVE_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<PUBLISH_RECEIVE_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<PUBLISH_RECEIVE_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHIDX` reader - Channel that event RECEIVE\\[n\\]
|
||||
will publish to."]
|
||||
pub type CHIDX_R = crate::FieldReader<u8, u8>;
|
||||
#[doc = "Field `CHIDX` writer - Channel that event RECEIVE\\[n\\]
|
||||
will publish to."]
|
||||
pub type CHIDX_W<'a, const O: u8> = crate::FieldWriter<'a, u32, PUBLISH_RECEIVE_SPEC, u8, u8, 4, O>;
|
||||
#[doc = "Field `EN` reader - "]
|
||||
pub type EN_R = crate::BitReader<EN_A>;
|
||||
#[doc = "\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum EN_A {
|
||||
#[doc = "0: Disable publishing"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Enable publishing"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<EN_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: EN_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl EN_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> EN_A {
|
||||
match self.bits {
|
||||
false => EN_A::DISABLED,
|
||||
true => EN_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == EN_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == EN_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `EN` writer - "]
|
||||
pub type EN_W<'a, const O: u8> = crate::BitWriter<'a, u32, PUBLISH_RECEIVE_SPEC, EN_A, O>;
|
||||
impl<'a, const O: u8> EN_W<'a, O> {
|
||||
#[doc = "Disable publishing"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(EN_A::DISABLED)
|
||||
}
|
||||
#[doc = "Enable publishing"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(EN_A::ENABLED)
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 0:3 - Channel that event RECEIVE\\[n\\]
|
||||
will publish to."]
|
||||
#[inline(always)]
|
||||
pub fn chidx(&self) -> CHIDX_R {
|
||||
CHIDX_R::new((self.bits & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bit 31"]
|
||||
#[inline(always)]
|
||||
pub fn en(&self) -> EN_R {
|
||||
EN_R::new(((self.bits >> 31) & 1) != 0)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 0:3 - Channel that event RECEIVE\\[n\\]
|
||||
will publish to."]
|
||||
#[inline(always)]
|
||||
pub fn chidx(&mut self) -> CHIDX_W<0> {
|
||||
CHIDX_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 31"]
|
||||
#[inline(always)]
|
||||
pub fn en(&mut self) -> EN_W<31> {
|
||||
EN_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 = "Description collection: Publish configuration for event RECEIVE\\[n\\]\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 [publish_receive](index.html) module"]
|
||||
pub struct PUBLISH_RECEIVE_SPEC;
|
||||
impl crate::RegisterSpec for PUBLISH_RECEIVE_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [publish_receive::R](R) reader structure"]
|
||||
impl crate::Readable for PUBLISH_RECEIVE_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [publish_receive::W](W) writer structure"]
|
||||
impl crate::Writable for PUBLISH_RECEIVE_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets PUBLISH_RECEIVE[%s]
|
||||
to value 0"]
|
||||
impl crate::Resettable for PUBLISH_RECEIVE_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
+547
@@ -0,0 +1,547 @@
|
||||
#[doc = "Register `RECEIVE_CNF[%s]` reader"]
|
||||
pub struct R(crate::R<RECEIVE_CNF_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<RECEIVE_CNF_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<RECEIVE_CNF_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<RECEIVE_CNF_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `RECEIVE_CNF[%s]` writer"]
|
||||
pub struct W(crate::W<RECEIVE_CNF_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<RECEIVE_CNF_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<RECEIVE_CNF_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<RECEIVE_CNF_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHEN0` reader - Enable subscription to channel 0."]
|
||||
pub type CHEN0_R = crate::BitReader<CHEN0_A>;
|
||||
#[doc = "Enable subscription to channel 0.\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum CHEN0_A {
|
||||
#[doc = "0: Disable events."]
|
||||
DISABLE = 0,
|
||||
#[doc = "1: Enable events."]
|
||||
ENABLE = 1,
|
||||
}
|
||||
impl From<CHEN0_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: CHEN0_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl CHEN0_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> CHEN0_A {
|
||||
match self.bits {
|
||||
false => CHEN0_A::DISABLE,
|
||||
true => CHEN0_A::ENABLE,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disable(&self) -> bool {
|
||||
*self == CHEN0_A::DISABLE
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enable(&self) -> bool {
|
||||
*self == CHEN0_A::ENABLE
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHEN0` writer - Enable subscription to channel 0."]
|
||||
pub type CHEN0_W<'a, const O: u8> = crate::BitWriter<'a, u32, RECEIVE_CNF_SPEC, CHEN0_A, O>;
|
||||
impl<'a, const O: u8> CHEN0_W<'a, O> {
|
||||
#[doc = "Disable events."]
|
||||
#[inline(always)]
|
||||
pub fn disable(self) -> &'a mut W {
|
||||
self.variant(CHEN0_A::DISABLE)
|
||||
}
|
||||
#[doc = "Enable events."]
|
||||
#[inline(always)]
|
||||
pub fn enable(self) -> &'a mut W {
|
||||
self.variant(CHEN0_A::ENABLE)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHEN1` reader - Enable subscription to channel 1."]
|
||||
pub type CHEN1_R = crate::BitReader<CHEN1_A>;
|
||||
#[doc = "Enable subscription to channel 1.\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum CHEN1_A {
|
||||
#[doc = "0: Disable events."]
|
||||
DISABLE = 0,
|
||||
#[doc = "1: Enable events."]
|
||||
ENABLE = 1,
|
||||
}
|
||||
impl From<CHEN1_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: CHEN1_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl CHEN1_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> CHEN1_A {
|
||||
match self.bits {
|
||||
false => CHEN1_A::DISABLE,
|
||||
true => CHEN1_A::ENABLE,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disable(&self) -> bool {
|
||||
*self == CHEN1_A::DISABLE
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enable(&self) -> bool {
|
||||
*self == CHEN1_A::ENABLE
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHEN1` writer - Enable subscription to channel 1."]
|
||||
pub type CHEN1_W<'a, const O: u8> = crate::BitWriter<'a, u32, RECEIVE_CNF_SPEC, CHEN1_A, O>;
|
||||
impl<'a, const O: u8> CHEN1_W<'a, O> {
|
||||
#[doc = "Disable events."]
|
||||
#[inline(always)]
|
||||
pub fn disable(self) -> &'a mut W {
|
||||
self.variant(CHEN1_A::DISABLE)
|
||||
}
|
||||
#[doc = "Enable events."]
|
||||
#[inline(always)]
|
||||
pub fn enable(self) -> &'a mut W {
|
||||
self.variant(CHEN1_A::ENABLE)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHEN2` reader - Enable subscription to channel 2."]
|
||||
pub type CHEN2_R = crate::BitReader<CHEN2_A>;
|
||||
#[doc = "Enable subscription to channel 2.\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum CHEN2_A {
|
||||
#[doc = "0: Disable events."]
|
||||
DISABLE = 0,
|
||||
#[doc = "1: Enable events."]
|
||||
ENABLE = 1,
|
||||
}
|
||||
impl From<CHEN2_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: CHEN2_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl CHEN2_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> CHEN2_A {
|
||||
match self.bits {
|
||||
false => CHEN2_A::DISABLE,
|
||||
true => CHEN2_A::ENABLE,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disable(&self) -> bool {
|
||||
*self == CHEN2_A::DISABLE
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enable(&self) -> bool {
|
||||
*self == CHEN2_A::ENABLE
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHEN2` writer - Enable subscription to channel 2."]
|
||||
pub type CHEN2_W<'a, const O: u8> = crate::BitWriter<'a, u32, RECEIVE_CNF_SPEC, CHEN2_A, O>;
|
||||
impl<'a, const O: u8> CHEN2_W<'a, O> {
|
||||
#[doc = "Disable events."]
|
||||
#[inline(always)]
|
||||
pub fn disable(self) -> &'a mut W {
|
||||
self.variant(CHEN2_A::DISABLE)
|
||||
}
|
||||
#[doc = "Enable events."]
|
||||
#[inline(always)]
|
||||
pub fn enable(self) -> &'a mut W {
|
||||
self.variant(CHEN2_A::ENABLE)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHEN3` reader - Enable subscription to channel 3."]
|
||||
pub type CHEN3_R = crate::BitReader<CHEN3_A>;
|
||||
#[doc = "Enable subscription to channel 3.\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum CHEN3_A {
|
||||
#[doc = "0: Disable events."]
|
||||
DISABLE = 0,
|
||||
#[doc = "1: Enable events."]
|
||||
ENABLE = 1,
|
||||
}
|
||||
impl From<CHEN3_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: CHEN3_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl CHEN3_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> CHEN3_A {
|
||||
match self.bits {
|
||||
false => CHEN3_A::DISABLE,
|
||||
true => CHEN3_A::ENABLE,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disable(&self) -> bool {
|
||||
*self == CHEN3_A::DISABLE
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enable(&self) -> bool {
|
||||
*self == CHEN3_A::ENABLE
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHEN3` writer - Enable subscription to channel 3."]
|
||||
pub type CHEN3_W<'a, const O: u8> = crate::BitWriter<'a, u32, RECEIVE_CNF_SPEC, CHEN3_A, O>;
|
||||
impl<'a, const O: u8> CHEN3_W<'a, O> {
|
||||
#[doc = "Disable events."]
|
||||
#[inline(always)]
|
||||
pub fn disable(self) -> &'a mut W {
|
||||
self.variant(CHEN3_A::DISABLE)
|
||||
}
|
||||
#[doc = "Enable events."]
|
||||
#[inline(always)]
|
||||
pub fn enable(self) -> &'a mut W {
|
||||
self.variant(CHEN3_A::ENABLE)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHEN4` reader - Enable subscription to channel 4."]
|
||||
pub type CHEN4_R = crate::BitReader<CHEN4_A>;
|
||||
#[doc = "Enable subscription to channel 4.\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum CHEN4_A {
|
||||
#[doc = "0: Disable events."]
|
||||
DISABLE = 0,
|
||||
#[doc = "1: Enable events."]
|
||||
ENABLE = 1,
|
||||
}
|
||||
impl From<CHEN4_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: CHEN4_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl CHEN4_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> CHEN4_A {
|
||||
match self.bits {
|
||||
false => CHEN4_A::DISABLE,
|
||||
true => CHEN4_A::ENABLE,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disable(&self) -> bool {
|
||||
*self == CHEN4_A::DISABLE
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enable(&self) -> bool {
|
||||
*self == CHEN4_A::ENABLE
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHEN4` writer - Enable subscription to channel 4."]
|
||||
pub type CHEN4_W<'a, const O: u8> = crate::BitWriter<'a, u32, RECEIVE_CNF_SPEC, CHEN4_A, O>;
|
||||
impl<'a, const O: u8> CHEN4_W<'a, O> {
|
||||
#[doc = "Disable events."]
|
||||
#[inline(always)]
|
||||
pub fn disable(self) -> &'a mut W {
|
||||
self.variant(CHEN4_A::DISABLE)
|
||||
}
|
||||
#[doc = "Enable events."]
|
||||
#[inline(always)]
|
||||
pub fn enable(self) -> &'a mut W {
|
||||
self.variant(CHEN4_A::ENABLE)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHEN5` reader - Enable subscription to channel 5."]
|
||||
pub type CHEN5_R = crate::BitReader<CHEN5_A>;
|
||||
#[doc = "Enable subscription to channel 5.\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum CHEN5_A {
|
||||
#[doc = "0: Disable events."]
|
||||
DISABLE = 0,
|
||||
#[doc = "1: Enable events."]
|
||||
ENABLE = 1,
|
||||
}
|
||||
impl From<CHEN5_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: CHEN5_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl CHEN5_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> CHEN5_A {
|
||||
match self.bits {
|
||||
false => CHEN5_A::DISABLE,
|
||||
true => CHEN5_A::ENABLE,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disable(&self) -> bool {
|
||||
*self == CHEN5_A::DISABLE
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enable(&self) -> bool {
|
||||
*self == CHEN5_A::ENABLE
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHEN5` writer - Enable subscription to channel 5."]
|
||||
pub type CHEN5_W<'a, const O: u8> = crate::BitWriter<'a, u32, RECEIVE_CNF_SPEC, CHEN5_A, O>;
|
||||
impl<'a, const O: u8> CHEN5_W<'a, O> {
|
||||
#[doc = "Disable events."]
|
||||
#[inline(always)]
|
||||
pub fn disable(self) -> &'a mut W {
|
||||
self.variant(CHEN5_A::DISABLE)
|
||||
}
|
||||
#[doc = "Enable events."]
|
||||
#[inline(always)]
|
||||
pub fn enable(self) -> &'a mut W {
|
||||
self.variant(CHEN5_A::ENABLE)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHEN6` reader - Enable subscription to channel 6."]
|
||||
pub type CHEN6_R = crate::BitReader<CHEN6_A>;
|
||||
#[doc = "Enable subscription to channel 6.\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum CHEN6_A {
|
||||
#[doc = "0: Disable events."]
|
||||
DISABLE = 0,
|
||||
#[doc = "1: Enable events."]
|
||||
ENABLE = 1,
|
||||
}
|
||||
impl From<CHEN6_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: CHEN6_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl CHEN6_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> CHEN6_A {
|
||||
match self.bits {
|
||||
false => CHEN6_A::DISABLE,
|
||||
true => CHEN6_A::ENABLE,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disable(&self) -> bool {
|
||||
*self == CHEN6_A::DISABLE
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enable(&self) -> bool {
|
||||
*self == CHEN6_A::ENABLE
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHEN6` writer - Enable subscription to channel 6."]
|
||||
pub type CHEN6_W<'a, const O: u8> = crate::BitWriter<'a, u32, RECEIVE_CNF_SPEC, CHEN6_A, O>;
|
||||
impl<'a, const O: u8> CHEN6_W<'a, O> {
|
||||
#[doc = "Disable events."]
|
||||
#[inline(always)]
|
||||
pub fn disable(self) -> &'a mut W {
|
||||
self.variant(CHEN6_A::DISABLE)
|
||||
}
|
||||
#[doc = "Enable events."]
|
||||
#[inline(always)]
|
||||
pub fn enable(self) -> &'a mut W {
|
||||
self.variant(CHEN6_A::ENABLE)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHEN7` reader - Enable subscription to channel 7."]
|
||||
pub type CHEN7_R = crate::BitReader<CHEN7_A>;
|
||||
#[doc = "Enable subscription to channel 7.\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum CHEN7_A {
|
||||
#[doc = "0: Disable events."]
|
||||
DISABLE = 0,
|
||||
#[doc = "1: Enable events."]
|
||||
ENABLE = 1,
|
||||
}
|
||||
impl From<CHEN7_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: CHEN7_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl CHEN7_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> CHEN7_A {
|
||||
match self.bits {
|
||||
false => CHEN7_A::DISABLE,
|
||||
true => CHEN7_A::ENABLE,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disable(&self) -> bool {
|
||||
*self == CHEN7_A::DISABLE
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enable(&self) -> bool {
|
||||
*self == CHEN7_A::ENABLE
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHEN7` writer - Enable subscription to channel 7."]
|
||||
pub type CHEN7_W<'a, const O: u8> = crate::BitWriter<'a, u32, RECEIVE_CNF_SPEC, CHEN7_A, O>;
|
||||
impl<'a, const O: u8> CHEN7_W<'a, O> {
|
||||
#[doc = "Disable events."]
|
||||
#[inline(always)]
|
||||
pub fn disable(self) -> &'a mut W {
|
||||
self.variant(CHEN7_A::DISABLE)
|
||||
}
|
||||
#[doc = "Enable events."]
|
||||
#[inline(always)]
|
||||
pub fn enable(self) -> &'a mut W {
|
||||
self.variant(CHEN7_A::ENABLE)
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bit 0 - Enable subscription to channel 0."]
|
||||
#[inline(always)]
|
||||
pub fn chen0(&self) -> CHEN0_R {
|
||||
CHEN0_R::new((self.bits & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 1 - Enable subscription to channel 1."]
|
||||
#[inline(always)]
|
||||
pub fn chen1(&self) -> CHEN1_R {
|
||||
CHEN1_R::new(((self.bits >> 1) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 2 - Enable subscription to channel 2."]
|
||||
#[inline(always)]
|
||||
pub fn chen2(&self) -> CHEN2_R {
|
||||
CHEN2_R::new(((self.bits >> 2) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 3 - Enable subscription to channel 3."]
|
||||
#[inline(always)]
|
||||
pub fn chen3(&self) -> CHEN3_R {
|
||||
CHEN3_R::new(((self.bits >> 3) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 4 - Enable subscription to channel 4."]
|
||||
#[inline(always)]
|
||||
pub fn chen4(&self) -> CHEN4_R {
|
||||
CHEN4_R::new(((self.bits >> 4) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 5 - Enable subscription to channel 5."]
|
||||
#[inline(always)]
|
||||
pub fn chen5(&self) -> CHEN5_R {
|
||||
CHEN5_R::new(((self.bits >> 5) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 6 - Enable subscription to channel 6."]
|
||||
#[inline(always)]
|
||||
pub fn chen6(&self) -> CHEN6_R {
|
||||
CHEN6_R::new(((self.bits >> 6) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 7 - Enable subscription to channel 7."]
|
||||
#[inline(always)]
|
||||
pub fn chen7(&self) -> CHEN7_R {
|
||||
CHEN7_R::new(((self.bits >> 7) & 1) != 0)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 0 - Enable subscription to channel 0."]
|
||||
#[inline(always)]
|
||||
pub fn chen0(&mut self) -> CHEN0_W<0> {
|
||||
CHEN0_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 1 - Enable subscription to channel 1."]
|
||||
#[inline(always)]
|
||||
pub fn chen1(&mut self) -> CHEN1_W<1> {
|
||||
CHEN1_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 2 - Enable subscription to channel 2."]
|
||||
#[inline(always)]
|
||||
pub fn chen2(&mut self) -> CHEN2_W<2> {
|
||||
CHEN2_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 3 - Enable subscription to channel 3."]
|
||||
#[inline(always)]
|
||||
pub fn chen3(&mut self) -> CHEN3_W<3> {
|
||||
CHEN3_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 4 - Enable subscription to channel 4."]
|
||||
#[inline(always)]
|
||||
pub fn chen4(&mut self) -> CHEN4_W<4> {
|
||||
CHEN4_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 5 - Enable subscription to channel 5."]
|
||||
#[inline(always)]
|
||||
pub fn chen5(&mut self) -> CHEN5_W<5> {
|
||||
CHEN5_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 6 - Enable subscription to channel 6."]
|
||||
#[inline(always)]
|
||||
pub fn chen6(&mut self) -> CHEN6_W<6> {
|
||||
CHEN6_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 7 - Enable subscription to channel 7."]
|
||||
#[inline(always)]
|
||||
pub fn chen7(&mut self) -> CHEN7_W<7> {
|
||||
CHEN7_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 = "Description collection: Receive event configuration for EVENTS_RECEIVE\\[n\\].\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 [receive_cnf](index.html) module"]
|
||||
pub struct RECEIVE_CNF_SPEC;
|
||||
impl crate::RegisterSpec for RECEIVE_CNF_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [receive_cnf::R](R) reader structure"]
|
||||
impl crate::Readable for RECEIVE_CNF_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [receive_cnf::W](W) writer structure"]
|
||||
impl crate::Writable for RECEIVE_CNF_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets RECEIVE_CNF[%s]
|
||||
to value 0"]
|
||||
impl crate::Resettable for RECEIVE_CNF_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
+547
@@ -0,0 +1,547 @@
|
||||
#[doc = "Register `SEND_CNF[%s]` reader"]
|
||||
pub struct R(crate::R<SEND_CNF_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<SEND_CNF_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<SEND_CNF_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<SEND_CNF_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `SEND_CNF[%s]` writer"]
|
||||
pub struct W(crate::W<SEND_CNF_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<SEND_CNF_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<SEND_CNF_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<SEND_CNF_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHEN0` reader - Enable broadcasting on channel 0."]
|
||||
pub type CHEN0_R = crate::BitReader<CHEN0_A>;
|
||||
#[doc = "Enable broadcasting on channel 0.\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum CHEN0_A {
|
||||
#[doc = "0: Disable broadcast."]
|
||||
DISABLE = 0,
|
||||
#[doc = "1: Enable broadcast."]
|
||||
ENABLE = 1,
|
||||
}
|
||||
impl From<CHEN0_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: CHEN0_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl CHEN0_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> CHEN0_A {
|
||||
match self.bits {
|
||||
false => CHEN0_A::DISABLE,
|
||||
true => CHEN0_A::ENABLE,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disable(&self) -> bool {
|
||||
*self == CHEN0_A::DISABLE
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enable(&self) -> bool {
|
||||
*self == CHEN0_A::ENABLE
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHEN0` writer - Enable broadcasting on channel 0."]
|
||||
pub type CHEN0_W<'a, const O: u8> = crate::BitWriter<'a, u32, SEND_CNF_SPEC, CHEN0_A, O>;
|
||||
impl<'a, const O: u8> CHEN0_W<'a, O> {
|
||||
#[doc = "Disable broadcast."]
|
||||
#[inline(always)]
|
||||
pub fn disable(self) -> &'a mut W {
|
||||
self.variant(CHEN0_A::DISABLE)
|
||||
}
|
||||
#[doc = "Enable broadcast."]
|
||||
#[inline(always)]
|
||||
pub fn enable(self) -> &'a mut W {
|
||||
self.variant(CHEN0_A::ENABLE)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHEN1` reader - Enable broadcasting on channel 1."]
|
||||
pub type CHEN1_R = crate::BitReader<CHEN1_A>;
|
||||
#[doc = "Enable broadcasting on channel 1.\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum CHEN1_A {
|
||||
#[doc = "0: Disable broadcast."]
|
||||
DISABLE = 0,
|
||||
#[doc = "1: Enable broadcast."]
|
||||
ENABLE = 1,
|
||||
}
|
||||
impl From<CHEN1_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: CHEN1_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl CHEN1_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> CHEN1_A {
|
||||
match self.bits {
|
||||
false => CHEN1_A::DISABLE,
|
||||
true => CHEN1_A::ENABLE,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disable(&self) -> bool {
|
||||
*self == CHEN1_A::DISABLE
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enable(&self) -> bool {
|
||||
*self == CHEN1_A::ENABLE
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHEN1` writer - Enable broadcasting on channel 1."]
|
||||
pub type CHEN1_W<'a, const O: u8> = crate::BitWriter<'a, u32, SEND_CNF_SPEC, CHEN1_A, O>;
|
||||
impl<'a, const O: u8> CHEN1_W<'a, O> {
|
||||
#[doc = "Disable broadcast."]
|
||||
#[inline(always)]
|
||||
pub fn disable(self) -> &'a mut W {
|
||||
self.variant(CHEN1_A::DISABLE)
|
||||
}
|
||||
#[doc = "Enable broadcast."]
|
||||
#[inline(always)]
|
||||
pub fn enable(self) -> &'a mut W {
|
||||
self.variant(CHEN1_A::ENABLE)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHEN2` reader - Enable broadcasting on channel 2."]
|
||||
pub type CHEN2_R = crate::BitReader<CHEN2_A>;
|
||||
#[doc = "Enable broadcasting on channel 2.\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum CHEN2_A {
|
||||
#[doc = "0: Disable broadcast."]
|
||||
DISABLE = 0,
|
||||
#[doc = "1: Enable broadcast."]
|
||||
ENABLE = 1,
|
||||
}
|
||||
impl From<CHEN2_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: CHEN2_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl CHEN2_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> CHEN2_A {
|
||||
match self.bits {
|
||||
false => CHEN2_A::DISABLE,
|
||||
true => CHEN2_A::ENABLE,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disable(&self) -> bool {
|
||||
*self == CHEN2_A::DISABLE
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enable(&self) -> bool {
|
||||
*self == CHEN2_A::ENABLE
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHEN2` writer - Enable broadcasting on channel 2."]
|
||||
pub type CHEN2_W<'a, const O: u8> = crate::BitWriter<'a, u32, SEND_CNF_SPEC, CHEN2_A, O>;
|
||||
impl<'a, const O: u8> CHEN2_W<'a, O> {
|
||||
#[doc = "Disable broadcast."]
|
||||
#[inline(always)]
|
||||
pub fn disable(self) -> &'a mut W {
|
||||
self.variant(CHEN2_A::DISABLE)
|
||||
}
|
||||
#[doc = "Enable broadcast."]
|
||||
#[inline(always)]
|
||||
pub fn enable(self) -> &'a mut W {
|
||||
self.variant(CHEN2_A::ENABLE)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHEN3` reader - Enable broadcasting on channel 3."]
|
||||
pub type CHEN3_R = crate::BitReader<CHEN3_A>;
|
||||
#[doc = "Enable broadcasting on channel 3.\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum CHEN3_A {
|
||||
#[doc = "0: Disable broadcast."]
|
||||
DISABLE = 0,
|
||||
#[doc = "1: Enable broadcast."]
|
||||
ENABLE = 1,
|
||||
}
|
||||
impl From<CHEN3_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: CHEN3_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl CHEN3_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> CHEN3_A {
|
||||
match self.bits {
|
||||
false => CHEN3_A::DISABLE,
|
||||
true => CHEN3_A::ENABLE,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disable(&self) -> bool {
|
||||
*self == CHEN3_A::DISABLE
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enable(&self) -> bool {
|
||||
*self == CHEN3_A::ENABLE
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHEN3` writer - Enable broadcasting on channel 3."]
|
||||
pub type CHEN3_W<'a, const O: u8> = crate::BitWriter<'a, u32, SEND_CNF_SPEC, CHEN3_A, O>;
|
||||
impl<'a, const O: u8> CHEN3_W<'a, O> {
|
||||
#[doc = "Disable broadcast."]
|
||||
#[inline(always)]
|
||||
pub fn disable(self) -> &'a mut W {
|
||||
self.variant(CHEN3_A::DISABLE)
|
||||
}
|
||||
#[doc = "Enable broadcast."]
|
||||
#[inline(always)]
|
||||
pub fn enable(self) -> &'a mut W {
|
||||
self.variant(CHEN3_A::ENABLE)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHEN4` reader - Enable broadcasting on channel 4."]
|
||||
pub type CHEN4_R = crate::BitReader<CHEN4_A>;
|
||||
#[doc = "Enable broadcasting on channel 4.\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum CHEN4_A {
|
||||
#[doc = "0: Disable broadcast."]
|
||||
DISABLE = 0,
|
||||
#[doc = "1: Enable broadcast."]
|
||||
ENABLE = 1,
|
||||
}
|
||||
impl From<CHEN4_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: CHEN4_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl CHEN4_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> CHEN4_A {
|
||||
match self.bits {
|
||||
false => CHEN4_A::DISABLE,
|
||||
true => CHEN4_A::ENABLE,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disable(&self) -> bool {
|
||||
*self == CHEN4_A::DISABLE
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enable(&self) -> bool {
|
||||
*self == CHEN4_A::ENABLE
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHEN4` writer - Enable broadcasting on channel 4."]
|
||||
pub type CHEN4_W<'a, const O: u8> = crate::BitWriter<'a, u32, SEND_CNF_SPEC, CHEN4_A, O>;
|
||||
impl<'a, const O: u8> CHEN4_W<'a, O> {
|
||||
#[doc = "Disable broadcast."]
|
||||
#[inline(always)]
|
||||
pub fn disable(self) -> &'a mut W {
|
||||
self.variant(CHEN4_A::DISABLE)
|
||||
}
|
||||
#[doc = "Enable broadcast."]
|
||||
#[inline(always)]
|
||||
pub fn enable(self) -> &'a mut W {
|
||||
self.variant(CHEN4_A::ENABLE)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHEN5` reader - Enable broadcasting on channel 5."]
|
||||
pub type CHEN5_R = crate::BitReader<CHEN5_A>;
|
||||
#[doc = "Enable broadcasting on channel 5.\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum CHEN5_A {
|
||||
#[doc = "0: Disable broadcast."]
|
||||
DISABLE = 0,
|
||||
#[doc = "1: Enable broadcast."]
|
||||
ENABLE = 1,
|
||||
}
|
||||
impl From<CHEN5_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: CHEN5_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl CHEN5_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> CHEN5_A {
|
||||
match self.bits {
|
||||
false => CHEN5_A::DISABLE,
|
||||
true => CHEN5_A::ENABLE,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disable(&self) -> bool {
|
||||
*self == CHEN5_A::DISABLE
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enable(&self) -> bool {
|
||||
*self == CHEN5_A::ENABLE
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHEN5` writer - Enable broadcasting on channel 5."]
|
||||
pub type CHEN5_W<'a, const O: u8> = crate::BitWriter<'a, u32, SEND_CNF_SPEC, CHEN5_A, O>;
|
||||
impl<'a, const O: u8> CHEN5_W<'a, O> {
|
||||
#[doc = "Disable broadcast."]
|
||||
#[inline(always)]
|
||||
pub fn disable(self) -> &'a mut W {
|
||||
self.variant(CHEN5_A::DISABLE)
|
||||
}
|
||||
#[doc = "Enable broadcast."]
|
||||
#[inline(always)]
|
||||
pub fn enable(self) -> &'a mut W {
|
||||
self.variant(CHEN5_A::ENABLE)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHEN6` reader - Enable broadcasting on channel 6."]
|
||||
pub type CHEN6_R = crate::BitReader<CHEN6_A>;
|
||||
#[doc = "Enable broadcasting on channel 6.\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum CHEN6_A {
|
||||
#[doc = "0: Disable broadcast."]
|
||||
DISABLE = 0,
|
||||
#[doc = "1: Enable broadcast."]
|
||||
ENABLE = 1,
|
||||
}
|
||||
impl From<CHEN6_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: CHEN6_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl CHEN6_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> CHEN6_A {
|
||||
match self.bits {
|
||||
false => CHEN6_A::DISABLE,
|
||||
true => CHEN6_A::ENABLE,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disable(&self) -> bool {
|
||||
*self == CHEN6_A::DISABLE
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enable(&self) -> bool {
|
||||
*self == CHEN6_A::ENABLE
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHEN6` writer - Enable broadcasting on channel 6."]
|
||||
pub type CHEN6_W<'a, const O: u8> = crate::BitWriter<'a, u32, SEND_CNF_SPEC, CHEN6_A, O>;
|
||||
impl<'a, const O: u8> CHEN6_W<'a, O> {
|
||||
#[doc = "Disable broadcast."]
|
||||
#[inline(always)]
|
||||
pub fn disable(self) -> &'a mut W {
|
||||
self.variant(CHEN6_A::DISABLE)
|
||||
}
|
||||
#[doc = "Enable broadcast."]
|
||||
#[inline(always)]
|
||||
pub fn enable(self) -> &'a mut W {
|
||||
self.variant(CHEN6_A::ENABLE)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHEN7` reader - Enable broadcasting on channel 7."]
|
||||
pub type CHEN7_R = crate::BitReader<CHEN7_A>;
|
||||
#[doc = "Enable broadcasting on channel 7.\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum CHEN7_A {
|
||||
#[doc = "0: Disable broadcast."]
|
||||
DISABLE = 0,
|
||||
#[doc = "1: Enable broadcast."]
|
||||
ENABLE = 1,
|
||||
}
|
||||
impl From<CHEN7_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: CHEN7_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl CHEN7_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> CHEN7_A {
|
||||
match self.bits {
|
||||
false => CHEN7_A::DISABLE,
|
||||
true => CHEN7_A::ENABLE,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disable(&self) -> bool {
|
||||
*self == CHEN7_A::DISABLE
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLE`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enable(&self) -> bool {
|
||||
*self == CHEN7_A::ENABLE
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHEN7` writer - Enable broadcasting on channel 7."]
|
||||
pub type CHEN7_W<'a, const O: u8> = crate::BitWriter<'a, u32, SEND_CNF_SPEC, CHEN7_A, O>;
|
||||
impl<'a, const O: u8> CHEN7_W<'a, O> {
|
||||
#[doc = "Disable broadcast."]
|
||||
#[inline(always)]
|
||||
pub fn disable(self) -> &'a mut W {
|
||||
self.variant(CHEN7_A::DISABLE)
|
||||
}
|
||||
#[doc = "Enable broadcast."]
|
||||
#[inline(always)]
|
||||
pub fn enable(self) -> &'a mut W {
|
||||
self.variant(CHEN7_A::ENABLE)
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bit 0 - Enable broadcasting on channel 0."]
|
||||
#[inline(always)]
|
||||
pub fn chen0(&self) -> CHEN0_R {
|
||||
CHEN0_R::new((self.bits & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 1 - Enable broadcasting on channel 1."]
|
||||
#[inline(always)]
|
||||
pub fn chen1(&self) -> CHEN1_R {
|
||||
CHEN1_R::new(((self.bits >> 1) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 2 - Enable broadcasting on channel 2."]
|
||||
#[inline(always)]
|
||||
pub fn chen2(&self) -> CHEN2_R {
|
||||
CHEN2_R::new(((self.bits >> 2) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 3 - Enable broadcasting on channel 3."]
|
||||
#[inline(always)]
|
||||
pub fn chen3(&self) -> CHEN3_R {
|
||||
CHEN3_R::new(((self.bits >> 3) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 4 - Enable broadcasting on channel 4."]
|
||||
#[inline(always)]
|
||||
pub fn chen4(&self) -> CHEN4_R {
|
||||
CHEN4_R::new(((self.bits >> 4) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 5 - Enable broadcasting on channel 5."]
|
||||
#[inline(always)]
|
||||
pub fn chen5(&self) -> CHEN5_R {
|
||||
CHEN5_R::new(((self.bits >> 5) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 6 - Enable broadcasting on channel 6."]
|
||||
#[inline(always)]
|
||||
pub fn chen6(&self) -> CHEN6_R {
|
||||
CHEN6_R::new(((self.bits >> 6) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 7 - Enable broadcasting on channel 7."]
|
||||
#[inline(always)]
|
||||
pub fn chen7(&self) -> CHEN7_R {
|
||||
CHEN7_R::new(((self.bits >> 7) & 1) != 0)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 0 - Enable broadcasting on channel 0."]
|
||||
#[inline(always)]
|
||||
pub fn chen0(&mut self) -> CHEN0_W<0> {
|
||||
CHEN0_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 1 - Enable broadcasting on channel 1."]
|
||||
#[inline(always)]
|
||||
pub fn chen1(&mut self) -> CHEN1_W<1> {
|
||||
CHEN1_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 2 - Enable broadcasting on channel 2."]
|
||||
#[inline(always)]
|
||||
pub fn chen2(&mut self) -> CHEN2_W<2> {
|
||||
CHEN2_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 3 - Enable broadcasting on channel 3."]
|
||||
#[inline(always)]
|
||||
pub fn chen3(&mut self) -> CHEN3_W<3> {
|
||||
CHEN3_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 4 - Enable broadcasting on channel 4."]
|
||||
#[inline(always)]
|
||||
pub fn chen4(&mut self) -> CHEN4_W<4> {
|
||||
CHEN4_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 5 - Enable broadcasting on channel 5."]
|
||||
#[inline(always)]
|
||||
pub fn chen5(&mut self) -> CHEN5_W<5> {
|
||||
CHEN5_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 6 - Enable broadcasting on channel 6."]
|
||||
#[inline(always)]
|
||||
pub fn chen6(&mut self) -> CHEN6_W<6> {
|
||||
CHEN6_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 7 - Enable broadcasting on channel 7."]
|
||||
#[inline(always)]
|
||||
pub fn chen7(&mut self) -> CHEN7_W<7> {
|
||||
CHEN7_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 = "Description collection: Send event configuration for TASKS_SEND\\[n\\].\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 [send_cnf](index.html) module"]
|
||||
pub struct SEND_CNF_SPEC;
|
||||
impl crate::RegisterSpec for SEND_CNF_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [send_cnf::R](R) reader structure"]
|
||||
impl crate::Readable for SEND_CNF_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [send_cnf::W](W) writer structure"]
|
||||
impl crate::Writable for SEND_CNF_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets SEND_CNF[%s]
|
||||
to value 0"]
|
||||
impl crate::Resettable for SEND_CNF_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
+145
@@ -0,0 +1,145 @@
|
||||
#[doc = "Register `SUBSCRIBE_SEND[%s]` reader"]
|
||||
pub struct R(crate::R<SUBSCRIBE_SEND_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<SUBSCRIBE_SEND_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<SUBSCRIBE_SEND_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<SUBSCRIBE_SEND_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `SUBSCRIBE_SEND[%s]` writer"]
|
||||
pub struct W(crate::W<SUBSCRIBE_SEND_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<SUBSCRIBE_SEND_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<SUBSCRIBE_SEND_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<SUBSCRIBE_SEND_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `CHIDX` reader - Channel that task SEND\\[n\\]
|
||||
will subscribe to"]
|
||||
pub type CHIDX_R = crate::FieldReader<u8, u8>;
|
||||
#[doc = "Field `CHIDX` writer - Channel that task SEND\\[n\\]
|
||||
will subscribe to"]
|
||||
pub type CHIDX_W<'a, const O: u8> = crate::FieldWriter<'a, u32, SUBSCRIBE_SEND_SPEC, u8, u8, 4, O>;
|
||||
#[doc = "Field `EN` reader - "]
|
||||
pub type EN_R = crate::BitReader<EN_A>;
|
||||
#[doc = "\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum EN_A {
|
||||
#[doc = "0: Disable subscription"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Enable subscription"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<EN_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: EN_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl EN_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> EN_A {
|
||||
match self.bits {
|
||||
false => EN_A::DISABLED,
|
||||
true => EN_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == EN_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == EN_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `EN` writer - "]
|
||||
pub type EN_W<'a, const O: u8> = crate::BitWriter<'a, u32, SUBSCRIBE_SEND_SPEC, EN_A, O>;
|
||||
impl<'a, const O: u8> EN_W<'a, O> {
|
||||
#[doc = "Disable subscription"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(EN_A::DISABLED)
|
||||
}
|
||||
#[doc = "Enable subscription"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(EN_A::ENABLED)
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bits 0:3 - Channel that task SEND\\[n\\]
|
||||
will subscribe to"]
|
||||
#[inline(always)]
|
||||
pub fn chidx(&self) -> CHIDX_R {
|
||||
CHIDX_R::new((self.bits & 0x0f) as u8)
|
||||
}
|
||||
#[doc = "Bit 31"]
|
||||
#[inline(always)]
|
||||
pub fn en(&self) -> EN_R {
|
||||
EN_R::new(((self.bits >> 31) & 1) != 0)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 0:3 - Channel that task SEND\\[n\\]
|
||||
will subscribe to"]
|
||||
#[inline(always)]
|
||||
pub fn chidx(&mut self) -> CHIDX_W<0> {
|
||||
CHIDX_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 31"]
|
||||
#[inline(always)]
|
||||
pub fn en(&mut self) -> EN_W<31> {
|
||||
EN_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 = "Description collection: Subscribe configuration for task SEND\\[n\\]\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 [subscribe_send](index.html) module"]
|
||||
pub struct SUBSCRIBE_SEND_SPEC;
|
||||
impl crate::RegisterSpec for SUBSCRIBE_SEND_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [subscribe_send::R](R) reader structure"]
|
||||
impl crate::Readable for SUBSCRIBE_SEND_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [subscribe_send::W](W) writer structure"]
|
||||
impl crate::Writable for SUBSCRIBE_SEND_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets SUBSCRIBE_SEND[%s]
|
||||
to value 0"]
|
||||
impl crate::Resettable for SUBSCRIBE_SEND_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
+73
@@ -0,0 +1,73 @@
|
||||
#[doc = "Register `TASKS_SEND[%s]` writer"]
|
||||
pub struct W(crate::W<TASKS_SEND_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<TASKS_SEND_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_SEND_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<TASKS_SEND_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Trigger events on channel enabled in SEND_CNF\\[n\\].\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum TASKS_SEND_AW {
|
||||
#[doc = "1: Trigger task"]
|
||||
TRIGGER = 1,
|
||||
}
|
||||
impl From<TASKS_SEND_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: TASKS_SEND_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `TASKS_SEND` writer - Trigger events on channel enabled in SEND_CNF\\[n\\]."]
|
||||
pub type TASKS_SEND_W<'a, const O: u8> =
|
||||
crate::BitWriter<'a, u32, TASKS_SEND_SPEC, TASKS_SEND_AW, O>;
|
||||
impl<'a, const O: u8> TASKS_SEND_W<'a, O> {
|
||||
#[doc = "Trigger task"]
|
||||
#[inline(always)]
|
||||
pub fn trigger(self) -> &'a mut W {
|
||||
self.variant(TASKS_SEND_AW::TRIGGER)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 0 - Trigger events on channel enabled in SEND_CNF\\[n\\]."]
|
||||
#[inline(always)]
|
||||
pub fn tasks_send(&mut self) -> TASKS_SEND_W<0> {
|
||||
TASKS_SEND_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 = "Description collection: Trigger events on channel enabled in SEND_CNF\\[n\\].\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_send](index.html) module"]
|
||||
pub struct TASKS_SEND_SPEC;
|
||||
impl crate::RegisterSpec for TASKS_SEND_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [tasks_send::W](W) writer structure"]
|
||||
impl crate::Writable for TASKS_SEND_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets TASKS_SEND[%s]
|
||||
to value 0"]
|
||||
impl crate::Resettable for TASKS_SEND_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user