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
Vendored
+81
@@ -0,0 +1,81 @@
|
||||
#[doc = "Register `CC[%s]` reader"]
|
||||
pub struct R(crate::R<CC_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<CC_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<CC_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<CC_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `CC[%s]` writer"]
|
||||
pub struct W(crate::W<CC_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<CC_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<CC_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<CC_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE` reader - Compare value"]
|
||||
pub type COMPARE_R = crate::FieldReader<u32, u32>;
|
||||
#[doc = "Field `COMPARE` writer - Compare value"]
|
||||
pub type COMPARE_W<'a, const O: u8> = crate::FieldWriter<'a, u32, CC_SPEC, u32, u32, 24, O>;
|
||||
impl R {
|
||||
#[doc = "Bits 0:23 - Compare value"]
|
||||
#[inline(always)]
|
||||
pub fn compare(&self) -> COMPARE_R {
|
||||
COMPARE_R::new((self.bits & 0x00ff_ffff) as u32)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 0:23 - Compare value"]
|
||||
#[inline(always)]
|
||||
pub fn compare(&mut self) -> COMPARE_W<0> {
|
||||
COMPARE_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: Compare register 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 [cc](index.html) module"]
|
||||
pub struct CC_SPEC;
|
||||
impl crate::RegisterSpec for CC_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [cc::R](R) reader structure"]
|
||||
impl crate::Readable for CC_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [cc::W](W) writer structure"]
|
||||
impl crate::Writable for CC_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets CC[%s]
|
||||
to value 0"]
|
||||
impl crate::Resettable for CC_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
+40
@@ -0,0 +1,40 @@
|
||||
#[doc = "Register `COUNTER` reader"]
|
||||
pub struct R(crate::R<COUNTER_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<COUNTER_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<COUNTER_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<COUNTER_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COUNTER` reader - Counter value"]
|
||||
pub type COUNTER_R = crate::FieldReader<u32, u32>;
|
||||
impl R {
|
||||
#[doc = "Bits 0:23 - Counter value"]
|
||||
#[inline(always)]
|
||||
pub fn counter(&self) -> COUNTER_R {
|
||||
COUNTER_R::new((self.bits & 0x00ff_ffff) as u32)
|
||||
}
|
||||
}
|
||||
#[doc = "Current COUNTER value\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 [counter](index.html) module"]
|
||||
pub struct COUNTER_SPEC;
|
||||
impl crate::RegisterSpec for COUNTER_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [counter::R](R) reader structure"]
|
||||
impl crate::Readable for COUNTER_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`reset()` method sets COUNTER to value 0"]
|
||||
impl crate::Resettable for COUNTER_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
+134
@@ -0,0 +1,134 @@
|
||||
#[doc = "Register `EVENTS_COMPARE[%s]` reader"]
|
||||
pub struct R(crate::R<EVENTS_COMPARE_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<EVENTS_COMPARE_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<EVENTS_COMPARE_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<EVENTS_COMPARE_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `EVENTS_COMPARE[%s]` writer"]
|
||||
pub struct W(crate::W<EVENTS_COMPARE_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<EVENTS_COMPARE_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_COMPARE_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<EVENTS_COMPARE_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `EVENTS_COMPARE` reader - Compare event on CC\\[n\\]
|
||||
match"]
|
||||
pub type EVENTS_COMPARE_R = crate::BitReader<EVENTS_COMPARE_A>;
|
||||
#[doc = "Compare event on CC\\[n\\]
|
||||
match\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum EVENTS_COMPARE_A {
|
||||
#[doc = "0: Event not generated"]
|
||||
NOT_GENERATED = 0,
|
||||
#[doc = "1: Event generated"]
|
||||
GENERATED = 1,
|
||||
}
|
||||
impl From<EVENTS_COMPARE_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: EVENTS_COMPARE_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl EVENTS_COMPARE_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> EVENTS_COMPARE_A {
|
||||
match self.bits {
|
||||
false => EVENTS_COMPARE_A::NOT_GENERATED,
|
||||
true => EVENTS_COMPARE_A::GENERATED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `NOT_GENERATED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_not_generated(&self) -> bool {
|
||||
*self == EVENTS_COMPARE_A::NOT_GENERATED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `GENERATED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_generated(&self) -> bool {
|
||||
*self == EVENTS_COMPARE_A::GENERATED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `EVENTS_COMPARE` writer - Compare event on CC\\[n\\]
|
||||
match"]
|
||||
pub type EVENTS_COMPARE_W<'a, const O: u8> =
|
||||
crate::BitWriter<'a, u32, EVENTS_COMPARE_SPEC, EVENTS_COMPARE_A, O>;
|
||||
impl<'a, const O: u8> EVENTS_COMPARE_W<'a, O> {
|
||||
#[doc = "Event not generated"]
|
||||
#[inline(always)]
|
||||
pub fn not_generated(self) -> &'a mut W {
|
||||
self.variant(EVENTS_COMPARE_A::NOT_GENERATED)
|
||||
}
|
||||
#[doc = "Event generated"]
|
||||
#[inline(always)]
|
||||
pub fn generated(self) -> &'a mut W {
|
||||
self.variant(EVENTS_COMPARE_A::GENERATED)
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bit 0 - Compare event on CC\\[n\\]
|
||||
match"]
|
||||
#[inline(always)]
|
||||
pub fn events_compare(&self) -> EVENTS_COMPARE_R {
|
||||
EVENTS_COMPARE_R::new((self.bits & 1) != 0)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 0 - Compare event on CC\\[n\\]
|
||||
match"]
|
||||
#[inline(always)]
|
||||
pub fn events_compare(&mut self) -> EVENTS_COMPARE_W<0> {
|
||||
EVENTS_COMPARE_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: Compare event on CC\\[n\\]
|
||||
match\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_compare](index.html) module"]
|
||||
pub struct EVENTS_COMPARE_SPEC;
|
||||
impl crate::RegisterSpec for EVENTS_COMPARE_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [events_compare::R](R) reader structure"]
|
||||
impl crate::Readable for EVENTS_COMPARE_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [events_compare::W](W) writer structure"]
|
||||
impl crate::Writable for EVENTS_COMPARE_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets EVENTS_COMPARE[%s]
|
||||
to value 0"]
|
||||
impl crate::Resettable for EVENTS_COMPARE_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
+127
@@ -0,0 +1,127 @@
|
||||
#[doc = "Register `EVENTS_OVRFLW` reader"]
|
||||
pub struct R(crate::R<EVENTS_OVRFLW_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<EVENTS_OVRFLW_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<EVENTS_OVRFLW_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<EVENTS_OVRFLW_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `EVENTS_OVRFLW` writer"]
|
||||
pub struct W(crate::W<EVENTS_OVRFLW_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<EVENTS_OVRFLW_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_OVRFLW_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<EVENTS_OVRFLW_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `EVENTS_OVRFLW` reader - Event on COUNTER overflow"]
|
||||
pub type EVENTS_OVRFLW_R = crate::BitReader<EVENTS_OVRFLW_A>;
|
||||
#[doc = "Event on COUNTER overflow\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum EVENTS_OVRFLW_A {
|
||||
#[doc = "0: Event not generated"]
|
||||
NOT_GENERATED = 0,
|
||||
#[doc = "1: Event generated"]
|
||||
GENERATED = 1,
|
||||
}
|
||||
impl From<EVENTS_OVRFLW_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: EVENTS_OVRFLW_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl EVENTS_OVRFLW_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> EVENTS_OVRFLW_A {
|
||||
match self.bits {
|
||||
false => EVENTS_OVRFLW_A::NOT_GENERATED,
|
||||
true => EVENTS_OVRFLW_A::GENERATED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `NOT_GENERATED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_not_generated(&self) -> bool {
|
||||
*self == EVENTS_OVRFLW_A::NOT_GENERATED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `GENERATED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_generated(&self) -> bool {
|
||||
*self == EVENTS_OVRFLW_A::GENERATED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `EVENTS_OVRFLW` writer - Event on COUNTER overflow"]
|
||||
pub type EVENTS_OVRFLW_W<'a, const O: u8> =
|
||||
crate::BitWriter<'a, u32, EVENTS_OVRFLW_SPEC, EVENTS_OVRFLW_A, O>;
|
||||
impl<'a, const O: u8> EVENTS_OVRFLW_W<'a, O> {
|
||||
#[doc = "Event not generated"]
|
||||
#[inline(always)]
|
||||
pub fn not_generated(self) -> &'a mut W {
|
||||
self.variant(EVENTS_OVRFLW_A::NOT_GENERATED)
|
||||
}
|
||||
#[doc = "Event generated"]
|
||||
#[inline(always)]
|
||||
pub fn generated(self) -> &'a mut W {
|
||||
self.variant(EVENTS_OVRFLW_A::GENERATED)
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bit 0 - Event on COUNTER overflow"]
|
||||
#[inline(always)]
|
||||
pub fn events_ovrflw(&self) -> EVENTS_OVRFLW_R {
|
||||
EVENTS_OVRFLW_R::new((self.bits & 1) != 0)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 0 - Event on COUNTER overflow"]
|
||||
#[inline(always)]
|
||||
pub fn events_ovrflw(&mut self) -> EVENTS_OVRFLW_W<0> {
|
||||
EVENTS_OVRFLW_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 = "Event on COUNTER overflow\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_ovrflw](index.html) module"]
|
||||
pub struct EVENTS_OVRFLW_SPEC;
|
||||
impl crate::RegisterSpec for EVENTS_OVRFLW_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [events_ovrflw::R](R) reader structure"]
|
||||
impl crate::Readable for EVENTS_OVRFLW_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [events_ovrflw::W](W) writer structure"]
|
||||
impl crate::Writable for EVENTS_OVRFLW_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets EVENTS_OVRFLW to value 0"]
|
||||
impl crate::Resettable for EVENTS_OVRFLW_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
+127
@@ -0,0 +1,127 @@
|
||||
#[doc = "Register `EVENTS_TICK` reader"]
|
||||
pub struct R(crate::R<EVENTS_TICK_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<EVENTS_TICK_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<EVENTS_TICK_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<EVENTS_TICK_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `EVENTS_TICK` writer"]
|
||||
pub struct W(crate::W<EVENTS_TICK_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<EVENTS_TICK_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_TICK_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<EVENTS_TICK_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `EVENTS_TICK` reader - Event on COUNTER increment"]
|
||||
pub type EVENTS_TICK_R = crate::BitReader<EVENTS_TICK_A>;
|
||||
#[doc = "Event on COUNTER increment\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum EVENTS_TICK_A {
|
||||
#[doc = "0: Event not generated"]
|
||||
NOT_GENERATED = 0,
|
||||
#[doc = "1: Event generated"]
|
||||
GENERATED = 1,
|
||||
}
|
||||
impl From<EVENTS_TICK_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: EVENTS_TICK_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl EVENTS_TICK_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> EVENTS_TICK_A {
|
||||
match self.bits {
|
||||
false => EVENTS_TICK_A::NOT_GENERATED,
|
||||
true => EVENTS_TICK_A::GENERATED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `NOT_GENERATED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_not_generated(&self) -> bool {
|
||||
*self == EVENTS_TICK_A::NOT_GENERATED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `GENERATED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_generated(&self) -> bool {
|
||||
*self == EVENTS_TICK_A::GENERATED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `EVENTS_TICK` writer - Event on COUNTER increment"]
|
||||
pub type EVENTS_TICK_W<'a, const O: u8> =
|
||||
crate::BitWriter<'a, u32, EVENTS_TICK_SPEC, EVENTS_TICK_A, O>;
|
||||
impl<'a, const O: u8> EVENTS_TICK_W<'a, O> {
|
||||
#[doc = "Event not generated"]
|
||||
#[inline(always)]
|
||||
pub fn not_generated(self) -> &'a mut W {
|
||||
self.variant(EVENTS_TICK_A::NOT_GENERATED)
|
||||
}
|
||||
#[doc = "Event generated"]
|
||||
#[inline(always)]
|
||||
pub fn generated(self) -> &'a mut W {
|
||||
self.variant(EVENTS_TICK_A::GENERATED)
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bit 0 - Event on COUNTER increment"]
|
||||
#[inline(always)]
|
||||
pub fn events_tick(&self) -> EVENTS_TICK_R {
|
||||
EVENTS_TICK_R::new((self.bits & 1) != 0)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 0 - Event on COUNTER increment"]
|
||||
#[inline(always)]
|
||||
pub fn events_tick(&mut self) -> EVENTS_TICK_W<0> {
|
||||
EVENTS_TICK_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 = "Event on COUNTER increment\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_tick](index.html) module"]
|
||||
pub struct EVENTS_TICK_SPEC;
|
||||
impl crate::RegisterSpec for EVENTS_TICK_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [events_tick::R](R) reader structure"]
|
||||
impl crate::Readable for EVENTS_TICK_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [events_tick::W](W) writer structure"]
|
||||
impl crate::Writable for EVENTS_TICK_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets EVENTS_TICK to value 0"]
|
||||
impl crate::Resettable for EVENTS_TICK_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
+426
@@ -0,0 +1,426 @@
|
||||
#[doc = "Register `EVTEN` reader"]
|
||||
pub struct R(crate::R<EVTEN_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<EVTEN_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<EVTEN_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<EVTEN_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `EVTEN` writer"]
|
||||
pub struct W(crate::W<EVTEN_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<EVTEN_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<EVTEN_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<EVTEN_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `TICK` reader - Enable or disable event routing for event TICK"]
|
||||
pub type TICK_R = crate::BitReader<TICK_A>;
|
||||
#[doc = "Enable or disable event routing for event TICK\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum TICK_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Disable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<TICK_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: TICK_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl TICK_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> TICK_A {
|
||||
match self.bits {
|
||||
false => TICK_A::DISABLED,
|
||||
true => TICK_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == TICK_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == TICK_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `TICK` writer - Enable or disable event routing for event TICK"]
|
||||
pub type TICK_W<'a, const O: u8> = crate::BitWriter<'a, u32, EVTEN_SPEC, TICK_A, O>;
|
||||
impl<'a, const O: u8> TICK_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(TICK_A::DISABLED)
|
||||
}
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(TICK_A::ENABLED)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `OVRFLW` reader - Enable or disable event routing for event OVRFLW"]
|
||||
pub type OVRFLW_R = crate::BitReader<OVRFLW_A>;
|
||||
#[doc = "Enable or disable event routing for event OVRFLW\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum OVRFLW_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Disable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<OVRFLW_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: OVRFLW_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl OVRFLW_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> OVRFLW_A {
|
||||
match self.bits {
|
||||
false => OVRFLW_A::DISABLED,
|
||||
true => OVRFLW_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == OVRFLW_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == OVRFLW_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `OVRFLW` writer - Enable or disable event routing for event OVRFLW"]
|
||||
pub type OVRFLW_W<'a, const O: u8> = crate::BitWriter<'a, u32, EVTEN_SPEC, OVRFLW_A, O>;
|
||||
impl<'a, const O: u8> OVRFLW_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(OVRFLW_A::DISABLED)
|
||||
}
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(OVRFLW_A::ENABLED)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE0` reader - Enable or disable event routing for event COMPARE\\[0\\]"]
|
||||
pub type COMPARE0_R = crate::BitReader<COMPARE0_A>;
|
||||
#[doc = "Enable or disable event routing for event COMPARE\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE0_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Disable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<COMPARE0_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE0_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl COMPARE0_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> COMPARE0_A {
|
||||
match self.bits {
|
||||
false => COMPARE0_A::DISABLED,
|
||||
true => COMPARE0_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == COMPARE0_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == COMPARE0_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE0` writer - Enable or disable event routing for event COMPARE\\[0\\]"]
|
||||
pub type COMPARE0_W<'a, const O: u8> = crate::BitWriter<'a, u32, EVTEN_SPEC, COMPARE0_A, O>;
|
||||
impl<'a, const O: u8> COMPARE0_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(COMPARE0_A::DISABLED)
|
||||
}
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(COMPARE0_A::ENABLED)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE1` reader - Enable or disable event routing for event COMPARE\\[1\\]"]
|
||||
pub type COMPARE1_R = crate::BitReader<COMPARE1_A>;
|
||||
#[doc = "Enable or disable event routing for event COMPARE\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE1_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Disable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<COMPARE1_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE1_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl COMPARE1_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> COMPARE1_A {
|
||||
match self.bits {
|
||||
false => COMPARE1_A::DISABLED,
|
||||
true => COMPARE1_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == COMPARE1_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == COMPARE1_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE1` writer - Enable or disable event routing for event COMPARE\\[1\\]"]
|
||||
pub type COMPARE1_W<'a, const O: u8> = crate::BitWriter<'a, u32, EVTEN_SPEC, COMPARE1_A, O>;
|
||||
impl<'a, const O: u8> COMPARE1_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(COMPARE1_A::DISABLED)
|
||||
}
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(COMPARE1_A::ENABLED)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE2` reader - Enable or disable event routing for event COMPARE\\[2\\]"]
|
||||
pub type COMPARE2_R = crate::BitReader<COMPARE2_A>;
|
||||
#[doc = "Enable or disable event routing for event COMPARE\\[2\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE2_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Disable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<COMPARE2_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE2_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl COMPARE2_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> COMPARE2_A {
|
||||
match self.bits {
|
||||
false => COMPARE2_A::DISABLED,
|
||||
true => COMPARE2_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == COMPARE2_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == COMPARE2_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE2` writer - Enable or disable event routing for event COMPARE\\[2\\]"]
|
||||
pub type COMPARE2_W<'a, const O: u8> = crate::BitWriter<'a, u32, EVTEN_SPEC, COMPARE2_A, O>;
|
||||
impl<'a, const O: u8> COMPARE2_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(COMPARE2_A::DISABLED)
|
||||
}
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(COMPARE2_A::ENABLED)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE3` reader - Enable or disable event routing for event COMPARE\\[3\\]"]
|
||||
pub type COMPARE3_R = crate::BitReader<COMPARE3_A>;
|
||||
#[doc = "Enable or disable event routing for event COMPARE\\[3\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE3_A {
|
||||
#[doc = "0: Disable"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Disable"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<COMPARE3_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE3_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl COMPARE3_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> COMPARE3_A {
|
||||
match self.bits {
|
||||
false => COMPARE3_A::DISABLED,
|
||||
true => COMPARE3_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == COMPARE3_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == COMPARE3_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE3` writer - Enable or disable event routing for event COMPARE\\[3\\]"]
|
||||
pub type COMPARE3_W<'a, const O: u8> = crate::BitWriter<'a, u32, EVTEN_SPEC, COMPARE3_A, O>;
|
||||
impl<'a, const O: u8> COMPARE3_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn disabled(self) -> &'a mut W {
|
||||
self.variant(COMPARE3_A::DISABLED)
|
||||
}
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn enabled(self) -> &'a mut W {
|
||||
self.variant(COMPARE3_A::ENABLED)
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bit 0 - Enable or disable event routing for event TICK"]
|
||||
#[inline(always)]
|
||||
pub fn tick(&self) -> TICK_R {
|
||||
TICK_R::new((self.bits & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 1 - Enable or disable event routing for event OVRFLW"]
|
||||
#[inline(always)]
|
||||
pub fn ovrflw(&self) -> OVRFLW_R {
|
||||
OVRFLW_R::new(((self.bits >> 1) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 16 - Enable or disable event routing for event COMPARE\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare0(&self) -> COMPARE0_R {
|
||||
COMPARE0_R::new(((self.bits >> 16) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 17 - Enable or disable event routing for event COMPARE\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare1(&self) -> COMPARE1_R {
|
||||
COMPARE1_R::new(((self.bits >> 17) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 18 - Enable or disable event routing for event COMPARE\\[2\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare2(&self) -> COMPARE2_R {
|
||||
COMPARE2_R::new(((self.bits >> 18) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 19 - Enable or disable event routing for event COMPARE\\[3\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare3(&self) -> COMPARE3_R {
|
||||
COMPARE3_R::new(((self.bits >> 19) & 1) != 0)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 0 - Enable or disable event routing for event TICK"]
|
||||
#[inline(always)]
|
||||
pub fn tick(&mut self) -> TICK_W<0> {
|
||||
TICK_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 1 - Enable or disable event routing for event OVRFLW"]
|
||||
#[inline(always)]
|
||||
pub fn ovrflw(&mut self) -> OVRFLW_W<1> {
|
||||
OVRFLW_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 16 - Enable or disable event routing for event COMPARE\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare0(&mut self) -> COMPARE0_W<16> {
|
||||
COMPARE0_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 17 - Enable or disable event routing for event COMPARE\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare1(&mut self) -> COMPARE1_W<17> {
|
||||
COMPARE1_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 18 - Enable or disable event routing for event COMPARE\\[2\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare2(&mut self) -> COMPARE2_W<18> {
|
||||
COMPARE2_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 19 - Enable or disable event routing for event COMPARE\\[3\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare3(&mut self) -> COMPARE3_W<19> {
|
||||
COMPARE3_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 event routing\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 [evten](index.html) module"]
|
||||
pub struct EVTEN_SPEC;
|
||||
impl crate::RegisterSpec for EVTEN_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [evten::R](R) reader structure"]
|
||||
impl crate::Readable for EVTEN_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [evten::W](W) writer structure"]
|
||||
impl crate::Writable for EVTEN_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets EVTEN to value 0"]
|
||||
impl crate::Resettable for EVTEN_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
+468
@@ -0,0 +1,468 @@
|
||||
#[doc = "Register `EVTENCLR` reader"]
|
||||
pub struct R(crate::R<EVTENCLR_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<EVTENCLR_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<EVTENCLR_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<EVTENCLR_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `EVTENCLR` writer"]
|
||||
pub struct W(crate::W<EVTENCLR_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<EVTENCLR_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<EVTENCLR_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<EVTENCLR_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `TICK` reader - Write '1' to disable event routing for event TICK"]
|
||||
pub type TICK_R = crate::BitReader<TICK_A>;
|
||||
#[doc = "Write '1' to disable event routing for event TICK\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum TICK_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<TICK_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: TICK_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl TICK_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> TICK_A {
|
||||
match self.bits {
|
||||
false => TICK_A::DISABLED,
|
||||
true => TICK_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == TICK_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == TICK_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable event routing for event TICK\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum TICK_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<TICK_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: TICK_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `TICK` writer - Write '1' to disable event routing for event TICK"]
|
||||
pub type TICK_W<'a, const O: u8> = crate::BitWriter<'a, u32, EVTENCLR_SPEC, TICK_AW, O>;
|
||||
impl<'a, const O: u8> TICK_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(TICK_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `OVRFLW` reader - Write '1' to disable event routing for event OVRFLW"]
|
||||
pub type OVRFLW_R = crate::BitReader<OVRFLW_A>;
|
||||
#[doc = "Write '1' to disable event routing for event OVRFLW\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum OVRFLW_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<OVRFLW_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: OVRFLW_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl OVRFLW_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> OVRFLW_A {
|
||||
match self.bits {
|
||||
false => OVRFLW_A::DISABLED,
|
||||
true => OVRFLW_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == OVRFLW_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == OVRFLW_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable event routing for event OVRFLW\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum OVRFLW_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<OVRFLW_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: OVRFLW_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `OVRFLW` writer - Write '1' to disable event routing for event OVRFLW"]
|
||||
pub type OVRFLW_W<'a, const O: u8> = crate::BitWriter<'a, u32, EVTENCLR_SPEC, OVRFLW_AW, O>;
|
||||
impl<'a, const O: u8> OVRFLW_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(OVRFLW_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE0` reader - Write '1' to disable event routing for event COMPARE\\[0\\]"]
|
||||
pub type COMPARE0_R = crate::BitReader<COMPARE0_A>;
|
||||
#[doc = "Write '1' to disable event routing for event COMPARE\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE0_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<COMPARE0_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE0_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl COMPARE0_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> COMPARE0_A {
|
||||
match self.bits {
|
||||
false => COMPARE0_A::DISABLED,
|
||||
true => COMPARE0_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == COMPARE0_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == COMPARE0_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable event routing for event COMPARE\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE0_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<COMPARE0_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE0_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE0` writer - Write '1' to disable event routing for event COMPARE\\[0\\]"]
|
||||
pub type COMPARE0_W<'a, const O: u8> = crate::BitWriter<'a, u32, EVTENCLR_SPEC, COMPARE0_AW, O>;
|
||||
impl<'a, const O: u8> COMPARE0_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(COMPARE0_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE1` reader - Write '1' to disable event routing for event COMPARE\\[1\\]"]
|
||||
pub type COMPARE1_R = crate::BitReader<COMPARE1_A>;
|
||||
#[doc = "Write '1' to disable event routing for event COMPARE\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE1_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<COMPARE1_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE1_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl COMPARE1_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> COMPARE1_A {
|
||||
match self.bits {
|
||||
false => COMPARE1_A::DISABLED,
|
||||
true => COMPARE1_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == COMPARE1_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == COMPARE1_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable event routing for event COMPARE\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE1_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<COMPARE1_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE1_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE1` writer - Write '1' to disable event routing for event COMPARE\\[1\\]"]
|
||||
pub type COMPARE1_W<'a, const O: u8> = crate::BitWriter<'a, u32, EVTENCLR_SPEC, COMPARE1_AW, O>;
|
||||
impl<'a, const O: u8> COMPARE1_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(COMPARE1_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE2` reader - Write '1' to disable event routing for event COMPARE\\[2\\]"]
|
||||
pub type COMPARE2_R = crate::BitReader<COMPARE2_A>;
|
||||
#[doc = "Write '1' to disable event routing for event COMPARE\\[2\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE2_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<COMPARE2_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE2_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl COMPARE2_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> COMPARE2_A {
|
||||
match self.bits {
|
||||
false => COMPARE2_A::DISABLED,
|
||||
true => COMPARE2_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == COMPARE2_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == COMPARE2_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable event routing for event COMPARE\\[2\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE2_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<COMPARE2_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE2_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE2` writer - Write '1' to disable event routing for event COMPARE\\[2\\]"]
|
||||
pub type COMPARE2_W<'a, const O: u8> = crate::BitWriter<'a, u32, EVTENCLR_SPEC, COMPARE2_AW, O>;
|
||||
impl<'a, const O: u8> COMPARE2_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(COMPARE2_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE3` reader - Write '1' to disable event routing for event COMPARE\\[3\\]"]
|
||||
pub type COMPARE3_R = crate::BitReader<COMPARE3_A>;
|
||||
#[doc = "Write '1' to disable event routing for event COMPARE\\[3\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE3_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<COMPARE3_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE3_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl COMPARE3_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> COMPARE3_A {
|
||||
match self.bits {
|
||||
false => COMPARE3_A::DISABLED,
|
||||
true => COMPARE3_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == COMPARE3_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == COMPARE3_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable event routing for event COMPARE\\[3\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE3_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<COMPARE3_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE3_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE3` writer - Write '1' to disable event routing for event COMPARE\\[3\\]"]
|
||||
pub type COMPARE3_W<'a, const O: u8> = crate::BitWriter<'a, u32, EVTENCLR_SPEC, COMPARE3_AW, O>;
|
||||
impl<'a, const O: u8> COMPARE3_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(COMPARE3_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bit 0 - Write '1' to disable event routing for event TICK"]
|
||||
#[inline(always)]
|
||||
pub fn tick(&self) -> TICK_R {
|
||||
TICK_R::new((self.bits & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 1 - Write '1' to disable event routing for event OVRFLW"]
|
||||
#[inline(always)]
|
||||
pub fn ovrflw(&self) -> OVRFLW_R {
|
||||
OVRFLW_R::new(((self.bits >> 1) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 16 - Write '1' to disable event routing for event COMPARE\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare0(&self) -> COMPARE0_R {
|
||||
COMPARE0_R::new(((self.bits >> 16) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 17 - Write '1' to disable event routing for event COMPARE\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare1(&self) -> COMPARE1_R {
|
||||
COMPARE1_R::new(((self.bits >> 17) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 18 - Write '1' to disable event routing for event COMPARE\\[2\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare2(&self) -> COMPARE2_R {
|
||||
COMPARE2_R::new(((self.bits >> 18) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 19 - Write '1' to disable event routing for event COMPARE\\[3\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare3(&self) -> COMPARE3_R {
|
||||
COMPARE3_R::new(((self.bits >> 19) & 1) != 0)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 0 - Write '1' to disable event routing for event TICK"]
|
||||
#[inline(always)]
|
||||
pub fn tick(&mut self) -> TICK_W<0> {
|
||||
TICK_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 1 - Write '1' to disable event routing for event OVRFLW"]
|
||||
#[inline(always)]
|
||||
pub fn ovrflw(&mut self) -> OVRFLW_W<1> {
|
||||
OVRFLW_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 16 - Write '1' to disable event routing for event COMPARE\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare0(&mut self) -> COMPARE0_W<16> {
|
||||
COMPARE0_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 17 - Write '1' to disable event routing for event COMPARE\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare1(&mut self) -> COMPARE1_W<17> {
|
||||
COMPARE1_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 18 - Write '1' to disable event routing for event COMPARE\\[2\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare2(&mut self) -> COMPARE2_W<18> {
|
||||
COMPARE2_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 19 - Write '1' to disable event routing for event COMPARE\\[3\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare3(&mut self) -> COMPARE3_W<19> {
|
||||
COMPARE3_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 event routing\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 [evtenclr](index.html) module"]
|
||||
pub struct EVTENCLR_SPEC;
|
||||
impl crate::RegisterSpec for EVTENCLR_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [evtenclr::R](R) reader structure"]
|
||||
impl crate::Readable for EVTENCLR_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [evtenclr::W](W) writer structure"]
|
||||
impl crate::Writable for EVTENCLR_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets EVTENCLR to value 0"]
|
||||
impl crate::Resettable for EVTENCLR_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
+468
@@ -0,0 +1,468 @@
|
||||
#[doc = "Register `EVTENSET` reader"]
|
||||
pub struct R(crate::R<EVTENSET_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<EVTENSET_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<EVTENSET_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<EVTENSET_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `EVTENSET` writer"]
|
||||
pub struct W(crate::W<EVTENSET_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<EVTENSET_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<EVTENSET_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<EVTENSET_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `TICK` reader - Write '1' to enable event routing for event TICK"]
|
||||
pub type TICK_R = crate::BitReader<TICK_A>;
|
||||
#[doc = "Write '1' to enable event routing for event TICK\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum TICK_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<TICK_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: TICK_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl TICK_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> TICK_A {
|
||||
match self.bits {
|
||||
false => TICK_A::DISABLED,
|
||||
true => TICK_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == TICK_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == TICK_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable event routing for event TICK\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum TICK_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<TICK_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: TICK_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `TICK` writer - Write '1' to enable event routing for event TICK"]
|
||||
pub type TICK_W<'a, const O: u8> = crate::BitWriter<'a, u32, EVTENSET_SPEC, TICK_AW, O>;
|
||||
impl<'a, const O: u8> TICK_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(TICK_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `OVRFLW` reader - Write '1' to enable event routing for event OVRFLW"]
|
||||
pub type OVRFLW_R = crate::BitReader<OVRFLW_A>;
|
||||
#[doc = "Write '1' to enable event routing for event OVRFLW\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum OVRFLW_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<OVRFLW_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: OVRFLW_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl OVRFLW_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> OVRFLW_A {
|
||||
match self.bits {
|
||||
false => OVRFLW_A::DISABLED,
|
||||
true => OVRFLW_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == OVRFLW_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == OVRFLW_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable event routing for event OVRFLW\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum OVRFLW_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<OVRFLW_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: OVRFLW_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `OVRFLW` writer - Write '1' to enable event routing for event OVRFLW"]
|
||||
pub type OVRFLW_W<'a, const O: u8> = crate::BitWriter<'a, u32, EVTENSET_SPEC, OVRFLW_AW, O>;
|
||||
impl<'a, const O: u8> OVRFLW_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(OVRFLW_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE0` reader - Write '1' to enable event routing for event COMPARE\\[0\\]"]
|
||||
pub type COMPARE0_R = crate::BitReader<COMPARE0_A>;
|
||||
#[doc = "Write '1' to enable event routing for event COMPARE\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE0_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<COMPARE0_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE0_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl COMPARE0_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> COMPARE0_A {
|
||||
match self.bits {
|
||||
false => COMPARE0_A::DISABLED,
|
||||
true => COMPARE0_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == COMPARE0_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == COMPARE0_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable event routing for event COMPARE\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE0_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<COMPARE0_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE0_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE0` writer - Write '1' to enable event routing for event COMPARE\\[0\\]"]
|
||||
pub type COMPARE0_W<'a, const O: u8> = crate::BitWriter<'a, u32, EVTENSET_SPEC, COMPARE0_AW, O>;
|
||||
impl<'a, const O: u8> COMPARE0_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(COMPARE0_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE1` reader - Write '1' to enable event routing for event COMPARE\\[1\\]"]
|
||||
pub type COMPARE1_R = crate::BitReader<COMPARE1_A>;
|
||||
#[doc = "Write '1' to enable event routing for event COMPARE\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE1_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<COMPARE1_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE1_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl COMPARE1_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> COMPARE1_A {
|
||||
match self.bits {
|
||||
false => COMPARE1_A::DISABLED,
|
||||
true => COMPARE1_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == COMPARE1_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == COMPARE1_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable event routing for event COMPARE\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE1_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<COMPARE1_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE1_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE1` writer - Write '1' to enable event routing for event COMPARE\\[1\\]"]
|
||||
pub type COMPARE1_W<'a, const O: u8> = crate::BitWriter<'a, u32, EVTENSET_SPEC, COMPARE1_AW, O>;
|
||||
impl<'a, const O: u8> COMPARE1_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(COMPARE1_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE2` reader - Write '1' to enable event routing for event COMPARE\\[2\\]"]
|
||||
pub type COMPARE2_R = crate::BitReader<COMPARE2_A>;
|
||||
#[doc = "Write '1' to enable event routing for event COMPARE\\[2\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE2_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<COMPARE2_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE2_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl COMPARE2_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> COMPARE2_A {
|
||||
match self.bits {
|
||||
false => COMPARE2_A::DISABLED,
|
||||
true => COMPARE2_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == COMPARE2_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == COMPARE2_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable event routing for event COMPARE\\[2\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE2_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<COMPARE2_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE2_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE2` writer - Write '1' to enable event routing for event COMPARE\\[2\\]"]
|
||||
pub type COMPARE2_W<'a, const O: u8> = crate::BitWriter<'a, u32, EVTENSET_SPEC, COMPARE2_AW, O>;
|
||||
impl<'a, const O: u8> COMPARE2_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(COMPARE2_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE3` reader - Write '1' to enable event routing for event COMPARE\\[3\\]"]
|
||||
pub type COMPARE3_R = crate::BitReader<COMPARE3_A>;
|
||||
#[doc = "Write '1' to enable event routing for event COMPARE\\[3\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE3_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<COMPARE3_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE3_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl COMPARE3_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> COMPARE3_A {
|
||||
match self.bits {
|
||||
false => COMPARE3_A::DISABLED,
|
||||
true => COMPARE3_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == COMPARE3_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == COMPARE3_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable event routing for event COMPARE\\[3\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE3_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<COMPARE3_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE3_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE3` writer - Write '1' to enable event routing for event COMPARE\\[3\\]"]
|
||||
pub type COMPARE3_W<'a, const O: u8> = crate::BitWriter<'a, u32, EVTENSET_SPEC, COMPARE3_AW, O>;
|
||||
impl<'a, const O: u8> COMPARE3_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(COMPARE3_AW::SET)
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bit 0 - Write '1' to enable event routing for event TICK"]
|
||||
#[inline(always)]
|
||||
pub fn tick(&self) -> TICK_R {
|
||||
TICK_R::new((self.bits & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 1 - Write '1' to enable event routing for event OVRFLW"]
|
||||
#[inline(always)]
|
||||
pub fn ovrflw(&self) -> OVRFLW_R {
|
||||
OVRFLW_R::new(((self.bits >> 1) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 16 - Write '1' to enable event routing for event COMPARE\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare0(&self) -> COMPARE0_R {
|
||||
COMPARE0_R::new(((self.bits >> 16) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 17 - Write '1' to enable event routing for event COMPARE\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare1(&self) -> COMPARE1_R {
|
||||
COMPARE1_R::new(((self.bits >> 17) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 18 - Write '1' to enable event routing for event COMPARE\\[2\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare2(&self) -> COMPARE2_R {
|
||||
COMPARE2_R::new(((self.bits >> 18) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 19 - Write '1' to enable event routing for event COMPARE\\[3\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare3(&self) -> COMPARE3_R {
|
||||
COMPARE3_R::new(((self.bits >> 19) & 1) != 0)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 0 - Write '1' to enable event routing for event TICK"]
|
||||
#[inline(always)]
|
||||
pub fn tick(&mut self) -> TICK_W<0> {
|
||||
TICK_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 1 - Write '1' to enable event routing for event OVRFLW"]
|
||||
#[inline(always)]
|
||||
pub fn ovrflw(&mut self) -> OVRFLW_W<1> {
|
||||
OVRFLW_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 16 - Write '1' to enable event routing for event COMPARE\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare0(&mut self) -> COMPARE0_W<16> {
|
||||
COMPARE0_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 17 - Write '1' to enable event routing for event COMPARE\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare1(&mut self) -> COMPARE1_W<17> {
|
||||
COMPARE1_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 18 - Write '1' to enable event routing for event COMPARE\\[2\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare2(&mut self) -> COMPARE2_W<18> {
|
||||
COMPARE2_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 19 - Write '1' to enable event routing for event COMPARE\\[3\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare3(&mut self) -> COMPARE3_W<19> {
|
||||
COMPARE3_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 event routing\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 [evtenset](index.html) module"]
|
||||
pub struct EVTENSET_SPEC;
|
||||
impl crate::RegisterSpec for EVTENSET_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [evtenset::R](R) reader structure"]
|
||||
impl crate::Readable for EVTENSET_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [evtenset::W](W) writer structure"]
|
||||
impl crate::Writable for EVTENSET_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets EVTENSET to value 0"]
|
||||
impl crate::Resettable for EVTENSET_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
+468
@@ -0,0 +1,468 @@
|
||||
#[doc = "Register `INTENCLR` reader"]
|
||||
pub struct R(crate::R<INTENCLR_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<INTENCLR_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<INTENCLR_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<INTENCLR_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `INTENCLR` writer"]
|
||||
pub struct W(crate::W<INTENCLR_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<INTENCLR_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<INTENCLR_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<INTENCLR_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `TICK` reader - Write '1' to disable interrupt for event TICK"]
|
||||
pub type TICK_R = crate::BitReader<TICK_A>;
|
||||
#[doc = "Write '1' to disable interrupt for event TICK\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum TICK_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<TICK_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: TICK_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl TICK_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> TICK_A {
|
||||
match self.bits {
|
||||
false => TICK_A::DISABLED,
|
||||
true => TICK_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == TICK_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == TICK_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable interrupt for event TICK\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum TICK_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<TICK_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: TICK_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `TICK` writer - Write '1' to disable interrupt for event TICK"]
|
||||
pub type TICK_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, TICK_AW, O>;
|
||||
impl<'a, const O: u8> TICK_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(TICK_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `OVRFLW` reader - Write '1' to disable interrupt for event OVRFLW"]
|
||||
pub type OVRFLW_R = crate::BitReader<OVRFLW_A>;
|
||||
#[doc = "Write '1' to disable interrupt for event OVRFLW\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum OVRFLW_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<OVRFLW_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: OVRFLW_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl OVRFLW_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> OVRFLW_A {
|
||||
match self.bits {
|
||||
false => OVRFLW_A::DISABLED,
|
||||
true => OVRFLW_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == OVRFLW_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == OVRFLW_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable interrupt for event OVRFLW\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum OVRFLW_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<OVRFLW_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: OVRFLW_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `OVRFLW` writer - Write '1' to disable interrupt for event OVRFLW"]
|
||||
pub type OVRFLW_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, OVRFLW_AW, O>;
|
||||
impl<'a, const O: u8> OVRFLW_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(OVRFLW_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE0` reader - Write '1' to disable interrupt for event COMPARE\\[0\\]"]
|
||||
pub type COMPARE0_R = crate::BitReader<COMPARE0_A>;
|
||||
#[doc = "Write '1' to disable interrupt for event COMPARE\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE0_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<COMPARE0_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE0_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl COMPARE0_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> COMPARE0_A {
|
||||
match self.bits {
|
||||
false => COMPARE0_A::DISABLED,
|
||||
true => COMPARE0_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == COMPARE0_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == COMPARE0_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable interrupt for event COMPARE\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE0_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<COMPARE0_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE0_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE0` writer - Write '1' to disable interrupt for event COMPARE\\[0\\]"]
|
||||
pub type COMPARE0_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, COMPARE0_AW, O>;
|
||||
impl<'a, const O: u8> COMPARE0_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(COMPARE0_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE1` reader - Write '1' to disable interrupt for event COMPARE\\[1\\]"]
|
||||
pub type COMPARE1_R = crate::BitReader<COMPARE1_A>;
|
||||
#[doc = "Write '1' to disable interrupt for event COMPARE\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE1_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<COMPARE1_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE1_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl COMPARE1_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> COMPARE1_A {
|
||||
match self.bits {
|
||||
false => COMPARE1_A::DISABLED,
|
||||
true => COMPARE1_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == COMPARE1_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == COMPARE1_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable interrupt for event COMPARE\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE1_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<COMPARE1_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE1_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE1` writer - Write '1' to disable interrupt for event COMPARE\\[1\\]"]
|
||||
pub type COMPARE1_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, COMPARE1_AW, O>;
|
||||
impl<'a, const O: u8> COMPARE1_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(COMPARE1_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE2` reader - Write '1' to disable interrupt for event COMPARE\\[2\\]"]
|
||||
pub type COMPARE2_R = crate::BitReader<COMPARE2_A>;
|
||||
#[doc = "Write '1' to disable interrupt for event COMPARE\\[2\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE2_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<COMPARE2_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE2_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl COMPARE2_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> COMPARE2_A {
|
||||
match self.bits {
|
||||
false => COMPARE2_A::DISABLED,
|
||||
true => COMPARE2_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == COMPARE2_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == COMPARE2_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable interrupt for event COMPARE\\[2\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE2_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<COMPARE2_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE2_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE2` writer - Write '1' to disable interrupt for event COMPARE\\[2\\]"]
|
||||
pub type COMPARE2_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, COMPARE2_AW, O>;
|
||||
impl<'a, const O: u8> COMPARE2_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(COMPARE2_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE3` reader - Write '1' to disable interrupt for event COMPARE\\[3\\]"]
|
||||
pub type COMPARE3_R = crate::BitReader<COMPARE3_A>;
|
||||
#[doc = "Write '1' to disable interrupt for event COMPARE\\[3\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE3_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<COMPARE3_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE3_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl COMPARE3_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> COMPARE3_A {
|
||||
match self.bits {
|
||||
false => COMPARE3_A::DISABLED,
|
||||
true => COMPARE3_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == COMPARE3_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == COMPARE3_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to disable interrupt for event COMPARE\\[3\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE3_AW {
|
||||
#[doc = "1: Disable"]
|
||||
CLEAR = 1,
|
||||
}
|
||||
impl From<COMPARE3_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE3_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE3` writer - Write '1' to disable interrupt for event COMPARE\\[3\\]"]
|
||||
pub type COMPARE3_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, COMPARE3_AW, O>;
|
||||
impl<'a, const O: u8> COMPARE3_W<'a, O> {
|
||||
#[doc = "Disable"]
|
||||
#[inline(always)]
|
||||
pub fn clear(self) -> &'a mut W {
|
||||
self.variant(COMPARE3_AW::CLEAR)
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bit 0 - Write '1' to disable interrupt for event TICK"]
|
||||
#[inline(always)]
|
||||
pub fn tick(&self) -> TICK_R {
|
||||
TICK_R::new((self.bits & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 1 - Write '1' to disable interrupt for event OVRFLW"]
|
||||
#[inline(always)]
|
||||
pub fn ovrflw(&self) -> OVRFLW_R {
|
||||
OVRFLW_R::new(((self.bits >> 1) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 16 - Write '1' to disable interrupt for event COMPARE\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare0(&self) -> COMPARE0_R {
|
||||
COMPARE0_R::new(((self.bits >> 16) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 17 - Write '1' to disable interrupt for event COMPARE\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare1(&self) -> COMPARE1_R {
|
||||
COMPARE1_R::new(((self.bits >> 17) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 18 - Write '1' to disable interrupt for event COMPARE\\[2\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare2(&self) -> COMPARE2_R {
|
||||
COMPARE2_R::new(((self.bits >> 18) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 19 - Write '1' to disable interrupt for event COMPARE\\[3\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare3(&self) -> COMPARE3_R {
|
||||
COMPARE3_R::new(((self.bits >> 19) & 1) != 0)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 0 - Write '1' to disable interrupt for event TICK"]
|
||||
#[inline(always)]
|
||||
pub fn tick(&mut self) -> TICK_W<0> {
|
||||
TICK_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 1 - Write '1' to disable interrupt for event OVRFLW"]
|
||||
#[inline(always)]
|
||||
pub fn ovrflw(&mut self) -> OVRFLW_W<1> {
|
||||
OVRFLW_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 16 - Write '1' to disable interrupt for event COMPARE\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare0(&mut self) -> COMPARE0_W<16> {
|
||||
COMPARE0_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 17 - Write '1' to disable interrupt for event COMPARE\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare1(&mut self) -> COMPARE1_W<17> {
|
||||
COMPARE1_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 18 - Write '1' to disable interrupt for event COMPARE\\[2\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare2(&mut self) -> COMPARE2_W<18> {
|
||||
COMPARE2_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 19 - Write '1' to disable interrupt for event COMPARE\\[3\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare3(&mut self) -> COMPARE3_W<19> {
|
||||
COMPARE3_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
|
||||
}
|
||||
}
|
||||
+468
@@ -0,0 +1,468 @@
|
||||
#[doc = "Register `INTENSET` reader"]
|
||||
pub struct R(crate::R<INTENSET_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<INTENSET_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<INTENSET_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<INTENSET_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `INTENSET` writer"]
|
||||
pub struct W(crate::W<INTENSET_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<INTENSET_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<INTENSET_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<INTENSET_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `TICK` reader - Write '1' to enable interrupt for event TICK"]
|
||||
pub type TICK_R = crate::BitReader<TICK_A>;
|
||||
#[doc = "Write '1' to enable interrupt for event TICK\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum TICK_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<TICK_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: TICK_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl TICK_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> TICK_A {
|
||||
match self.bits {
|
||||
false => TICK_A::DISABLED,
|
||||
true => TICK_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == TICK_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == TICK_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable interrupt for event TICK\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum TICK_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<TICK_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: TICK_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `TICK` writer - Write '1' to enable interrupt for event TICK"]
|
||||
pub type TICK_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, TICK_AW, O>;
|
||||
impl<'a, const O: u8> TICK_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(TICK_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `OVRFLW` reader - Write '1' to enable interrupt for event OVRFLW"]
|
||||
pub type OVRFLW_R = crate::BitReader<OVRFLW_A>;
|
||||
#[doc = "Write '1' to enable interrupt for event OVRFLW\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum OVRFLW_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<OVRFLW_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: OVRFLW_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl OVRFLW_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> OVRFLW_A {
|
||||
match self.bits {
|
||||
false => OVRFLW_A::DISABLED,
|
||||
true => OVRFLW_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == OVRFLW_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == OVRFLW_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable interrupt for event OVRFLW\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum OVRFLW_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<OVRFLW_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: OVRFLW_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `OVRFLW` writer - Write '1' to enable interrupt for event OVRFLW"]
|
||||
pub type OVRFLW_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, OVRFLW_AW, O>;
|
||||
impl<'a, const O: u8> OVRFLW_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(OVRFLW_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE0` reader - Write '1' to enable interrupt for event COMPARE\\[0\\]"]
|
||||
pub type COMPARE0_R = crate::BitReader<COMPARE0_A>;
|
||||
#[doc = "Write '1' to enable interrupt for event COMPARE\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE0_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<COMPARE0_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE0_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl COMPARE0_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> COMPARE0_A {
|
||||
match self.bits {
|
||||
false => COMPARE0_A::DISABLED,
|
||||
true => COMPARE0_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == COMPARE0_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == COMPARE0_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable interrupt for event COMPARE\\[0\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE0_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<COMPARE0_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE0_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE0` writer - Write '1' to enable interrupt for event COMPARE\\[0\\]"]
|
||||
pub type COMPARE0_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, COMPARE0_AW, O>;
|
||||
impl<'a, const O: u8> COMPARE0_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(COMPARE0_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE1` reader - Write '1' to enable interrupt for event COMPARE\\[1\\]"]
|
||||
pub type COMPARE1_R = crate::BitReader<COMPARE1_A>;
|
||||
#[doc = "Write '1' to enable interrupt for event COMPARE\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE1_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<COMPARE1_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE1_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl COMPARE1_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> COMPARE1_A {
|
||||
match self.bits {
|
||||
false => COMPARE1_A::DISABLED,
|
||||
true => COMPARE1_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == COMPARE1_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == COMPARE1_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable interrupt for event COMPARE\\[1\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE1_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<COMPARE1_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE1_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE1` writer - Write '1' to enable interrupt for event COMPARE\\[1\\]"]
|
||||
pub type COMPARE1_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, COMPARE1_AW, O>;
|
||||
impl<'a, const O: u8> COMPARE1_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(COMPARE1_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE2` reader - Write '1' to enable interrupt for event COMPARE\\[2\\]"]
|
||||
pub type COMPARE2_R = crate::BitReader<COMPARE2_A>;
|
||||
#[doc = "Write '1' to enable interrupt for event COMPARE\\[2\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE2_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<COMPARE2_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE2_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl COMPARE2_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> COMPARE2_A {
|
||||
match self.bits {
|
||||
false => COMPARE2_A::DISABLED,
|
||||
true => COMPARE2_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == COMPARE2_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == COMPARE2_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable interrupt for event COMPARE\\[2\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE2_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<COMPARE2_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE2_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE2` writer - Write '1' to enable interrupt for event COMPARE\\[2\\]"]
|
||||
pub type COMPARE2_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, COMPARE2_AW, O>;
|
||||
impl<'a, const O: u8> COMPARE2_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(COMPARE2_AW::SET)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE3` reader - Write '1' to enable interrupt for event COMPARE\\[3\\]"]
|
||||
pub type COMPARE3_R = crate::BitReader<COMPARE3_A>;
|
||||
#[doc = "Write '1' to enable interrupt for event COMPARE\\[3\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE3_A {
|
||||
#[doc = "0: Read: Disabled"]
|
||||
DISABLED = 0,
|
||||
#[doc = "1: Read: Enabled"]
|
||||
ENABLED = 1,
|
||||
}
|
||||
impl From<COMPARE3_A> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE3_A) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
impl COMPARE3_R {
|
||||
#[doc = "Get enumerated values variant"]
|
||||
#[inline(always)]
|
||||
pub fn variant(&self) -> COMPARE3_A {
|
||||
match self.bits {
|
||||
false => COMPARE3_A::DISABLED,
|
||||
true => COMPARE3_A::ENABLED,
|
||||
}
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `DISABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_disabled(&self) -> bool {
|
||||
*self == COMPARE3_A::DISABLED
|
||||
}
|
||||
#[doc = "Checks if the value of the field is `ENABLED`"]
|
||||
#[inline(always)]
|
||||
pub fn is_enabled(&self) -> bool {
|
||||
*self == COMPARE3_A::ENABLED
|
||||
}
|
||||
}
|
||||
#[doc = "Write '1' to enable interrupt for event COMPARE\\[3\\]\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum COMPARE3_AW {
|
||||
#[doc = "1: Enable"]
|
||||
SET = 1,
|
||||
}
|
||||
impl From<COMPARE3_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: COMPARE3_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `COMPARE3` writer - Write '1' to enable interrupt for event COMPARE\\[3\\]"]
|
||||
pub type COMPARE3_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENSET_SPEC, COMPARE3_AW, O>;
|
||||
impl<'a, const O: u8> COMPARE3_W<'a, O> {
|
||||
#[doc = "Enable"]
|
||||
#[inline(always)]
|
||||
pub fn set(self) -> &'a mut W {
|
||||
self.variant(COMPARE3_AW::SET)
|
||||
}
|
||||
}
|
||||
impl R {
|
||||
#[doc = "Bit 0 - Write '1' to enable interrupt for event TICK"]
|
||||
#[inline(always)]
|
||||
pub fn tick(&self) -> TICK_R {
|
||||
TICK_R::new((self.bits & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 1 - Write '1' to enable interrupt for event OVRFLW"]
|
||||
#[inline(always)]
|
||||
pub fn ovrflw(&self) -> OVRFLW_R {
|
||||
OVRFLW_R::new(((self.bits >> 1) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 16 - Write '1' to enable interrupt for event COMPARE\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare0(&self) -> COMPARE0_R {
|
||||
COMPARE0_R::new(((self.bits >> 16) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 17 - Write '1' to enable interrupt for event COMPARE\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare1(&self) -> COMPARE1_R {
|
||||
COMPARE1_R::new(((self.bits >> 17) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 18 - Write '1' to enable interrupt for event COMPARE\\[2\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare2(&self) -> COMPARE2_R {
|
||||
COMPARE2_R::new(((self.bits >> 18) & 1) != 0)
|
||||
}
|
||||
#[doc = "Bit 19 - Write '1' to enable interrupt for event COMPARE\\[3\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare3(&self) -> COMPARE3_R {
|
||||
COMPARE3_R::new(((self.bits >> 19) & 1) != 0)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 0 - Write '1' to enable interrupt for event TICK"]
|
||||
#[inline(always)]
|
||||
pub fn tick(&mut self) -> TICK_W<0> {
|
||||
TICK_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 1 - Write '1' to enable interrupt for event OVRFLW"]
|
||||
#[inline(always)]
|
||||
pub fn ovrflw(&mut self) -> OVRFLW_W<1> {
|
||||
OVRFLW_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 16 - Write '1' to enable interrupt for event COMPARE\\[0\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare0(&mut self) -> COMPARE0_W<16> {
|
||||
COMPARE0_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 17 - Write '1' to enable interrupt for event COMPARE\\[1\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare1(&mut self) -> COMPARE1_W<17> {
|
||||
COMPARE1_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 18 - Write '1' to enable interrupt for event COMPARE\\[2\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare2(&mut self) -> COMPARE2_W<18> {
|
||||
COMPARE2_W::new(self)
|
||||
}
|
||||
#[doc = "Bit 19 - Write '1' to enable interrupt for event COMPARE\\[3\\]"]
|
||||
#[inline(always)]
|
||||
pub fn compare3(&mut self) -> COMPARE3_W<19> {
|
||||
COMPARE3_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
|
||||
}
|
||||
}
|
||||
+81
@@ -0,0 +1,81 @@
|
||||
#[doc = "Register `PRESCALER` reader"]
|
||||
pub struct R(crate::R<PRESCALER_SPEC>);
|
||||
impl core::ops::Deref for R {
|
||||
type Target = crate::R<PRESCALER_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::R<PRESCALER_SPEC>> for R {
|
||||
#[inline(always)]
|
||||
fn from(reader: crate::R<PRESCALER_SPEC>) -> Self {
|
||||
R(reader)
|
||||
}
|
||||
}
|
||||
#[doc = "Register `PRESCALER` writer"]
|
||||
pub struct W(crate::W<PRESCALER_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<PRESCALER_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<PRESCALER_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<PRESCALER_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Field `PRESCALER` reader - Prescaler value"]
|
||||
pub type PRESCALER_R = crate::FieldReader<u16, u16>;
|
||||
#[doc = "Field `PRESCALER` writer - Prescaler value"]
|
||||
pub type PRESCALER_W<'a, const O: u8> =
|
||||
crate::FieldWriter<'a, u32, PRESCALER_SPEC, u16, u16, 12, O>;
|
||||
impl R {
|
||||
#[doc = "Bits 0:11 - Prescaler value"]
|
||||
#[inline(always)]
|
||||
pub fn prescaler(&self) -> PRESCALER_R {
|
||||
PRESCALER_R::new((self.bits & 0x0fff) as u16)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bits 0:11 - Prescaler value"]
|
||||
#[inline(always)]
|
||||
pub fn prescaler(&mut self) -> PRESCALER_W<0> {
|
||||
PRESCALER_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 = "12 bit prescaler for COUNTER frequency (32768/(PRESCALER+1)).Must be written when RTC is stopped\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [prescaler](index.html) module"]
|
||||
pub struct PRESCALER_SPEC;
|
||||
impl crate::RegisterSpec for PRESCALER_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`read()` method returns [prescaler::R](R) reader structure"]
|
||||
impl crate::Readable for PRESCALER_SPEC {
|
||||
type Reader = R;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [prescaler::W](W) writer structure"]
|
||||
impl crate::Writable for PRESCALER_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets PRESCALER to value 0"]
|
||||
impl crate::Resettable for PRESCALER_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
+72
@@ -0,0 +1,72 @@
|
||||
#[doc = "Register `TASKS_CLEAR` writer"]
|
||||
pub struct W(crate::W<TASKS_CLEAR_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<TASKS_CLEAR_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_CLEAR_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<TASKS_CLEAR_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Clear RTC COUNTER\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum TASKS_CLEAR_AW {
|
||||
#[doc = "1: Trigger task"]
|
||||
TRIGGER = 1,
|
||||
}
|
||||
impl From<TASKS_CLEAR_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: TASKS_CLEAR_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `TASKS_CLEAR` writer - Clear RTC COUNTER"]
|
||||
pub type TASKS_CLEAR_W<'a, const O: u8> =
|
||||
crate::BitWriter<'a, u32, TASKS_CLEAR_SPEC, TASKS_CLEAR_AW, O>;
|
||||
impl<'a, const O: u8> TASKS_CLEAR_W<'a, O> {
|
||||
#[doc = "Trigger task"]
|
||||
#[inline(always)]
|
||||
pub fn trigger(self) -> &'a mut W {
|
||||
self.variant(TASKS_CLEAR_AW::TRIGGER)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 0 - Clear RTC COUNTER"]
|
||||
#[inline(always)]
|
||||
pub fn tasks_clear(&mut self) -> TASKS_CLEAR_W<0> {
|
||||
TASKS_CLEAR_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 = "Clear RTC COUNTER\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_clear](index.html) module"]
|
||||
pub struct TASKS_CLEAR_SPEC;
|
||||
impl crate::RegisterSpec for TASKS_CLEAR_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [tasks_clear::W](W) writer structure"]
|
||||
impl crate::Writable for TASKS_CLEAR_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets TASKS_CLEAR to value 0"]
|
||||
impl crate::Resettable for TASKS_CLEAR_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
+72
@@ -0,0 +1,72 @@
|
||||
#[doc = "Register `TASKS_START` writer"]
|
||||
pub struct W(crate::W<TASKS_START_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<TASKS_START_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_START_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<TASKS_START_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Start RTC COUNTER\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum TASKS_START_AW {
|
||||
#[doc = "1: Trigger task"]
|
||||
TRIGGER = 1,
|
||||
}
|
||||
impl From<TASKS_START_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: TASKS_START_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `TASKS_START` writer - Start RTC COUNTER"]
|
||||
pub type TASKS_START_W<'a, const O: u8> =
|
||||
crate::BitWriter<'a, u32, TASKS_START_SPEC, TASKS_START_AW, O>;
|
||||
impl<'a, const O: u8> TASKS_START_W<'a, O> {
|
||||
#[doc = "Trigger task"]
|
||||
#[inline(always)]
|
||||
pub fn trigger(self) -> &'a mut W {
|
||||
self.variant(TASKS_START_AW::TRIGGER)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 0 - Start RTC COUNTER"]
|
||||
#[inline(always)]
|
||||
pub fn tasks_start(&mut self) -> TASKS_START_W<0> {
|
||||
TASKS_START_W::new(self)
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "Start RTC COUNTER\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_start](index.html) module"]
|
||||
pub struct TASKS_START_SPEC;
|
||||
impl crate::RegisterSpec for TASKS_START_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [tasks_start::W](W) writer structure"]
|
||||
impl crate::Writable for TASKS_START_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets TASKS_START to value 0"]
|
||||
impl crate::Resettable for TASKS_START_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
+72
@@ -0,0 +1,72 @@
|
||||
#[doc = "Register `TASKS_STOP` writer"]
|
||||
pub struct W(crate::W<TASKS_STOP_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<TASKS_STOP_SPEC>;
|
||||
#[inline(always)]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
impl core::ops::DerefMut for W {
|
||||
#[inline(always)]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
impl From<crate::W<TASKS_STOP_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<TASKS_STOP_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Stop RTC COUNTER\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum TASKS_STOP_AW {
|
||||
#[doc = "1: Trigger task"]
|
||||
TRIGGER = 1,
|
||||
}
|
||||
impl From<TASKS_STOP_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: TASKS_STOP_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `TASKS_STOP` writer - Stop RTC COUNTER"]
|
||||
pub type TASKS_STOP_W<'a, const O: u8> =
|
||||
crate::BitWriter<'a, u32, TASKS_STOP_SPEC, TASKS_STOP_AW, O>;
|
||||
impl<'a, const O: u8> TASKS_STOP_W<'a, O> {
|
||||
#[doc = "Trigger task"]
|
||||
#[inline(always)]
|
||||
pub fn trigger(self) -> &'a mut W {
|
||||
self.variant(TASKS_STOP_AW::TRIGGER)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 0 - Stop RTC COUNTER"]
|
||||
#[inline(always)]
|
||||
pub fn tasks_stop(&mut self) -> TASKS_STOP_W<0> {
|
||||
TASKS_STOP_W::new(self)
|
||||
}
|
||||
#[doc = "Writes raw bits to the register."]
|
||||
#[inline(always)]
|
||||
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
||||
self.0.bits(bits);
|
||||
self
|
||||
}
|
||||
}
|
||||
#[doc = "Stop RTC COUNTER\n\nThis register you can [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [tasks_stop](index.html) module"]
|
||||
pub struct TASKS_STOP_SPEC;
|
||||
impl crate::RegisterSpec for TASKS_STOP_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [tasks_stop::W](W) writer structure"]
|
||||
impl crate::Writable for TASKS_STOP_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets TASKS_STOP to value 0"]
|
||||
impl crate::Resettable for TASKS_STOP_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
#[doc = "Register `TASKS_TRIGOVRFLW` writer"]
|
||||
pub struct W(crate::W<TASKS_TRIGOVRFLW_SPEC>);
|
||||
impl core::ops::Deref for W {
|
||||
type Target = crate::W<TASKS_TRIGOVRFLW_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_TRIGOVRFLW_SPEC>> for W {
|
||||
#[inline(always)]
|
||||
fn from(writer: crate::W<TASKS_TRIGOVRFLW_SPEC>) -> Self {
|
||||
W(writer)
|
||||
}
|
||||
}
|
||||
#[doc = "Set COUNTER to 0xFFFFF0\n\nValue on reset: 0"]
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum TASKS_TRIGOVRFLW_AW {
|
||||
#[doc = "1: Trigger task"]
|
||||
TRIGGER = 1,
|
||||
}
|
||||
impl From<TASKS_TRIGOVRFLW_AW> for bool {
|
||||
#[inline(always)]
|
||||
fn from(variant: TASKS_TRIGOVRFLW_AW) -> Self {
|
||||
variant as u8 != 0
|
||||
}
|
||||
}
|
||||
#[doc = "Field `TASKS_TRIGOVRFLW` writer - Set COUNTER to 0xFFFFF0"]
|
||||
pub type TASKS_TRIGOVRFLW_W<'a, const O: u8> =
|
||||
crate::BitWriter<'a, u32, TASKS_TRIGOVRFLW_SPEC, TASKS_TRIGOVRFLW_AW, O>;
|
||||
impl<'a, const O: u8> TASKS_TRIGOVRFLW_W<'a, O> {
|
||||
#[doc = "Trigger task"]
|
||||
#[inline(always)]
|
||||
pub fn trigger(self) -> &'a mut W {
|
||||
self.variant(TASKS_TRIGOVRFLW_AW::TRIGGER)
|
||||
}
|
||||
}
|
||||
impl W {
|
||||
#[doc = "Bit 0 - Set COUNTER to 0xFFFFF0"]
|
||||
#[inline(always)]
|
||||
pub fn tasks_trigovrflw(&mut self) -> TASKS_TRIGOVRFLW_W<0> {
|
||||
TASKS_TRIGOVRFLW_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 = "Set COUNTER to 0xFFFFF0\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_trigovrflw](index.html) module"]
|
||||
pub struct TASKS_TRIGOVRFLW_SPEC;
|
||||
impl crate::RegisterSpec for TASKS_TRIGOVRFLW_SPEC {
|
||||
type Ux = u32;
|
||||
}
|
||||
#[doc = "`write(|w| ..)` method takes [tasks_trigovrflw::W](W) writer structure"]
|
||||
impl crate::Writable for TASKS_TRIGOVRFLW_SPEC {
|
||||
type Writer = W;
|
||||
}
|
||||
#[doc = "`reset()` method sets TASKS_TRIGOVRFLW to value 0"]
|
||||
impl crate::Resettable for TASKS_TRIGOVRFLW_SPEC {
|
||||
#[inline(always)]
|
||||
fn reset_value() -> Self::Ux {
|
||||
0
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user