├── .gitignore ├── src ├── swi0 │ └── unused.rs ├── ppi │ ├── tasks_chg │ │ ├── en.rs │ │ └── dis.rs │ ├── fork.rs │ └── fork │ │ └── tep.rs ├── ficr │ ├── temp │ │ ├── b0.rs │ │ ├── b1.rs │ │ ├── b2.rs │ │ ├── b3.rs │ │ ├── b4.rs │ │ ├── b5.rs │ │ ├── t0.rs │ │ ├── t1.rs │ │ ├── t2.rs │ │ ├── t3.rs │ │ ├── t4.rs │ │ ├── a0.rs │ │ ├── a1.rs │ │ ├── a2.rs │ │ ├── a3.rs │ │ ├── a4.rs │ │ └── a5.rs │ ├── er.rs │ ├── ir.rs │ ├── codesize.rs │ ├── deviceid.rs │ ├── deviceaddr.rs │ ├── codepagesize.rs │ ├── info │ │ └── unused0.rs │ └── nfc │ │ ├── tagheader1.rs │ │ ├── tagheader2.rs │ │ ├── tagheader3.rs │ │ └── tagheader0.rs ├── twi0 │ ├── rxd.rs │ ├── tasks_stop.rs │ ├── tasks_resume.rs │ ├── tasks_startrx.rs │ ├── tasks_starttx.rs │ ├── tasks_suspend.rs │ ├── events_bb.rs │ ├── events_error.rs │ ├── events_stopped.rs │ ├── events_txdsent.rs │ ├── events_rxdready.rs │ ├── events_suspended.rs │ └── txd.rs ├── aar │ ├── tasks_stop.rs │ ├── tasks_start.rs │ ├── status.rs │ ├── events_end.rs │ ├── events_resolved.rs │ └── events_notresolved.rs ├── ccm │ ├── tasks_stop.rs │ ├── tasks_crypt.rs │ ├── tasks_ksgen.rs │ ├── events_error.rs │ ├── events_endcrypt.rs │ └── events_endksgen.rs ├── clock │ ├── tasks_cal.rs │ ├── tasks_ctstop.rs │ ├── tasks_ctstart.rs │ ├── tasks_hfclkstop.rs │ ├── tasks_lfclkstop.rs │ ├── tasks_hfclkstart.rs │ ├── tasks_lfclkstart.rs │ ├── events_ctto.rs │ ├── events_done.rs │ ├── events_hfclkstarted.rs │ └── events_lfclkstarted.rs ├── comp │ ├── tasks_stop.rs │ ├── tasks_start.rs │ ├── tasks_sample.rs │ ├── events_up.rs │ ├── events_down.rs │ ├── events_cross.rs │ └── events_ready.rs ├── i2s │ ├── tasks_stop.rs │ ├── tasks_start.rs │ ├── events_stopped.rs │ ├── events_rxptrupd.rs │ ├── events_txptrupd.rs │ ├── rxd.rs │ ├── txd.rs │ └── rxtxd.rs ├── pdm │ ├── tasks_stop.rs │ ├── tasks_start.rs │ ├── events_end.rs │ ├── events_started.rs │ └── events_stopped.rs ├── pwm0 │ ├── tasks_stop.rs │ ├── tasks_nextstep.rs │ ├── tasks_seqstart.rs │ ├── events_stopped.rs │ ├── events_loopsdone.rs │ ├── events_seqend.rs │ ├── events_pwmperiodend.rs │ ├── events_seqstarted.rs │ └── psel.rs ├── qdec │ ├── tasks_stop.rs │ ├── tasks_start.rs │ ├── tasks_rdclracc.rs │ ├── tasks_rdclrdbl.rs │ ├── tasks_readclracc.rs │ ├── sample.rs │ ├── accread.rs │ ├── acc.rs │ ├── accdbl.rs │ ├── events_accof.rs │ ├── events_dblrdy.rs │ ├── accdblread.rs │ ├── events_stopped.rs │ ├── events_reportrdy.rs │ └── events_samplerdy.rs ├── rng │ ├── tasks_stop.rs │ ├── tasks_start.rs │ ├── value.rs │ └── events_valrdy.rs ├── rtc0 │ ├── tasks_stop.rs │ ├── tasks_clear.rs │ ├── tasks_start.rs │ ├── tasks_trigovrflw.rs │ ├── counter.rs │ ├── events_tick.rs │ ├── events_ovrflw.rs │ └── events_compare.rs ├── temp │ ├── tasks_stop.rs │ ├── tasks_start.rs │ ├── temp.rs │ ├── events_datardy.rs │ ├── t1.rs │ ├── t0.rs │ ├── t2.rs │ ├── t3.rs │ └── t4.rs ├── lpcomp │ ├── tasks_stop.rs │ ├── tasks_start.rs │ ├── tasks_sample.rs │ ├── events_up.rs │ ├── events_down.rs │ ├── events_cross.rs │ └── events_ready.rs ├── nfct │ ├── tasks_sense.rs │ ├── tasks_goidle.rs │ ├── tasks_disable.rs │ ├── tasks_gosleep.rs │ ├── tasks_starttx.rs │ ├── tasks_activate.rs │ ├── tasks_enablerxdata.rs │ ├── currentloadctrl.rs │ ├── events_endrx.rs │ ├── events_endtx.rs │ ├── events_error.rs │ ├── events_ready.rs │ ├── events_rxerror.rs │ ├── events_started.rs │ ├── events_selected.rs │ ├── events_collision.rs │ ├── events_fieldlost.rs │ ├── events_rxframeend.rs │ ├── events_txframeend.rs │ ├── events_rxframestart.rs │ ├── events_txframestart.rs │ ├── events_fielddetected.rs │ ├── events_autocolresstarted.rs │ ├── framestatus.rs │ └── rxd │ │ └── amount.rs ├── radio │ ├── tasks_rxen.rs │ ├── tasks_stop.rs │ ├── tasks_txen.rs │ ├── dai.rs │ ├── tasks_start.rs │ ├── tasks_bcstop.rs │ ├── tasks_bcstart.rs │ ├── tasks_disable.rs │ ├── tasks_rssistop.rs │ ├── rxmatch.rs │ ├── tasks_rssistart.rs │ ├── rssisample.rs │ ├── rxcrc.rs │ ├── unused0.rs │ ├── events_end.rs │ ├── events_crcok.rs │ ├── events_ready.rs │ ├── events_address.rs │ ├── events_bcmatch.rs │ ├── events_devmiss.rs │ ├── events_payload.rs │ ├── events_rssiend.rs │ ├── events_crcerror.rs │ ├── events_devmatch.rs │ ├── events_disabled.rs │ ├── bcc.rs │ ├── tifs.rs │ └── dap.rs ├── saadc │ ├── tasks_stop.rs │ ├── tasks_start.rs │ ├── tasks_sample.rs │ ├── tasks_calibrateoffset.rs │ ├── events_ch │ │ ├── limith.rs │ │ └── limitl.rs │ ├── events_end.rs │ ├── events_done.rs │ ├── result │ │ ├── amount.rs │ │ └── ptr.rs │ ├── events_started.rs │ ├── events_stopped.rs │ ├── events_resultdone.rs │ └── events_calibratedone.rs ├── spim0 │ ├── tasks_stop.rs │ ├── tasks_start.rs │ ├── tasks_resume.rs │ ├── tasks_suspend.rs │ ├── rxd │ │ ├── amount.rs │ │ └── ptr.rs │ ├── txd │ │ ├── amount.rs │ │ └── ptr.rs │ ├── events_end.rs │ ├── events_endrx.rs │ ├── events_endtx.rs │ ├── events_started.rs │ └── events_stopped.rs ├── timer0 │ ├── tasks_stop.rs │ ├── tasks_clear.rs │ ├── tasks_count.rs │ ├── tasks_start.rs │ ├── tasks_shutdown.rs │ ├── tasks_capture.rs │ ├── events_compare.rs │ └── cc.rs ├── timer3 │ ├── tasks_stop.rs │ ├── tasks_clear.rs │ ├── tasks_count.rs │ ├── tasks_start.rs │ ├── tasks_shutdown.rs │ ├── tasks_capture.rs │ ├── events_compare.rs │ └── cc.rs ├── twim0 │ ├── tasks_stop.rs │ ├── tasks_resume.rs │ ├── tasks_startrx.rs │ ├── tasks_starttx.rs │ ├── tasks_suspend.rs │ ├── rxd │ │ ├── amount.rs │ │ └── ptr.rs │ ├── txd │ │ ├── amount.rs │ │ └── ptr.rs │ ├── events_error.rs │ ├── events_lastrx.rs │ ├── events_lasttx.rs │ ├── events_stopped.rs │ ├── events_rxstarted.rs │ ├── events_suspended.rs │ └── events_txstarted.rs ├── twis0 │ ├── tasks_stop.rs │ ├── tasks_resume.rs │ ├── tasks_suspend.rs │ ├── tasks_preparerx.rs │ ├── tasks_preparetx.rs │ ├── match_.rs │ ├── rxd │ │ ├── amount.rs │ │ └── ptr.rs │ ├── txd │ │ ├── amount.rs │ │ └── ptr.rs │ ├── events_read.rs │ ├── events_error.rs │ ├── events_write.rs │ ├── events_stopped.rs │ ├── events_rxstarted.rs │ └── events_txstarted.rs ├── wdt │ ├── tasks_start.rs │ └── events_timeout.rs ├── gpiote │ ├── tasks_clr.rs │ ├── tasks_out.rs │ ├── tasks_set.rs │ ├── events_in.rs │ └── events_port.rs ├── ecb │ ├── tasks_stopecb.rs │ ├── tasks_startecb.rs │ ├── events_endecb.rs │ └── events_errorecb.rs ├── power │ ├── tasks_lowpwr.rs │ ├── tasks_constlat.rs │ ├── events_pofwarn.rs │ ├── events_sleepexit.rs │ └── events_sleepenter.rs ├── spi0 │ ├── rxd.rs │ ├── events_ready.rs │ └── txd.rs ├── uart0 │ ├── tasks_stoprx.rs │ ├── tasks_stoptx.rs │ ├── tasks_startrx.rs │ ├── tasks_starttx.rs │ ├── tasks_suspend.rs │ ├── rxd.rs │ ├── events_cts.rs │ ├── events_ncts.rs │ ├── events_rxto.rs │ ├── events_error.rs │ ├── events_rxdrdy.rs │ ├── events_txdrdy.rs │ └── txd.rs ├── uarte0 │ ├── tasks_stoprx.rs │ ├── tasks_stoptx.rs │ ├── tasks_flushrx.rs │ ├── tasks_startrx.rs │ ├── tasks_starttx.rs │ ├── rxd │ │ ├── amount.rs │ │ └── ptr.rs │ ├── txd │ │ ├── amount.rs │ │ └── ptr.rs │ ├── events_cts.rs │ ├── events_ncts.rs │ ├── events_rxto.rs │ ├── events_endrx.rs │ ├── events_endtx.rs │ ├── events_error.rs │ ├── events_rxdrdy.rs │ ├── events_txdrdy.rs │ ├── events_rxstarted.rs │ ├── events_txstarted.rs │ └── events_txstopped.rs ├── mwu │ ├── pregion │ │ ├── end.rs │ │ └── start.rs │ ├── events_region │ │ ├── ra.rs │ │ └── wa.rs │ ├── events_pregion │ │ ├── ra.rs │ │ └── wa.rs │ └── region │ │ └── end.rs ├── spis0 │ ├── tasks_acquire.rs │ ├── tasks_release.rs │ ├── rxd │ │ ├── amount.rs │ │ └── ptr.rs │ ├── txd │ │ ├── amount.rs │ │ └── ptr.rs │ ├── events_end.rs │ ├── events_endrx.rs │ └── events_acquired.rs ├── egu0 │ ├── tasks_trigger.rs │ └── events_triggered.rs ├── bprot │ └── unused0.rs ├── uicr │ ├── unused0.rs │ ├── unused1.rs │ ├── unused2.rs │ └── unused3.rs ├── swi0.rs └── nvmc │ └── ihit.rs ├── update.sh ├── Cargo.toml ├── README.md └── LICENSE-MIT /.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | [._]*.sw[a-p] 3 | **/*.rs.bk 4 | Cargo.lock 5 | -------------------------------------------------------------------------------- /src/swi0/unused.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register UNUSED"] 2 | pub type R = crate::R; 3 | impl R {} 4 | -------------------------------------------------------------------------------- /src/ppi/tasks_chg/en.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register EN"] 2 | pub type W = crate::W; 3 | #[doc = "Register EN `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::EN { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/ppi/tasks_chg/dis.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register DIS"] 2 | pub type W = crate::W; 3 | #[doc = "Register DIS `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::DIS { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/ficr/temp/b0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register B0"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `B`"] 4 | pub type B_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:13 - B (y-intercept)"] 7 | #[inline(always)] 8 | pub fn b(&self) -> B_R { 9 | B_R::new((self.bits & 0x3fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/ficr/temp/b1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register B1"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `B`"] 4 | pub type B_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:13 - B (y-intercept)"] 7 | #[inline(always)] 8 | pub fn b(&self) -> B_R { 9 | B_R::new((self.bits & 0x3fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/ficr/temp/b2.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register B2"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `B`"] 4 | pub type B_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:13 - B (y-intercept)"] 7 | #[inline(always)] 8 | pub fn b(&self) -> B_R { 9 | B_R::new((self.bits & 0x3fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/ficr/temp/b3.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register B3"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `B`"] 4 | pub type B_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:13 - B (y-intercept)"] 7 | #[inline(always)] 8 | pub fn b(&self) -> B_R { 9 | B_R::new((self.bits & 0x3fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/ficr/temp/b4.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register B4"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `B`"] 4 | pub type B_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:13 - B (y-intercept)"] 7 | #[inline(always)] 8 | pub fn b(&self) -> B_R { 9 | B_R::new((self.bits & 0x3fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/ficr/temp/b5.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register B5"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `B`"] 4 | pub type B_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:13 - B (y-intercept)"] 7 | #[inline(always)] 8 | pub fn b(&self) -> B_R { 9 | B_R::new((self.bits & 0x3fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/ficr/temp/t0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register T0"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `T`"] 4 | pub type T_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:7 - T (segment end)register."] 7 | #[inline(always)] 8 | pub fn t(&self) -> T_R { 9 | T_R::new((self.bits & 0xff) as u8) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/ficr/temp/t1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register T1"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `T`"] 4 | pub type T_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:7 - T (segment end)register."] 7 | #[inline(always)] 8 | pub fn t(&self) -> T_R { 9 | T_R::new((self.bits & 0xff) as u8) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/ficr/temp/t2.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register T2"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `T`"] 4 | pub type T_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:7 - T (segment end)register."] 7 | #[inline(always)] 8 | pub fn t(&self) -> T_R { 9 | T_R::new((self.bits & 0xff) as u8) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/ficr/temp/t3.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register T3"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `T`"] 4 | pub type T_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:7 - T (segment end)register."] 7 | #[inline(always)] 8 | pub fn t(&self) -> T_R { 9 | T_R::new((self.bits & 0xff) as u8) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/ficr/temp/t4.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register T4"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `T`"] 4 | pub type T_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:7 - T (segment end)register."] 7 | #[inline(always)] 8 | pub fn t(&self) -> T_R { 9 | T_R::new((self.bits & 0xff) as u8) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/twi0/rxd.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RXD"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `RXD`"] 4 | pub type RXD_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:7 - RXD register"] 7 | #[inline(always)] 8 | pub fn rxd(&self) -> RXD_R { 9 | RXD_R::new((self.bits & 0xff) as u8) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/aar/tasks_stop.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_STOP"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_STOP `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_STOP { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/ccm/tasks_stop.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_STOP"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_STOP `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_STOP { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/clock/tasks_cal.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_CAL"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_CAL `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_CAL { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/comp/tasks_stop.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_STOP"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_STOP `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_STOP { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/i2s/tasks_stop.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_STOP"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_STOP `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_STOP { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/pdm/tasks_stop.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_STOP"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_STOP `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_STOP { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/pwm0/tasks_stop.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_STOP"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_STOP `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_STOP { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/qdec/tasks_stop.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_STOP"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_STOP `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_STOP { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/rng/tasks_stop.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_STOP"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_STOP `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_STOP { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/rtc0/tasks_stop.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_STOP"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_STOP `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_STOP { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/temp/tasks_stop.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_STOP"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_STOP `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_STOP { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/twi0/tasks_stop.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_STOP"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_STOP `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_STOP { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/aar/tasks_start.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_START"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_START `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_START { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/ccm/tasks_crypt.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_CRYPT"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_CRYPT `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_CRYPT { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/ccm/tasks_ksgen.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_KSGEN"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_KSGEN `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_KSGEN { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/comp/tasks_start.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_START"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_START `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_START { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/i2s/tasks_start.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_START"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_START `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_START { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/lpcomp/tasks_stop.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_STOP"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_STOP `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_STOP { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/nfct/tasks_sense.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_SENSE"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_SENSE `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_SENSE { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/pdm/tasks_start.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_START"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_START `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_START { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/qdec/tasks_start.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_START"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_START `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_START { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/radio/tasks_rxen.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_RXEN"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_RXEN `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_RXEN { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/radio/tasks_stop.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_STOP"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_STOP `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_STOP { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/radio/tasks_txen.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_TXEN"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_TXEN `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_TXEN { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/rng/tasks_start.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_START"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_START `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_START { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/rtc0/tasks_clear.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_CLEAR"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_CLEAR `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_CLEAR { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/rtc0/tasks_start.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_START"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_START `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_START { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/saadc/tasks_stop.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_STOP"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_STOP `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_STOP { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/spim0/tasks_stop.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_STOP"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_STOP `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_STOP { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/temp/tasks_start.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_START"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_START `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_START { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/timer0/tasks_stop.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_STOP"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_STOP `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_STOP { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/timer3/tasks_stop.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_STOP"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_STOP `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_STOP { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/twim0/tasks_stop.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_STOP"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_STOP `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_STOP { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/twis0/tasks_stop.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_STOP"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_STOP `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_STOP { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/wdt/tasks_start.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_START"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_START `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_START { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/comp/tasks_sample.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_SAMPLE"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_SAMPLE `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_SAMPLE { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/ficr/er.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register ER[%s]"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `ER`"] 4 | pub type ER_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - Encryption Root, word n"] 7 | #[inline(always)] 8 | pub fn er(&self) -> ER_R { 9 | ER_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/ficr/ir.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register IR[%s]"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `IR`"] 4 | pub type IR_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - Identity Root, word n"] 7 | #[inline(always)] 8 | pub fn ir(&self) -> IR_R { 9 | IR_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/ficr/temp/a0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register A0"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `A`"] 4 | pub type A_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:11 - A (slope definition) register."] 7 | #[inline(always)] 8 | pub fn a(&self) -> A_R { 9 | A_R::new((self.bits & 0x0fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/ficr/temp/a1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register A1"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `A`"] 4 | pub type A_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:11 - A (slope definition) register."] 7 | #[inline(always)] 8 | pub fn a(&self) -> A_R { 9 | A_R::new((self.bits & 0x0fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/ficr/temp/a2.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register A2"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `A`"] 4 | pub type A_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:11 - A (slope definition) register."] 7 | #[inline(always)] 8 | pub fn a(&self) -> A_R { 9 | A_R::new((self.bits & 0x0fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/ficr/temp/a3.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register A3"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `A`"] 4 | pub type A_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:11 - A (slope definition) register."] 7 | #[inline(always)] 8 | pub fn a(&self) -> A_R { 9 | A_R::new((self.bits & 0x0fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/ficr/temp/a4.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register A4"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `A`"] 4 | pub type A_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:11 - A (slope definition) register."] 7 | #[inline(always)] 8 | pub fn a(&self) -> A_R { 9 | A_R::new((self.bits & 0x0fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/ficr/temp/a5.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register A5"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `A`"] 4 | pub type A_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:11 - A (slope definition) register."] 7 | #[inline(always)] 8 | pub fn a(&self) -> A_R { 9 | A_R::new((self.bits & 0x0fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/gpiote/tasks_clr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_CLR[%s]"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_CLR[%s] 4 | `reset()`'s with value 0"] 5 | impl crate::ResetValue for super::TASKS_CLR { 6 | type Type = u32; 7 | #[inline(always)] 8 | fn reset_value() -> Self::Type { 9 | 0 10 | } 11 | } 12 | impl W {} 13 | -------------------------------------------------------------------------------- /src/gpiote/tasks_out.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_OUT[%s]"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_OUT[%s] 4 | `reset()`'s with value 0"] 5 | impl crate::ResetValue for super::TASKS_OUT { 6 | type Type = u32; 7 | #[inline(always)] 8 | fn reset_value() -> Self::Type { 9 | 0 10 | } 11 | } 12 | impl W {} 13 | -------------------------------------------------------------------------------- /src/gpiote/tasks_set.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_SET[%s]"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_SET[%s] 4 | `reset()`'s with value 0"] 5 | impl crate::ResetValue for super::TASKS_SET { 6 | type Type = u32; 7 | #[inline(always)] 8 | fn reset_value() -> Self::Type { 9 | 0 10 | } 11 | } 12 | impl W {} 13 | -------------------------------------------------------------------------------- /src/lpcomp/tasks_start.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_START"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_START `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_START { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/nfct/tasks_goidle.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_GOIDLE"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_GOIDLE `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_GOIDLE { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/radio/dai.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register DAI"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `DAI`"] 4 | pub type DAI_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:2 - Device address match index"] 7 | #[inline(always)] 8 | pub fn dai(&self) -> DAI_R { 9 | DAI_R::new((self.bits & 0x07) as u8) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/radio/tasks_start.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_START"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_START `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_START { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/saadc/tasks_start.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_START"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_START `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_START { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/spim0/tasks_start.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_START"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_START `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_START { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/timer0/tasks_clear.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_CLEAR"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_CLEAR `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_CLEAR { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/timer0/tasks_count.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_COUNT"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_COUNT `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_COUNT { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/timer0/tasks_start.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_START"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_START `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_START { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/timer3/tasks_clear.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_CLEAR"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_CLEAR `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_CLEAR { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/timer3/tasks_count.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_COUNT"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_COUNT `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_COUNT { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/timer3/tasks_start.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_START"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_START `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_START { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/twi0/tasks_resume.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_RESUME"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_RESUME `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_RESUME { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/clock/tasks_ctstop.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_CTSTOP"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_CTSTOP `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_CTSTOP { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/ecb/tasks_stopecb.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_STOPECB"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_STOPECB `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_STOPECB { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/lpcomp/tasks_sample.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_SAMPLE"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_SAMPLE `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_SAMPLE { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/nfct/tasks_disable.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_DISABLE"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_DISABLE `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_DISABLE { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/nfct/tasks_gosleep.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_GOSLEEP"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_GOSLEEP `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_GOSLEEP { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/nfct/tasks_starttx.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_STARTTX"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_STARTTX `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_STARTTX { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/power/tasks_lowpwr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_LOWPWR"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_LOWPWR `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_LOWPWR { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/radio/tasks_bcstop.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_BCSTOP"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_BCSTOP `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_BCSTOP { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/saadc/tasks_sample.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_SAMPLE"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_SAMPLE `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_SAMPLE { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/spi0/rxd.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RXD"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `RXD`"] 4 | pub type RXD_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:7 - RX data received. Double buffered"] 7 | #[inline(always)] 8 | pub fn rxd(&self) -> RXD_R { 9 | RXD_R::new((self.bits & 0xff) as u8) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/spim0/tasks_resume.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_RESUME"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_RESUME `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_RESUME { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/twi0/tasks_startrx.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_STARTRX"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_STARTRX `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_STARTRX { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/twi0/tasks_starttx.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_STARTTX"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_STARTTX `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_STARTTX { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/twi0/tasks_suspend.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_SUSPEND"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_SUSPEND `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_SUSPEND { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/twim0/tasks_resume.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_RESUME"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_RESUME `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_RESUME { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/twis0/tasks_resume.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_RESUME"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_RESUME `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_RESUME { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/uart0/tasks_stoprx.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_STOPRX"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_STOPRX `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_STOPRX { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/uart0/tasks_stoptx.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_STOPTX"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_STOPTX `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_STOPTX { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/uarte0/tasks_stoprx.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_STOPRX"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_STOPRX `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_STOPRX { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/uarte0/tasks_stoptx.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_STOPTX"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_STOPTX `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_STOPTX { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/clock/tasks_ctstart.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_CTSTART"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_CTSTART `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_CTSTART { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/ecb/tasks_startecb.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_STARTECB"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_STARTECB `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_STARTECB { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/mwu/pregion/end.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register END"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `END`"] 4 | pub type END_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - Reserved for future use"] 7 | #[inline(always)] 8 | pub fn end(&self) -> END_R { 9 | END_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/nfct/tasks_activate.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_ACTIVATE"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_ACTIVATE `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_ACTIVATE { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/pwm0/tasks_nextstep.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_NEXTSTEP"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_NEXTSTEP `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_NEXTSTEP { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/qdec/tasks_rdclracc.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_RDCLRACC"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_RDCLRACC `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_RDCLRACC { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/qdec/tasks_rdclrdbl.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_RDCLRDBL"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_RDCLRDBL `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_RDCLRDBL { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/radio/tasks_bcstart.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_BCSTART"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_BCSTART `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_BCSTART { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/radio/tasks_disable.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_DISABLE"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_DISABLE `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_DISABLE { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/rng/value.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register VALUE"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `VALUE`"] 4 | pub type VALUE_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:7 - Generated random number"] 7 | #[inline(always)] 8 | pub fn value(&self) -> VALUE_R { 9 | VALUE_R::new((self.bits & 0xff) as u8) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/spim0/tasks_suspend.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_SUSPEND"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_SUSPEND `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_SUSPEND { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/spis0/tasks_acquire.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_ACQUIRE"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_ACQUIRE `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_ACQUIRE { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/spis0/tasks_release.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_RELEASE"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_RELEASE `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_RELEASE { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/twim0/tasks_startrx.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_STARTRX"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_STARTRX `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_STARTRX { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/twim0/tasks_starttx.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_STARTTX"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_STARTTX `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_STARTTX { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/twim0/tasks_suspend.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_SUSPEND"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_SUSPEND `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_SUSPEND { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/twis0/tasks_suspend.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_SUSPEND"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_SUSPEND `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_SUSPEND { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/uart0/tasks_startrx.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_STARTRX"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_STARTRX `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_STARTRX { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/uart0/tasks_starttx.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_STARTTX"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_STARTTX `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_STARTTX { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/uart0/tasks_suspend.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_SUSPEND"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_SUSPEND `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_SUSPEND { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/uarte0/tasks_flushrx.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_FLUSHRX"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_FLUSHRX `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_FLUSHRX { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/uarte0/tasks_startrx.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_STARTRX"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_STARTRX `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_STARTRX { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/uarte0/tasks_starttx.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_STARTTX"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_STARTTX `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_STARTTX { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/power/tasks_constlat.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_CONSTLAT"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_CONSTLAT `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_CONSTLAT { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/radio/tasks_rssistop.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_RSSISTOP"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_RSSISTOP `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_RSSISTOP { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/timer0/tasks_shutdown.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_SHUTDOWN"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_SHUTDOWN `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_SHUTDOWN { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/timer3/tasks_shutdown.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_SHUTDOWN"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_SHUTDOWN `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_SHUTDOWN { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /update.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | set -x 3 | set -e 4 | 5 | # NOTE: Last executed using Rust 1.40.0 6 | 7 | cargo install --force --version 0.17.0 svd2rust 8 | cargo install --force --version 0.7.0 form 9 | rustup component add rustfmt 10 | 11 | rm -rf src 12 | mkdir src 13 | svd2rust -i ./nrf52832.svd 14 | form -i lib.rs -o src 15 | rm lib.rs 16 | cargo fmt 17 | rustfmt build.rs 18 | -------------------------------------------------------------------------------- /src/clock/tasks_hfclkstop.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_HFCLKSTOP"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_HFCLKSTOP `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_HFCLKSTOP { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/clock/tasks_lfclkstop.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_LFCLKSTOP"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_LFCLKSTOP `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_LFCLKSTOP { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/egu0/tasks_trigger.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_TRIGGER[%s]"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_TRIGGER[%s] 4 | `reset()`'s with value 0"] 5 | impl crate::ResetValue for super::TASKS_TRIGGER { 6 | type Type = u32; 7 | #[inline(always)] 8 | fn reset_value() -> Self::Type { 9 | 0 10 | } 11 | } 12 | impl W {} 13 | -------------------------------------------------------------------------------- /src/qdec/tasks_readclracc.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_READCLRACC"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_READCLRACC `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_READCLRACC { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/radio/rxmatch.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RXMATCH"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `RXMATCH`"] 4 | pub type RXMATCH_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:2 - Received address"] 7 | #[inline(always)] 8 | pub fn rxmatch(&self) -> RXMATCH_R { 9 | RXMATCH_R::new((self.bits & 0x07) as u8) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/radio/tasks_rssistart.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_RSSISTART"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_RSSISTART `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_RSSISTART { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/rtc0/tasks_trigovrflw.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_TRIGOVRFLW"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_TRIGOVRFLW `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_TRIGOVRFLW { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/timer0/tasks_capture.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_CAPTURE[%s]"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_CAPTURE[%s] 4 | `reset()`'s with value 0"] 5 | impl crate::ResetValue for super::TASKS_CAPTURE { 6 | type Type = u32; 7 | #[inline(always)] 8 | fn reset_value() -> Self::Type { 9 | 0 10 | } 11 | } 12 | impl W {} 13 | -------------------------------------------------------------------------------- /src/timer3/tasks_capture.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_CAPTURE[%s]"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_CAPTURE[%s] 4 | `reset()`'s with value 0"] 5 | impl crate::ResetValue for super::TASKS_CAPTURE { 6 | type Type = u32; 7 | #[inline(always)] 8 | fn reset_value() -> Self::Type { 9 | 0 10 | } 11 | } 12 | impl W {} 13 | -------------------------------------------------------------------------------- /src/twis0/tasks_preparerx.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_PREPARERX"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_PREPARERX `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_PREPARERX { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/twis0/tasks_preparetx.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_PREPARETX"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_PREPARETX `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_PREPARETX { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/clock/tasks_hfclkstart.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_HFCLKSTART"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_HFCLKSTART `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_HFCLKSTART { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/clock/tasks_lfclkstart.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_LFCLKSTART"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_LFCLKSTART `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_LFCLKSTART { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/pwm0/tasks_seqstart.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_SEQSTART[%s]"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_SEQSTART[%s] 4 | `reset()`'s with value 0"] 5 | impl crate::ResetValue for super::TASKS_SEQSTART { 6 | type Type = u32; 7 | #[inline(always)] 8 | fn reset_value() -> Self::Type { 9 | 0 10 | } 11 | } 12 | impl W {} 13 | -------------------------------------------------------------------------------- /src/qdec/sample.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register SAMPLE"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `SAMPLE`"] 4 | pub type SAMPLE_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - Last motion sample"] 7 | #[inline(always)] 8 | pub fn sample(&self) -> SAMPLE_R { 9 | SAMPLE_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/rtc0/counter.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register COUNTER"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `COUNTER`"] 4 | pub type COUNTER_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:23 - Counter value"] 7 | #[inline(always)] 8 | pub fn counter(&self) -> COUNTER_R { 9 | COUNTER_R::new((self.bits & 0x00ff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/temp/temp.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TEMP"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `TEMP`"] 4 | pub type TEMP_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - Temperature in degC (0.25deg steps)"] 7 | #[inline(always)] 8 | pub fn temp(&self) -> TEMP_R { 9 | TEMP_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/uart0/rxd.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RXD"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `RXD`"] 4 | pub type RXD_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:7 - RX data received in previous transfers, double buffered"] 7 | #[inline(always)] 8 | pub fn rxd(&self) -> RXD_R { 9 | RXD_R::new((self.bits & 0xff) as u8) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/mwu/pregion/start.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register START"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `START`"] 4 | pub type START_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - Reserved for future use"] 7 | #[inline(always)] 8 | pub fn start(&self) -> START_R { 9 | START_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/nfct/tasks_enablerxdata.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_ENABLERXDATA"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_ENABLERXDATA `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_ENABLERXDATA { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/radio/rssisample.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RSSISAMPLE"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `RSSISAMPLE`"] 4 | pub type RSSISAMPLE_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:6 - RSSI sample"] 7 | #[inline(always)] 8 | pub fn rssisample(&self) -> RSSISAMPLE_R { 9 | RSSISAMPLE_R::new((self.bits & 0x7f) as u8) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/radio/rxcrc.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RXCRC"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `RXCRC`"] 4 | pub type RXCRC_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:23 - CRC field of previously received packet"] 7 | #[inline(always)] 8 | pub fn rxcrc(&self) -> RXCRC_R { 9 | RXCRC_R::new((self.bits & 0x00ff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/qdec/accread.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register ACCREAD"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `ACCREAD`"] 4 | pub type ACCREAD_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - Snapshot of the ACC register."] 7 | #[inline(always)] 8 | pub fn accread(&self) -> ACCREAD_R { 9 | ACCREAD_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/aar/status.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register STATUS"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `STATUS`"] 4 | pub type STATUS_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:3 - The IRK that was used last time an address was resolved"] 7 | #[inline(always)] 8 | pub fn status(&self) -> STATUS_R { 9 | STATUS_R::new((self.bits & 0x0f) as u8) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/saadc/tasks_calibrateoffset.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TASKS_CALIBRATEOFFSET"] 2 | pub type W = crate::W; 3 | #[doc = "Register TASKS_CALIBRATEOFFSET `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TASKS_CALIBRATEOFFSET { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /src/spim0/rxd/amount.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register AMOUNT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `AMOUNT`"] 4 | pub type AMOUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:7 - Number of bytes transferred in the last transaction"] 7 | #[inline(always)] 8 | pub fn amount(&self) -> AMOUNT_R { 9 | AMOUNT_R::new((self.bits & 0xff) as u8) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/spim0/txd/amount.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register AMOUNT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `AMOUNT`"] 4 | pub type AMOUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:7 - Number of bytes transferred in the last transaction"] 7 | #[inline(always)] 8 | pub fn amount(&self) -> AMOUNT_R { 9 | AMOUNT_R::new((self.bits & 0xff) as u8) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/uarte0/rxd/amount.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register AMOUNT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `AMOUNT`"] 4 | pub type AMOUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:7 - Number of bytes transferred in the last transaction"] 7 | #[inline(always)] 8 | pub fn amount(&self) -> AMOUNT_R { 9 | AMOUNT_R::new((self.bits & 0xff) as u8) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/uarte0/txd/amount.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register AMOUNT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `AMOUNT`"] 4 | pub type AMOUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:7 - Number of bytes transferred in the last transaction"] 7 | #[inline(always)] 8 | pub fn amount(&self) -> AMOUNT_R { 9 | AMOUNT_R::new((self.bits & 0xff) as u8) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/ficr/codesize.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register CODESIZE"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `CODESIZE`"] 4 | pub type CODESIZE_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - Code memory size in number of pages"] 7 | #[inline(always)] 8 | pub fn codesize(&self) -> CODESIZE_R { 9 | CODESIZE_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/ficr/deviceid.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register DEVICEID[%s]"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `DEVICEID`"] 4 | pub type DEVICEID_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - 64 bit unique device identifier"] 7 | #[inline(always)] 8 | pub fn deviceid(&self) -> DEVICEID_R { 9 | DEVICEID_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/spis0/rxd/amount.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register AMOUNT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `AMOUNT`"] 4 | pub type AMOUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:7 - Number of bytes received in the last granted transaction"] 7 | #[inline(always)] 8 | pub fn amount(&self) -> AMOUNT_R { 9 | AMOUNT_R::new((self.bits & 0xff) as u8) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/spis0/txd/amount.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register AMOUNT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `AMOUNT`"] 4 | pub type AMOUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:7 - Number of bytes transmitted in last granted transaction"] 7 | #[inline(always)] 8 | pub fn amount(&self) -> AMOUNT_R { 9 | AMOUNT_R::new((self.bits & 0xff) as u8) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/twis0/match_.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register MATCH"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `MATCH`"] 4 | pub type MATCH_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - Which of the addresses in {ADDRESS} matched the incoming address"] 7 | #[inline(always)] 8 | pub fn match_(&self) -> MATCH_R { 9 | MATCH_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/twis0/rxd/amount.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register AMOUNT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `AMOUNT`"] 4 | pub type AMOUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:7 - Number of bytes transferred in the last RXD transaction"] 7 | #[inline(always)] 8 | pub fn amount(&self) -> AMOUNT_R { 9 | AMOUNT_R::new((self.bits & 0xff) as u8) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/twis0/txd/amount.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register AMOUNT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `AMOUNT`"] 4 | pub type AMOUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:7 - Number of bytes transferred in the last TXD transaction"] 7 | #[inline(always)] 8 | pub fn amount(&self) -> AMOUNT_R { 9 | AMOUNT_R::new((self.bits & 0xff) as u8) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/mwu/events_region/ra.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RA"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register RA"] 4 | pub type W = crate::W; 5 | #[doc = "Register RA `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::RA { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/mwu/events_region/wa.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register WA"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register WA"] 4 | pub type W = crate::W; 5 | #[doc = "Register WA `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::WA { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/ficr/deviceaddr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register DEVICEADDR[%s]"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `DEVICEADDR`"] 4 | pub type DEVICEADDR_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - 48 bit device address"] 7 | #[inline(always)] 8 | pub fn deviceaddr(&self) -> DEVICEADDR_R { 9 | DEVICEADDR_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/mwu/events_pregion/ra.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RA"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register RA"] 4 | pub type W = crate::W; 5 | #[doc = "Register RA `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::RA { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/mwu/events_pregion/wa.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register WA"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register WA"] 4 | pub type W = crate::W; 5 | #[doc = "Register WA `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::WA { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/ficr/codepagesize.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register CODEPAGESIZE"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `CODEPAGESIZE`"] 4 | pub type CODEPAGESIZE_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - Code memory page size"] 7 | #[inline(always)] 8 | pub fn codepagesize(&self) -> CODEPAGESIZE_R { 9 | CODEPAGESIZE_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/qdec/acc.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register ACC"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `ACC`"] 4 | pub type ACC_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - Register accumulating all valid samples (not double transition) read from the SAMPLE register"] 7 | #[inline(always)] 8 | pub fn acc(&self) -> ACC_R { 9 | ACC_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/bprot/unused0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register UNUSED0"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register UNUSED0"] 4 | pub type W = crate::W; 5 | #[doc = "Register UNUSED0 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::UNUSED0 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/qdec/accdbl.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register ACCDBL"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `ACCDBL`"] 4 | pub type ACCDBL_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:3 - Register accumulating the number of detected double or illegal transitions. ( SAMPLE = 2 )."] 7 | #[inline(always)] 8 | pub fn accdbl(&self) -> ACCDBL_R { 9 | ACCDBL_R::new((self.bits & 0x0f) as u8) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/radio/unused0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register UNUSED0"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register UNUSED0"] 4 | pub type W = crate::W; 5 | #[doc = "Register UNUSED0 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::UNUSED0 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/uicr/unused0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register UNUSED0"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register UNUSED0"] 4 | pub type W = crate::W; 5 | #[doc = "Register UNUSED0 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::UNUSED0 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/uicr/unused1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register UNUSED1"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register UNUSED1"] 4 | pub type W = crate::W; 5 | #[doc = "Register UNUSED1 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::UNUSED1 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/uicr/unused2.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register UNUSED2"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register UNUSED2"] 4 | pub type W = crate::W; 5 | #[doc = "Register UNUSED2 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::UNUSED2 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/uicr/unused3.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register UNUSED3"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register UNUSED3"] 4 | pub type W = crate::W; 5 | #[doc = "Register UNUSED3 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::UNUSED3 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/saadc/events_ch/limith.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register LIMITH"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register LIMITH"] 4 | pub type W = crate::W; 5 | #[doc = "Register LIMITH `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::LIMITH { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/saadc/events_ch/limitl.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register LIMITL"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register LIMITL"] 4 | pub type W = crate::W; 5 | #[doc = "Register LIMITL `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::LIMITL { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/comp/events_up.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_UP"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_UP"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_UP `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_UP { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/lpcomp/events_up.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_UP"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_UP"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_UP `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_UP { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/twi0/events_bb.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_BB"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_BB"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_BB `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_BB { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/twim0/rxd/amount.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register AMOUNT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `AMOUNT`"] 4 | pub type AMOUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:7 - Number of bytes transferred in the last transaction. In case of NACK error, includes the NACK'ed byte."] 7 | #[inline(always)] 8 | pub fn amount(&self) -> AMOUNT_R { 9 | AMOUNT_R::new((self.bits & 0xff) as u8) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/twim0/txd/amount.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register AMOUNT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `AMOUNT`"] 4 | pub type AMOUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:7 - Number of bytes transferred in the last transaction. In case of NACK error, includes the NACK'ed byte."] 7 | #[inline(always)] 8 | pub fn amount(&self) -> AMOUNT_R { 9 | AMOUNT_R::new((self.bits & 0xff) as u8) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/aar/events_end.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_END"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_END"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_END `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_END { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/ficr/info/unused0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register UNUSED0[%s]"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register UNUSED0[%s]"] 4 | pub type W = crate::W; 5 | #[doc = "Register UNUSED0[%s] 6 | `reset()`'s with value 0"] 7 | impl crate::ResetValue for super::UNUSED0 { 8 | type Type = u32; 9 | #[inline(always)] 10 | fn reset_value() -> Self::Type { 11 | 0 12 | } 13 | } 14 | impl R {} 15 | impl W {} 16 | -------------------------------------------------------------------------------- /src/pdm/events_end.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_END"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_END"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_END `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_END { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/radio/events_end.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_END"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_END"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_END `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_END { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/saadc/events_end.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_END"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_END"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_END `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_END { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/spim0/events_end.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_END"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_END"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_END `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_END { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/spis0/events_end.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_END"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_END"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_END `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_END { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/uart0/events_cts.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_CTS"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_CTS"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_CTS `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_CTS { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/uarte0/events_cts.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_CTS"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_CTS"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_CTS `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_CTS { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/comp/events_down.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_DOWN"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_DOWN"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_DOWN `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_DOWN { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/nfct/currentloadctrl.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register CURRENTLOADCTRL"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `CURRENTLOADCTRL`"] 4 | pub type CURRENTLOADCTRL_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:5 - Current value driven to the NFC Load Control"] 7 | #[inline(always)] 8 | pub fn currentloadctrl(&self) -> CURRENTLOADCTRL_R { 9 | CURRENTLOADCTRL_R::new((self.bits & 0x3f) as u8) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/rtc0/events_tick.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_TICK"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_TICK"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_TICK `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_TICK { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/clock/events_ctto.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_CTTO"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_CTTO"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_CTTO `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_CTTO { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/clock/events_done.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_DONE"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_DONE"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_DONE `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_DONE { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/gpiote/events_in.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_IN[%s]"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_IN[%s]"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_IN[%s] 6 | `reset()`'s with value 0"] 7 | impl crate::ResetValue for super::EVENTS_IN { 8 | type Type = u32; 9 | #[inline(always)] 10 | fn reset_value() -> Self::Type { 11 | 0 12 | } 13 | } 14 | impl R {} 15 | impl W {} 16 | -------------------------------------------------------------------------------- /src/gpiote/events_port.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_PORT"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_PORT"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_PORT `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_PORT { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/lpcomp/events_down.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_DOWN"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_DOWN"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_DOWN `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_DOWN { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/saadc/events_done.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_DONE"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_DONE"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_DONE `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_DONE { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/twis0/events_read.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_READ"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_READ"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_READ `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_READ { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/uart0/events_ncts.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_NCTS"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_NCTS"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_NCTS `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_NCTS { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/uart0/events_rxto.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_RXTO"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_RXTO"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_RXTO `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_RXTO { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/uarte0/events_ncts.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_NCTS"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_NCTS"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_NCTS `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_NCTS { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/uarte0/events_rxto.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_RXTO"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_RXTO"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_RXTO `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_RXTO { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/ccm/events_error.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_ERROR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_ERROR"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_ERROR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_ERROR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/comp/events_cross.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_CROSS"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_CROSS"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_CROSS `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_CROSS { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/comp/events_ready.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_READY"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_READY"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_READY `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_READY { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/lpcomp/events_cross.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_CROSS"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_CROSS"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_CROSS `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_CROSS { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/lpcomp/events_ready.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_READY"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_READY"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_READY `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_READY { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/nfct/events_endrx.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_ENDRX"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_ENDRX"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_ENDRX `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_ENDRX { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/nfct/events_endtx.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_ENDTX"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_ENDTX"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_ENDTX `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_ENDTX { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/nfct/events_error.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_ERROR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_ERROR"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_ERROR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_ERROR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/nfct/events_ready.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_READY"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_READY"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_READY `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_READY { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/qdec/events_accof.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_ACCOF"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_ACCOF"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_ACCOF `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_ACCOF { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/radio/events_crcok.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_CRCOK"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_CRCOK"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_CRCOK `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_CRCOK { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/radio/events_ready.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_READY"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_READY"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_READY `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_READY { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/saadc/result/amount.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register AMOUNT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `AMOUNT`"] 4 | pub type AMOUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:14 - Number of buffer words transferred since last START. This register can be read after an END or STOPPED event."] 7 | #[inline(always)] 8 | pub fn amount(&self) -> AMOUNT_R { 9 | AMOUNT_R::new((self.bits & 0x7fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/spi0/events_ready.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_READY"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_READY"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_READY `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_READY { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/spim0/events_endrx.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_ENDRX"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_ENDRX"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_ENDRX `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_ENDRX { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/spim0/events_endtx.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_ENDTX"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_ENDTX"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_ENDTX `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_ENDTX { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/spis0/events_endrx.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_ENDRX"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_ENDRX"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_ENDRX `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_ENDRX { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/twi0/events_error.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_ERROR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_ERROR"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_ERROR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_ERROR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/twim0/events_error.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_ERROR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_ERROR"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_ERROR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_ERROR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/twis0/events_error.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_ERROR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_ERROR"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_ERROR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_ERROR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/twis0/events_write.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_WRITE"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_WRITE"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_WRITE `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_WRITE { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/uart0/events_error.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_ERROR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_ERROR"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_ERROR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_ERROR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/uarte0/events_endrx.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_ENDRX"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_ENDRX"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_ENDRX `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_ENDRX { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/uarte0/events_endtx.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_ENDTX"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_ENDTX"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_ENDTX `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_ENDTX { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/uarte0/events_error.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_ERROR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_ERROR"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_ERROR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_ERROR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/ecb/events_endecb.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_ENDECB"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_ENDECB"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_ENDECB `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_ENDECB { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/qdec/events_dblrdy.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_DBLRDY"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_DBLRDY"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_DBLRDY `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_DBLRDY { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/rng/events_valrdy.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_VALRDY"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_VALRDY"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_VALRDY `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_VALRDY { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/rtc0/events_ovrflw.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_OVRFLW"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_OVRFLW"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_OVRFLW `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_OVRFLW { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/twim0/events_lastrx.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_LASTRX"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_LASTRX"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_LASTRX `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_LASTRX { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/twim0/events_lasttx.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_LASTTX"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_LASTTX"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_LASTTX `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_LASTTX { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/uart0/events_rxdrdy.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_RXDRDY"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_RXDRDY"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_RXDRDY `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_RXDRDY { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/uart0/events_txdrdy.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_TXDRDY"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_TXDRDY"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_TXDRDY `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_TXDRDY { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/i2s/events_stopped.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_STOPPED"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_STOPPED"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_STOPPED `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_STOPPED { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/pdm/events_started.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_STARTED"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_STARTED"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_STARTED `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_STARTED { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/pdm/events_stopped.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_STOPPED"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_STOPPED"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_STOPPED `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_STOPPED { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/qdec/accdblread.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register ACCDBLREAD"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `ACCDBLREAD`"] 4 | pub type ACCDBLREAD_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:3 - Snapshot of the ACCDBL register. This field is updated when the READCLRACC or RDCLRDBL task is triggered."] 7 | #[inline(always)] 8 | pub fn accdblread(&self) -> ACCDBLREAD_R { 9 | ACCDBLREAD_R::new((self.bits & 0x0f) as u8) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/uarte0/events_rxdrdy.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_RXDRDY"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_RXDRDY"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_RXDRDY `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_RXDRDY { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/uarte0/events_txdrdy.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_TXDRDY"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_TXDRDY"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_TXDRDY `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_TXDRDY { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/wdt/events_timeout.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_TIMEOUT"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_TIMEOUT"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_TIMEOUT `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_TIMEOUT { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/nfct/events_rxerror.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_RXERROR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_RXERROR"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_RXERROR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_RXERROR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/nfct/events_started.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_STARTED"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_STARTED"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_STARTED `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_STARTED { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/power/events_pofwarn.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_POFWARN"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_POFWARN"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_POFWARN `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_POFWARN { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/pwm0/events_stopped.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_STOPPED"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_STOPPED"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_STOPPED `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_STOPPED { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/qdec/events_stopped.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_STOPPED"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_STOPPED"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_STOPPED `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_STOPPED { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/radio/events_address.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_ADDRESS"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_ADDRESS"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_ADDRESS `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_ADDRESS { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/radio/events_bcmatch.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_BCMATCH"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_BCMATCH"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_BCMATCH `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_BCMATCH { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/radio/events_devmiss.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_DEVMISS"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_DEVMISS"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_DEVMISS `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_DEVMISS { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/radio/events_payload.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_PAYLOAD"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_PAYLOAD"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_PAYLOAD `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_PAYLOAD { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/radio/events_rssiend.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_RSSIEND"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_RSSIEND"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_RSSIEND `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_RSSIEND { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/saadc/events_started.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_STARTED"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_STARTED"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_STARTED `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_STARTED { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/saadc/events_stopped.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_STOPPED"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_STOPPED"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_STOPPED `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_STOPPED { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/spim0/events_started.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_STARTED"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_STARTED"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_STARTED `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_STARTED { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/spim0/events_stopped.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_STOPPED"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_STOPPED"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_STOPPED `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_STOPPED { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/temp/events_datardy.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_DATARDY"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_DATARDY"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_DATARDY `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_DATARDY { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/twi0/events_stopped.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_STOPPED"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_STOPPED"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_STOPPED `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_STOPPED { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/twi0/events_txdsent.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_TXDSENT"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_TXDSENT"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_TXDSENT `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_TXDSENT { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/twim0/events_stopped.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_STOPPED"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_STOPPED"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_STOPPED `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_STOPPED { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/twis0/events_stopped.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_STOPPED"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_STOPPED"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_STOPPED `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_STOPPED { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/aar/events_resolved.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_RESOLVED"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_RESOLVED"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_RESOLVED `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_RESOLVED { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/ccm/events_endcrypt.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_ENDCRYPT"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_ENDCRYPT"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_ENDCRYPT `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_ENDCRYPT { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/ccm/events_endksgen.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_ENDKSGEN"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_ENDKSGEN"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_ENDKSGEN `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_ENDKSGEN { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/ecb/events_errorecb.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_ERRORECB"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_ERRORECB"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_ERRORECB `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_ERRORECB { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/i2s/events_rxptrupd.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_RXPTRUPD"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_RXPTRUPD"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_RXPTRUPD `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_RXPTRUPD { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/i2s/events_txptrupd.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_TXPTRUPD"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_TXPTRUPD"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_TXPTRUPD `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_TXPTRUPD { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/nfct/events_selected.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_SELECTED"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_SELECTED"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_SELECTED `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_SELECTED { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/radio/events_crcerror.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_CRCERROR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_CRCERROR"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_CRCERROR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_CRCERROR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/radio/events_devmatch.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_DEVMATCH"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_DEVMATCH"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_DEVMATCH `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_DEVMATCH { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/radio/events_disabled.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_DISABLED"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_DISABLED"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_DISABLED `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_DISABLED { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/spis0/events_acquired.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_ACQUIRED"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_ACQUIRED"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_ACQUIRED `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_ACQUIRED { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/twi0/events_rxdready.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_RXDREADY"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_RXDREADY"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_RXDREADY `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_RXDREADY { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/nfct/events_collision.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_COLLISION"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_COLLISION"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_COLLISION `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_COLLISION { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/nfct/events_fieldlost.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_FIELDLOST"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_FIELDLOST"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_FIELDLOST `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_FIELDLOST { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/pwm0/events_loopsdone.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_LOOPSDONE"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_LOOPSDONE"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_LOOPSDONE `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_LOOPSDONE { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/pwm0/events_seqend.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_SEQEND[%s]"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_SEQEND[%s]"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_SEQEND[%s] 6 | `reset()`'s with value 0"] 7 | impl crate::ResetValue for super::EVENTS_SEQEND { 8 | type Type = u32; 9 | #[inline(always)] 10 | fn reset_value() -> Self::Type { 11 | 0 12 | } 13 | } 14 | impl R {} 15 | impl W {} 16 | -------------------------------------------------------------------------------- /src/qdec/events_reportrdy.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_REPORTRDY"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_REPORTRDY"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_REPORTRDY `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_REPORTRDY { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/qdec/events_samplerdy.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_SAMPLERDY"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_SAMPLERDY"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_SAMPLERDY `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_SAMPLERDY { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/twi0/events_suspended.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_SUSPENDED"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_SUSPENDED"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_SUSPENDED `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_SUSPENDED { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/power/events_sleepexit.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_SLEEPEXIT"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_SLEEPEXIT"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_SLEEPEXIT `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_SLEEPEXIT { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/rtc0/events_compare.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_COMPARE[%s]"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_COMPARE[%s]"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_COMPARE[%s] 6 | `reset()`'s with value 0"] 7 | impl crate::ResetValue for super::EVENTS_COMPARE { 8 | type Type = u32; 9 | #[inline(always)] 10 | fn reset_value() -> Self::Type { 11 | 0 12 | } 13 | } 14 | impl R {} 15 | impl W {} 16 | -------------------------------------------------------------------------------- /src/timer0/events_compare.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_COMPARE[%s]"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_COMPARE[%s]"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_COMPARE[%s] 6 | `reset()`'s with value 0"] 7 | impl crate::ResetValue for super::EVENTS_COMPARE { 8 | type Type = u32; 9 | #[inline(always)] 10 | fn reset_value() -> Self::Type { 11 | 0 12 | } 13 | } 14 | impl R {} 15 | impl W {} 16 | -------------------------------------------------------------------------------- /src/timer3/events_compare.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_COMPARE[%s]"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_COMPARE[%s]"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_COMPARE[%s] 6 | `reset()`'s with value 0"] 7 | impl crate::ResetValue for super::EVENTS_COMPARE { 8 | type Type = u32; 9 | #[inline(always)] 10 | fn reset_value() -> Self::Type { 11 | 0 12 | } 13 | } 14 | impl R {} 15 | impl W {} 16 | -------------------------------------------------------------------------------- /src/twim0/events_rxstarted.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_RXSTARTED"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_RXSTARTED"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_RXSTARTED `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_RXSTARTED { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/twim0/events_suspended.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_SUSPENDED"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_SUSPENDED"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_SUSPENDED `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_SUSPENDED { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/twim0/events_txstarted.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_TXSTARTED"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_TXSTARTED"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_TXSTARTED `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_TXSTARTED { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/twis0/events_rxstarted.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_RXSTARTED"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_RXSTARTED"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_RXSTARTED `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_RXSTARTED { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/twis0/events_txstarted.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_TXSTARTED"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_TXSTARTED"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_TXSTARTED `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_TXSTARTED { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/uarte0/events_rxstarted.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_RXSTARTED"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_RXSTARTED"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_RXSTARTED `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_RXSTARTED { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/uarte0/events_txstarted.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_TXSTARTED"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_TXSTARTED"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_TXSTARTED `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_TXSTARTED { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/uarte0/events_txstopped.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_TXSTOPPED"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_TXSTOPPED"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_TXSTOPPED `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_TXSTOPPED { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/nfct/events_rxframeend.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_RXFRAMEEND"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_RXFRAMEEND"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_RXFRAMEEND `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_RXFRAMEEND { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/nfct/events_txframeend.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_TXFRAMEEND"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_TXFRAMEEND"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_TXFRAMEEND `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_TXFRAMEEND { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/power/events_sleepenter.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_SLEEPENTER"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_SLEEPENTER"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_SLEEPENTER `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_SLEEPENTER { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/saadc/events_resultdone.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_RESULTDONE"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_RESULTDONE"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_RESULTDONE `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_RESULTDONE { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/aar/events_notresolved.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_NOTRESOLVED"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_NOTRESOLVED"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_NOTRESOLVED `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_NOTRESOLVED { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/egu0/events_triggered.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_TRIGGERED[%s]"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_TRIGGERED[%s]"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_TRIGGERED[%s] 6 | `reset()`'s with value 0"] 7 | impl crate::ResetValue for super::EVENTS_TRIGGERED { 8 | type Type = u32; 9 | #[inline(always)] 10 | fn reset_value() -> Self::Type { 11 | 0 12 | } 13 | } 14 | impl R {} 15 | impl W {} 16 | -------------------------------------------------------------------------------- /src/clock/events_hfclkstarted.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_HFCLKSTARTED"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_HFCLKSTARTED"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_HFCLKSTARTED `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_HFCLKSTARTED { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/clock/events_lfclkstarted.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_LFCLKSTARTED"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_LFCLKSTARTED"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_LFCLKSTARTED `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_LFCLKSTARTED { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/nfct/events_rxframestart.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_RXFRAMESTART"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_RXFRAMESTART"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_RXFRAMESTART `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_RXFRAMESTART { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/nfct/events_txframestart.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_TXFRAMESTART"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_TXFRAMESTART"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_TXFRAMESTART `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_TXFRAMESTART { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/pwm0/events_pwmperiodend.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_PWMPERIODEND"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_PWMPERIODEND"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_PWMPERIODEND `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_PWMPERIODEND { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/pwm0/events_seqstarted.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_SEQSTARTED[%s]"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_SEQSTARTED[%s]"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_SEQSTARTED[%s] 6 | `reset()`'s with value 0"] 7 | impl crate::ResetValue for super::EVENTS_SEQSTARTED { 8 | type Type = u32; 9 | #[inline(always)] 10 | fn reset_value() -> Self::Type { 11 | 0 12 | } 13 | } 14 | impl R {} 15 | impl W {} 16 | -------------------------------------------------------------------------------- /src/nfct/events_fielddetected.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_FIELDDETECTED"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_FIELDDETECTED"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_FIELDDETECTED `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_FIELDDETECTED { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/saadc/events_calibratedone.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_CALIBRATEDONE"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_CALIBRATEDONE"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_CALIBRATEDONE `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_CALIBRATEDONE { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/nfct/events_autocolresstarted.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EVENTS_AUTOCOLRESSTARTED"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register EVENTS_AUTOCOLRESSTARTED"] 4 | pub type W = crate::W; 5 | #[doc = "Register EVENTS_AUTOCOLRESSTARTED `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::EVENTS_AUTOCOLRESSTARTED { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /src/swi0.rs: -------------------------------------------------------------------------------- 1 | #[doc = r"Register block"] 2 | #[repr(C)] 3 | pub struct RegisterBlock { 4 | #[doc = "0x00 - Unused."] 5 | pub unused: UNUSED, 6 | } 7 | #[doc = "Unused.\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 [unused](unused) module"] 8 | pub type UNUSED = crate::Reg; 9 | #[allow(missing_docs)] 10 | #[doc(hidden)] 11 | pub struct _UNUSED; 12 | #[doc = "`read()` method returns [unused::R](unused::R) reader structure"] 13 | impl crate::Readable for UNUSED {} 14 | #[doc = "Unused."] 15 | pub mod unused; 16 | -------------------------------------------------------------------------------- /Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | version = "0.9.0" 3 | authors = [ 4 | "James Munns ", 5 | "Hanno Braun ", 6 | "Wez Furlong ", 7 | ] 8 | description = "Peripheral access API for nrf52832 microcontrollers" 9 | documentation = "https://docs.rs/nrf52832-pac" 10 | keywords = ["no-std", "arm", "cortex-m", "nrf52", "nrf52832"] 11 | license = "MIT OR Apache-2.0" 12 | name = "nrf52832-pac" 13 | repository = "https://github.com/nrf-rs/nrf52832-pac" 14 | edition = "2018" 15 | 16 | [dependencies] 17 | bare-metal = "0.2.4" 18 | vcell = "0.1" 19 | cortex-m = ">= 0.5.8, < 0.7" 20 | 21 | [dependencies.cortex-m-rt] 22 | optional = true 23 | version = "0.6.8" 24 | 25 | [features] 26 | rt = ["cortex-m-rt/device"] 27 | -------------------------------------------------------------------------------- /src/nfct/framestatus.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Result of last incoming frames\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [rx](rx) module"] 2 | pub type RX = crate::Reg; 3 | #[allow(missing_docs)] 4 | #[doc(hidden)] 5 | pub struct _RX; 6 | #[doc = "`read()` method returns [rx::R](rx::R) reader structure"] 7 | impl crate::Readable for RX {} 8 | #[doc = "`write(|w| ..)` method takes [rx::W](rx::W) writer structure"] 9 | impl crate::Writable for RX {} 10 | #[doc = "Result of last incoming frames"] 11 | pub mod rx; 12 | -------------------------------------------------------------------------------- /src/i2s/rxd.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Receive buffer RAM start address.\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ptr](ptr) module"] 2 | pub type PTR = crate::Reg; 3 | #[allow(missing_docs)] 4 | #[doc(hidden)] 5 | pub struct _PTR; 6 | #[doc = "`read()` method returns [ptr::R](ptr::R) reader structure"] 7 | impl crate::Readable for PTR {} 8 | #[doc = "`write(|w| ..)` method takes [ptr::W](ptr::W) writer structure"] 9 | impl crate::Writable for PTR {} 10 | #[doc = "Receive buffer RAM start address."] 11 | pub mod ptr; 12 | -------------------------------------------------------------------------------- /src/i2s/txd.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Transmit buffer RAM start address.\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ptr](ptr) module"] 2 | pub type PTR = crate::Reg; 3 | #[allow(missing_docs)] 4 | #[doc(hidden)] 5 | pub struct _PTR; 6 | #[doc = "`read()` method returns [ptr::R](ptr::R) reader structure"] 7 | impl crate::Readable for PTR {} 8 | #[doc = "`write(|w| ..)` method takes [ptr::W](ptr::W) writer structure"] 9 | impl crate::Writable for PTR {} 10 | #[doc = "Transmit buffer RAM start address."] 11 | pub mod ptr; 12 | -------------------------------------------------------------------------------- /src/i2s/rxtxd.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Size of RXD and TXD buffers.\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [maxcnt](maxcnt) module"] 2 | pub type MAXCNT = crate::Reg; 3 | #[allow(missing_docs)] 4 | #[doc(hidden)] 5 | pub struct _MAXCNT; 6 | #[doc = "`read()` method returns [maxcnt::R](maxcnt::R) reader structure"] 7 | impl crate::Readable for MAXCNT {} 8 | #[doc = "`write(|w| ..)` method takes [maxcnt::W](maxcnt::W) writer structure"] 9 | impl crate::Writable for MAXCNT {} 10 | #[doc = "Size of RXD and TXD buffers."] 11 | pub mod maxcnt; 12 | -------------------------------------------------------------------------------- /src/ppi/fork.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Description cluster\\[0\\]: Channel 0 task end-point\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [tep](tep) module"] 2 | pub type TEP = crate::Reg; 3 | #[allow(missing_docs)] 4 | #[doc(hidden)] 5 | pub struct _TEP; 6 | #[doc = "`read()` method returns [tep::R](tep::R) reader structure"] 7 | impl crate::Readable for TEP {} 8 | #[doc = "`write(|w| ..)` method takes [tep::W](tep::W) writer structure"] 9 | impl crate::Writable for TEP {} 10 | #[doc = "Description cluster\\[0\\]: Channel 0 task end-point"] 11 | pub mod tep; 12 | -------------------------------------------------------------------------------- /src/uart0/txd.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TXD"] 2 | pub type W = crate::W; 3 | #[doc = "Register TXD `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TXD { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | #[doc = "Write proxy for field `TXD`"] 12 | pub struct TXD_W<'a> { 13 | w: &'a mut W, 14 | } 15 | impl<'a> TXD_W<'a> { 16 | #[doc = r"Writes raw bits to the field"] 17 | #[inline(always)] 18 | pub unsafe fn bits(self, value: u8) -> &'a mut W { 19 | self.w.bits = (self.w.bits & !0xff) | ((value as u32) & 0xff); 20 | self.w 21 | } 22 | } 23 | impl W { 24 | #[doc = "Bits 0:7 - TX data to be transferred"] 25 | #[inline(always)] 26 | pub fn txd(&mut self) -> TXD_W { 27 | TXD_W { w: self } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/pwm0/psel.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Description collection\\[0\\]: Output pin select for PWM channel 0\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [out](out) module"] 2 | pub type OUT = crate::Reg; 3 | #[allow(missing_docs)] 4 | #[doc(hidden)] 5 | pub struct _OUT; 6 | #[doc = "`read()` method returns [out::R](out::R) reader structure"] 7 | impl crate::Readable for OUT {} 8 | #[doc = "`write(|w| ..)` method takes [out::W](out::W) writer structure"] 9 | impl crate::Writable for OUT {} 10 | #[doc = "Description collection\\[0\\]: Output pin select for PWM channel 0"] 11 | pub mod out; 12 | -------------------------------------------------------------------------------- /src/nfct/rxd/amount.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register AMOUNT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `RXDATABITS`"] 4 | pub type RXDATABITS_R = crate::R; 5 | #[doc = "Reader of field `RXDATABYTES`"] 6 | pub type RXDATABYTES_R = crate::R; 7 | impl R { 8 | #[doc = "Bits 0:2 - Number of bits in the last byte in the frame, if less than 8 (including CRC, but excluding parity and SoF/EoF framing)."] 9 | #[inline(always)] 10 | pub fn rxdatabits(&self) -> RXDATABITS_R { 11 | RXDATABITS_R::new((self.bits & 0x07) as u8) 12 | } 13 | #[doc = "Bits 3:11 - Number of complete bytes received in the frame (including CRC, but excluding parity and SoF/EoF framing)"] 14 | #[inline(always)] 15 | pub fn rxdatabytes(&self) -> RXDATABYTES_R { 16 | RXDATABYTES_R::new(((self.bits >> 3) & 0x01ff) as u16) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | **MOVED!** This repository has been moved to . 2 | 3 | # `nrf52832-pac` 4 | 5 | > Peripheral access API for the nRF52832 microcontroller 6 | 7 | This repo contains the sources used to generate the code for the nRF52832 8 | microcontroller from the corresponding SVD files that are also included 9 | in this repo. 10 | 11 | We use `svd2rust` to generate the code, `form` to organize it, and `cargo fmt` 12 | to make it pretty. 13 | 14 | # License 15 | 16 | Licensed under either of 17 | 18 | - Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or 19 | http://www.apache.org/licenses/LICENSE-2.0) 20 | 21 | - MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT) 22 | 23 | at your option. 24 | 25 | ## Contribution 26 | 27 | Unless you explicitly state otherwise, any contribution intentionally submitted 28 | for inclusion in the work by you, as defined in the Apache-2.0 license, shall be 29 | dual licensed as above, without any additional terms or conditions. 30 | -------------------------------------------------------------------------------- /LICENSE-MIT: -------------------------------------------------------------------------------- 1 | Copyright (c) 2018 Anthony James Munns 2 | 3 | Permission is hereby granted, free of charge, to any 4 | person obtaining a copy of this software and associated 5 | documentation files (the "Software"), to deal in the 6 | Software without restriction, including without 7 | limitation the rights to use, copy, modify, merge, 8 | publish, distribute, sublicense, and/or sell copies of 9 | the Software, and to permit persons to whom the Software 10 | is furnished to do so, subject to the following 11 | conditions: 12 | 13 | The above copyright notice and this permission notice 14 | shall be included in all copies or substantial portions 15 | of the Software. 16 | 17 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF 18 | ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED 19 | TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A 20 | PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT 21 | SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 22 | CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 23 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR 24 | IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 25 | DEALINGS IN THE SOFTWARE. 26 | -------------------------------------------------------------------------------- /src/ficr/nfc/tagheader1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TAGHEADER1"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `UD4`"] 4 | pub type UD4_R = crate::R; 5 | #[doc = "Reader of field `UD5`"] 6 | pub type UD5_R = crate::R; 7 | #[doc = "Reader of field `UD6`"] 8 | pub type UD6_R = crate::R; 9 | #[doc = "Reader of field `UD7`"] 10 | pub type UD7_R = crate::R; 11 | impl R { 12 | #[doc = "Bits 0:7 - Unique identifier byte 4"] 13 | #[inline(always)] 14 | pub fn ud4(&self) -> UD4_R { 15 | UD4_R::new((self.bits & 0xff) as u8) 16 | } 17 | #[doc = "Bits 8:15 - Unique identifier byte 5"] 18 | #[inline(always)] 19 | pub fn ud5(&self) -> UD5_R { 20 | UD5_R::new(((self.bits >> 8) & 0xff) as u8) 21 | } 22 | #[doc = "Bits 16:23 - Unique identifier byte 6"] 23 | #[inline(always)] 24 | pub fn ud6(&self) -> UD6_R { 25 | UD6_R::new(((self.bits >> 16) & 0xff) as u8) 26 | } 27 | #[doc = "Bits 24:31 - Unique identifier byte 7"] 28 | #[inline(always)] 29 | pub fn ud7(&self) -> UD7_R { 30 | UD7_R::new(((self.bits >> 24) & 0xff) as u8) 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/ficr/nfc/tagheader2.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TAGHEADER2"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `UD8`"] 4 | pub type UD8_R = crate::R; 5 | #[doc = "Reader of field `UD9`"] 6 | pub type UD9_R = crate::R; 7 | #[doc = "Reader of field `UD10`"] 8 | pub type UD10_R = crate::R; 9 | #[doc = "Reader of field `UD11`"] 10 | pub type UD11_R = crate::R; 11 | impl R { 12 | #[doc = "Bits 0:7 - Unique identifier byte 8"] 13 | #[inline(always)] 14 | pub fn ud8(&self) -> UD8_R { 15 | UD8_R::new((self.bits & 0xff) as u8) 16 | } 17 | #[doc = "Bits 8:15 - Unique identifier byte 9"] 18 | #[inline(always)] 19 | pub fn ud9(&self) -> UD9_R { 20 | UD9_R::new(((self.bits >> 8) & 0xff) as u8) 21 | } 22 | #[doc = "Bits 16:23 - Unique identifier byte 10"] 23 | #[inline(always)] 24 | pub fn ud10(&self) -> UD10_R { 25 | UD10_R::new(((self.bits >> 16) & 0xff) as u8) 26 | } 27 | #[doc = "Bits 24:31 - Unique identifier byte 11"] 28 | #[inline(always)] 29 | pub fn ud11(&self) -> UD11_R { 30 | UD11_R::new(((self.bits >> 24) & 0xff) as u8) 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/ficr/nfc/tagheader3.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TAGHEADER3"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `UD12`"] 4 | pub type UD12_R = crate::R; 5 | #[doc = "Reader of field `UD13`"] 6 | pub type UD13_R = crate::R; 7 | #[doc = "Reader of field `UD14`"] 8 | pub type UD14_R = crate::R; 9 | #[doc = "Reader of field `UD15`"] 10 | pub type UD15_R = crate::R; 11 | impl R { 12 | #[doc = "Bits 0:7 - Unique identifier byte 12"] 13 | #[inline(always)] 14 | pub fn ud12(&self) -> UD12_R { 15 | UD12_R::new((self.bits & 0xff) as u8) 16 | } 17 | #[doc = "Bits 8:15 - Unique identifier byte 13"] 18 | #[inline(always)] 19 | pub fn ud13(&self) -> UD13_R { 20 | UD13_R::new(((self.bits >> 8) & 0xff) as u8) 21 | } 22 | #[doc = "Bits 16:23 - Unique identifier byte 14"] 23 | #[inline(always)] 24 | pub fn ud14(&self) -> UD14_R { 25 | UD14_R::new(((self.bits >> 16) & 0xff) as u8) 26 | } 27 | #[doc = "Bits 24:31 - Unique identifier byte 15"] 28 | #[inline(always)] 29 | pub fn ud15(&self) -> UD15_R { 30 | UD15_R::new(((self.bits >> 24) & 0xff) as u8) 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/twi0/txd.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TXD"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register TXD"] 4 | pub type W = crate::W; 5 | #[doc = "Register TXD `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::TXD { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | #[doc = "Reader of field `TXD`"] 14 | pub type TXD_R = crate::R; 15 | #[doc = "Write proxy for field `TXD`"] 16 | pub struct TXD_W<'a> { 17 | w: &'a mut W, 18 | } 19 | impl<'a> TXD_W<'a> { 20 | #[doc = r"Writes raw bits to the field"] 21 | #[inline(always)] 22 | pub unsafe fn bits(self, value: u8) -> &'a mut W { 23 | self.w.bits = (self.w.bits & !0xff) | ((value as u32) & 0xff); 24 | self.w 25 | } 26 | } 27 | impl R { 28 | #[doc = "Bits 0:7 - TXD register"] 29 | #[inline(always)] 30 | pub fn txd(&self) -> TXD_R { 31 | TXD_R::new((self.bits & 0xff) as u8) 32 | } 33 | } 34 | impl W { 35 | #[doc = "Bits 0:7 - TXD register"] 36 | #[inline(always)] 37 | pub fn txd(&mut self) -> TXD_W { 38 | TXD_W { w: self } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/ficr/nfc/tagheader0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TAGHEADER0"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `MFGID`"] 4 | pub type MFGID_R = crate::R; 5 | #[doc = "Reader of field `UD1`"] 6 | pub type UD1_R = crate::R; 7 | #[doc = "Reader of field `UD2`"] 8 | pub type UD2_R = crate::R; 9 | #[doc = "Reader of field `UD3`"] 10 | pub type UD3_R = crate::R; 11 | impl R { 12 | #[doc = "Bits 0:7 - Default Manufacturer ID: Nordic Semiconductor ASA has ICM 0x5F"] 13 | #[inline(always)] 14 | pub fn mfgid(&self) -> MFGID_R { 15 | MFGID_R::new((self.bits & 0xff) as u8) 16 | } 17 | #[doc = "Bits 8:15 - Unique identifier byte 1"] 18 | #[inline(always)] 19 | pub fn ud1(&self) -> UD1_R { 20 | UD1_R::new(((self.bits >> 8) & 0xff) as u8) 21 | } 22 | #[doc = "Bits 16:23 - Unique identifier byte 2"] 23 | #[inline(always)] 24 | pub fn ud2(&self) -> UD2_R { 25 | UD2_R::new(((self.bits >> 16) & 0xff) as u8) 26 | } 27 | #[doc = "Bits 24:31 - Unique identifier byte 3"] 28 | #[inline(always)] 29 | pub fn ud3(&self) -> UD3_R { 30 | UD3_R::new(((self.bits >> 24) & 0xff) as u8) 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/spim0/rxd/ptr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PTR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register PTR"] 4 | pub type W = crate::W; 5 | #[doc = "Register PTR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::PTR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | #[doc = "Reader of field `PTR`"] 14 | pub type PTR_R = crate::R; 15 | #[doc = "Write proxy for field `PTR`"] 16 | pub struct PTR_W<'a> { 17 | w: &'a mut W, 18 | } 19 | impl<'a> PTR_W<'a> { 20 | #[doc = r"Writes raw bits to the field"] 21 | #[inline(always)] 22 | pub unsafe fn bits(self, value: u32) -> &'a mut W { 23 | self.w.bits = (self.w.bits & !0xffff_ffff) | ((value as u32) & 0xffff_ffff); 24 | self.w 25 | } 26 | } 27 | impl R { 28 | #[doc = "Bits 0:31 - Data pointer"] 29 | #[inline(always)] 30 | pub fn ptr(&self) -> PTR_R { 31 | PTR_R::new((self.bits & 0xffff_ffff) as u32) 32 | } 33 | } 34 | impl W { 35 | #[doc = "Bits 0:31 - Data pointer"] 36 | #[inline(always)] 37 | pub fn ptr(&mut self) -> PTR_W { 38 | PTR_W { w: self } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/spim0/txd/ptr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PTR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register PTR"] 4 | pub type W = crate::W; 5 | #[doc = "Register PTR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::PTR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | #[doc = "Reader of field `PTR`"] 14 | pub type PTR_R = crate::R; 15 | #[doc = "Write proxy for field `PTR`"] 16 | pub struct PTR_W<'a> { 17 | w: &'a mut W, 18 | } 19 | impl<'a> PTR_W<'a> { 20 | #[doc = r"Writes raw bits to the field"] 21 | #[inline(always)] 22 | pub unsafe fn bits(self, value: u32) -> &'a mut W { 23 | self.w.bits = (self.w.bits & !0xffff_ffff) | ((value as u32) & 0xffff_ffff); 24 | self.w 25 | } 26 | } 27 | impl R { 28 | #[doc = "Bits 0:31 - Data pointer"] 29 | #[inline(always)] 30 | pub fn ptr(&self) -> PTR_R { 31 | PTR_R::new((self.bits & 0xffff_ffff) as u32) 32 | } 33 | } 34 | impl W { 35 | #[doc = "Bits 0:31 - Data pointer"] 36 | #[inline(always)] 37 | pub fn ptr(&mut self) -> PTR_W { 38 | PTR_W { w: self } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/twim0/rxd/ptr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PTR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register PTR"] 4 | pub type W = crate::W; 5 | #[doc = "Register PTR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::PTR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | #[doc = "Reader of field `PTR`"] 14 | pub type PTR_R = crate::R; 15 | #[doc = "Write proxy for field `PTR`"] 16 | pub struct PTR_W<'a> { 17 | w: &'a mut W, 18 | } 19 | impl<'a> PTR_W<'a> { 20 | #[doc = r"Writes raw bits to the field"] 21 | #[inline(always)] 22 | pub unsafe fn bits(self, value: u32) -> &'a mut W { 23 | self.w.bits = (self.w.bits & !0xffff_ffff) | ((value as u32) & 0xffff_ffff); 24 | self.w 25 | } 26 | } 27 | impl R { 28 | #[doc = "Bits 0:31 - Data pointer"] 29 | #[inline(always)] 30 | pub fn ptr(&self) -> PTR_R { 31 | PTR_R::new((self.bits & 0xffff_ffff) as u32) 32 | } 33 | } 34 | impl W { 35 | #[doc = "Bits 0:31 - Data pointer"] 36 | #[inline(always)] 37 | pub fn ptr(&mut self) -> PTR_W { 38 | PTR_W { w: self } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/twim0/txd/ptr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PTR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register PTR"] 4 | pub type W = crate::W; 5 | #[doc = "Register PTR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::PTR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | #[doc = "Reader of field `PTR`"] 14 | pub type PTR_R = crate::R; 15 | #[doc = "Write proxy for field `PTR`"] 16 | pub struct PTR_W<'a> { 17 | w: &'a mut W, 18 | } 19 | impl<'a> PTR_W<'a> { 20 | #[doc = r"Writes raw bits to the field"] 21 | #[inline(always)] 22 | pub unsafe fn bits(self, value: u32) -> &'a mut W { 23 | self.w.bits = (self.w.bits & !0xffff_ffff) | ((value as u32) & 0xffff_ffff); 24 | self.w 25 | } 26 | } 27 | impl R { 28 | #[doc = "Bits 0:31 - Data pointer"] 29 | #[inline(always)] 30 | pub fn ptr(&self) -> PTR_R { 31 | PTR_R::new((self.bits & 0xffff_ffff) as u32) 32 | } 33 | } 34 | impl W { 35 | #[doc = "Bits 0:31 - Data pointer"] 36 | #[inline(always)] 37 | pub fn ptr(&mut self) -> PTR_W { 38 | PTR_W { w: self } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/saadc/result/ptr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PTR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register PTR"] 4 | pub type W = crate::W; 5 | #[doc = "Register PTR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::PTR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | #[doc = "Reader of field `PTR`"] 14 | pub type PTR_R = crate::R; 15 | #[doc = "Write proxy for field `PTR`"] 16 | pub struct PTR_W<'a> { 17 | w: &'a mut W, 18 | } 19 | impl<'a> PTR_W<'a> { 20 | #[doc = r"Writes raw bits to the field"] 21 | #[inline(always)] 22 | pub unsafe fn bits(self, value: u32) -> &'a mut W { 23 | self.w.bits = (self.w.bits & !0xffff_ffff) | ((value as u32) & 0xffff_ffff); 24 | self.w 25 | } 26 | } 27 | impl R { 28 | #[doc = "Bits 0:31 - Data pointer"] 29 | #[inline(always)] 30 | pub fn ptr(&self) -> PTR_R { 31 | PTR_R::new((self.bits & 0xffff_ffff) as u32) 32 | } 33 | } 34 | impl W { 35 | #[doc = "Bits 0:31 - Data pointer"] 36 | #[inline(always)] 37 | pub fn ptr(&mut self) -> PTR_W { 38 | PTR_W { w: self } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/uarte0/rxd/ptr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PTR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register PTR"] 4 | pub type W = crate::W; 5 | #[doc = "Register PTR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::PTR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | #[doc = "Reader of field `PTR`"] 14 | pub type PTR_R = crate::R; 15 | #[doc = "Write proxy for field `PTR`"] 16 | pub struct PTR_W<'a> { 17 | w: &'a mut W, 18 | } 19 | impl<'a> PTR_W<'a> { 20 | #[doc = r"Writes raw bits to the field"] 21 | #[inline(always)] 22 | pub unsafe fn bits(self, value: u32) -> &'a mut W { 23 | self.w.bits = (self.w.bits & !0xffff_ffff) | ((value as u32) & 0xffff_ffff); 24 | self.w 25 | } 26 | } 27 | impl R { 28 | #[doc = "Bits 0:31 - Data pointer"] 29 | #[inline(always)] 30 | pub fn ptr(&self) -> PTR_R { 31 | PTR_R::new((self.bits & 0xffff_ffff) as u32) 32 | } 33 | } 34 | impl W { 35 | #[doc = "Bits 0:31 - Data pointer"] 36 | #[inline(always)] 37 | pub fn ptr(&mut self) -> PTR_W { 38 | PTR_W { w: self } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/uarte0/txd/ptr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PTR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register PTR"] 4 | pub type W = crate::W; 5 | #[doc = "Register PTR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::PTR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | #[doc = "Reader of field `PTR`"] 14 | pub type PTR_R = crate::R; 15 | #[doc = "Write proxy for field `PTR`"] 16 | pub struct PTR_W<'a> { 17 | w: &'a mut W, 18 | } 19 | impl<'a> PTR_W<'a> { 20 | #[doc = r"Writes raw bits to the field"] 21 | #[inline(always)] 22 | pub unsafe fn bits(self, value: u32) -> &'a mut W { 23 | self.w.bits = (self.w.bits & !0xffff_ffff) | ((value as u32) & 0xffff_ffff); 24 | self.w 25 | } 26 | } 27 | impl R { 28 | #[doc = "Bits 0:31 - Data pointer"] 29 | #[inline(always)] 30 | pub fn ptr(&self) -> PTR_R { 31 | PTR_R::new((self.bits & 0xffff_ffff) as u32) 32 | } 33 | } 34 | impl W { 35 | #[doc = "Bits 0:31 - Data pointer"] 36 | #[inline(always)] 37 | pub fn ptr(&mut self) -> PTR_W { 38 | PTR_W { w: self } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/radio/bcc.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register BCC"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register BCC"] 4 | pub type W = crate::W; 5 | #[doc = "Register BCC `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::BCC { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | #[doc = "Reader of field `BCC`"] 14 | pub type BCC_R = crate::R; 15 | #[doc = "Write proxy for field `BCC`"] 16 | pub struct BCC_W<'a> { 17 | w: &'a mut W, 18 | } 19 | impl<'a> BCC_W<'a> { 20 | #[doc = r"Writes raw bits to the field"] 21 | #[inline(always)] 22 | pub unsafe fn bits(self, value: u32) -> &'a mut W { 23 | self.w.bits = (self.w.bits & !0xffff_ffff) | ((value as u32) & 0xffff_ffff); 24 | self.w 25 | } 26 | } 27 | impl R { 28 | #[doc = "Bits 0:31 - Bit counter compare"] 29 | #[inline(always)] 30 | pub fn bcc(&self) -> BCC_R { 31 | BCC_R::new((self.bits & 0xffff_ffff) as u32) 32 | } 33 | } 34 | impl W { 35 | #[doc = "Bits 0:31 - Bit counter compare"] 36 | #[inline(always)] 37 | pub fn bcc(&mut self) -> BCC_W { 38 | BCC_W { w: self } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/spi0/txd.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TXD"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register TXD"] 4 | pub type W = crate::W; 5 | #[doc = "Register TXD `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::TXD { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | #[doc = "Reader of field `TXD`"] 14 | pub type TXD_R = crate::R; 15 | #[doc = "Write proxy for field `TXD`"] 16 | pub struct TXD_W<'a> { 17 | w: &'a mut W, 18 | } 19 | impl<'a> TXD_W<'a> { 20 | #[doc = r"Writes raw bits to the field"] 21 | #[inline(always)] 22 | pub unsafe fn bits(self, value: u8) -> &'a mut W { 23 | self.w.bits = (self.w.bits & !0xff) | ((value as u32) & 0xff); 24 | self.w 25 | } 26 | } 27 | impl R { 28 | #[doc = "Bits 0:7 - TX data to send. Double buffered"] 29 | #[inline(always)] 30 | pub fn txd(&self) -> TXD_R { 31 | TXD_R::new((self.bits & 0xff) as u8) 32 | } 33 | } 34 | impl W { 35 | #[doc = "Bits 0:7 - TX data to send. Double buffered"] 36 | #[inline(always)] 37 | pub fn txd(&mut self) -> TXD_W { 38 | TXD_W { w: self } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/spis0/rxd/ptr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PTR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register PTR"] 4 | pub type W = crate::W; 5 | #[doc = "Register PTR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::PTR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | #[doc = "Reader of field `PTR`"] 14 | pub type PTR_R = crate::R; 15 | #[doc = "Write proxy for field `PTR`"] 16 | pub struct PTR_W<'a> { 17 | w: &'a mut W, 18 | } 19 | impl<'a> PTR_W<'a> { 20 | #[doc = r"Writes raw bits to the field"] 21 | #[inline(always)] 22 | pub unsafe fn bits(self, value: u32) -> &'a mut W { 23 | self.w.bits = (self.w.bits & !0xffff_ffff) | ((value as u32) & 0xffff_ffff); 24 | self.w 25 | } 26 | } 27 | impl R { 28 | #[doc = "Bits 0:31 - RXD data pointer"] 29 | #[inline(always)] 30 | pub fn ptr(&self) -> PTR_R { 31 | PTR_R::new((self.bits & 0xffff_ffff) as u32) 32 | } 33 | } 34 | impl W { 35 | #[doc = "Bits 0:31 - RXD data pointer"] 36 | #[inline(always)] 37 | pub fn ptr(&mut self) -> PTR_W { 38 | PTR_W { w: self } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/spis0/txd/ptr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PTR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register PTR"] 4 | pub type W = crate::W; 5 | #[doc = "Register PTR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::PTR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | #[doc = "Reader of field `PTR`"] 14 | pub type PTR_R = crate::R; 15 | #[doc = "Write proxy for field `PTR`"] 16 | pub struct PTR_W<'a> { 17 | w: &'a mut W, 18 | } 19 | impl<'a> PTR_W<'a> { 20 | #[doc = r"Writes raw bits to the field"] 21 | #[inline(always)] 22 | pub unsafe fn bits(self, value: u32) -> &'a mut W { 23 | self.w.bits = (self.w.bits & !0xffff_ffff) | ((value as u32) & 0xffff_ffff); 24 | self.w 25 | } 26 | } 27 | impl R { 28 | #[doc = "Bits 0:31 - TXD data pointer"] 29 | #[inline(always)] 30 | pub fn ptr(&self) -> PTR_R { 31 | PTR_R::new((self.bits & 0xffff_ffff) as u32) 32 | } 33 | } 34 | impl W { 35 | #[doc = "Bits 0:31 - TXD data pointer"] 36 | #[inline(always)] 37 | pub fn ptr(&mut self) -> PTR_W { 38 | PTR_W { w: self } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/twis0/rxd/ptr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PTR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register PTR"] 4 | pub type W = crate::W; 5 | #[doc = "Register PTR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::PTR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | #[doc = "Reader of field `PTR`"] 14 | pub type PTR_R = crate::R; 15 | #[doc = "Write proxy for field `PTR`"] 16 | pub struct PTR_W<'a> { 17 | w: &'a mut W, 18 | } 19 | impl<'a> PTR_W<'a> { 20 | #[doc = r"Writes raw bits to the field"] 21 | #[inline(always)] 22 | pub unsafe fn bits(self, value: u32) -> &'a mut W { 23 | self.w.bits = (self.w.bits & !0xffff_ffff) | ((value as u32) & 0xffff_ffff); 24 | self.w 25 | } 26 | } 27 | impl R { 28 | #[doc = "Bits 0:31 - RXD Data pointer"] 29 | #[inline(always)] 30 | pub fn ptr(&self) -> PTR_R { 31 | PTR_R::new((self.bits & 0xffff_ffff) as u32) 32 | } 33 | } 34 | impl W { 35 | #[doc = "Bits 0:31 - RXD Data pointer"] 36 | #[inline(always)] 37 | pub fn ptr(&mut self) -> PTR_W { 38 | PTR_W { w: self } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/twis0/txd/ptr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PTR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register PTR"] 4 | pub type W = crate::W; 5 | #[doc = "Register PTR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::PTR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | #[doc = "Reader of field `PTR`"] 14 | pub type PTR_R = crate::R; 15 | #[doc = "Write proxy for field `PTR`"] 16 | pub struct PTR_W<'a> { 17 | w: &'a mut W, 18 | } 19 | impl<'a> PTR_W<'a> { 20 | #[doc = r"Writes raw bits to the field"] 21 | #[inline(always)] 22 | pub unsafe fn bits(self, value: u32) -> &'a mut W { 23 | self.w.bits = (self.w.bits & !0xffff_ffff) | ((value as u32) & 0xffff_ffff); 24 | self.w 25 | } 26 | } 27 | impl R { 28 | #[doc = "Bits 0:31 - TXD Data pointer"] 29 | #[inline(always)] 30 | pub fn ptr(&self) -> PTR_R { 31 | PTR_R::new((self.bits & 0xffff_ffff) as u32) 32 | } 33 | } 34 | impl W { 35 | #[doc = "Bits 0:31 - TXD Data pointer"] 36 | #[inline(always)] 37 | pub fn ptr(&mut self) -> PTR_W { 38 | PTR_W { w: self } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/radio/tifs.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TIFS"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register TIFS"] 4 | pub type W = crate::W; 5 | #[doc = "Register TIFS `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::TIFS { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | #[doc = "Reader of field `TIFS`"] 14 | pub type TIFS_R = crate::R; 15 | #[doc = "Write proxy for field `TIFS`"] 16 | pub struct TIFS_W<'a> { 17 | w: &'a mut W, 18 | } 19 | impl<'a> TIFS_W<'a> { 20 | #[doc = r"Writes raw bits to the field"] 21 | #[inline(always)] 22 | pub unsafe fn bits(self, value: u8) -> &'a mut W { 23 | self.w.bits = (self.w.bits & !0xff) | ((value as u32) & 0xff); 24 | self.w 25 | } 26 | } 27 | impl R { 28 | #[doc = "Bits 0:7 - Inter Frame Spacing in us"] 29 | #[inline(always)] 30 | pub fn tifs(&self) -> TIFS_R { 31 | TIFS_R::new((self.bits & 0xff) as u8) 32 | } 33 | } 34 | impl W { 35 | #[doc = "Bits 0:7 - Inter Frame Spacing in us"] 36 | #[inline(always)] 37 | pub fn tifs(&mut self) -> TIFS_W { 38 | TIFS_W { w: self } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/temp/t1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register T1"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register T1"] 4 | pub type W = crate::W; 5 | #[doc = "Register T1 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::T1 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | #[doc = "Reader of field `T1`"] 14 | pub type T1_R = crate::R; 15 | #[doc = "Write proxy for field `T1`"] 16 | pub struct T1_W<'a> { 17 | w: &'a mut W, 18 | } 19 | impl<'a> T1_W<'a> { 20 | #[doc = r"Writes raw bits to the field"] 21 | #[inline(always)] 22 | pub unsafe fn bits(self, value: u8) -> &'a mut W { 23 | self.w.bits = (self.w.bits & !0xff) | ((value as u32) & 0xff); 24 | self.w 25 | } 26 | } 27 | impl R { 28 | #[doc = "Bits 0:7 - End point of 2nd piece wise linear function"] 29 | #[inline(always)] 30 | pub fn t1(&self) -> T1_R { 31 | T1_R::new((self.bits & 0xff) as u8) 32 | } 33 | } 34 | impl W { 35 | #[doc = "Bits 0:7 - End point of 2nd piece wise linear function"] 36 | #[inline(always)] 37 | pub fn t1(&mut self) -> T1_W { 38 | T1_W { w: self } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/timer0/cc.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register CC[%s]"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register CC[%s]"] 4 | pub type W = crate::W; 5 | #[doc = "Register CC[%s] 6 | `reset()`'s with value 0"] 7 | impl crate::ResetValue for super::CC { 8 | type Type = u32; 9 | #[inline(always)] 10 | fn reset_value() -> Self::Type { 11 | 0 12 | } 13 | } 14 | #[doc = "Reader of field `CC`"] 15 | pub type CC_R = crate::R; 16 | #[doc = "Write proxy for field `CC`"] 17 | pub struct CC_W<'a> { 18 | w: &'a mut W, 19 | } 20 | impl<'a> CC_W<'a> { 21 | #[doc = r"Writes raw bits to the field"] 22 | #[inline(always)] 23 | pub unsafe fn bits(self, value: u32) -> &'a mut W { 24 | self.w.bits = (self.w.bits & !0xffff_ffff) | ((value as u32) & 0xffff_ffff); 25 | self.w 26 | } 27 | } 28 | impl R { 29 | #[doc = "Bits 0:31 - Capture/Compare value"] 30 | #[inline(always)] 31 | pub fn cc(&self) -> CC_R { 32 | CC_R::new((self.bits & 0xffff_ffff) as u32) 33 | } 34 | } 35 | impl W { 36 | #[doc = "Bits 0:31 - Capture/Compare value"] 37 | #[inline(always)] 38 | pub fn cc(&mut self) -> CC_W { 39 | CC_W { w: self } 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/timer3/cc.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register CC[%s]"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register CC[%s]"] 4 | pub type W = crate::W; 5 | #[doc = "Register CC[%s] 6 | `reset()`'s with value 0"] 7 | impl crate::ResetValue for super::CC { 8 | type Type = u32; 9 | #[inline(always)] 10 | fn reset_value() -> Self::Type { 11 | 0 12 | } 13 | } 14 | #[doc = "Reader of field `CC`"] 15 | pub type CC_R = crate::R; 16 | #[doc = "Write proxy for field `CC`"] 17 | pub struct CC_W<'a> { 18 | w: &'a mut W, 19 | } 20 | impl<'a> CC_W<'a> { 21 | #[doc = r"Writes raw bits to the field"] 22 | #[inline(always)] 23 | pub unsafe fn bits(self, value: u32) -> &'a mut W { 24 | self.w.bits = (self.w.bits & !0xffff_ffff) | ((value as u32) & 0xffff_ffff); 25 | self.w 26 | } 27 | } 28 | impl R { 29 | #[doc = "Bits 0:31 - Capture/Compare value"] 30 | #[inline(always)] 31 | pub fn cc(&self) -> CC_R { 32 | CC_R::new((self.bits & 0xffff_ffff) as u32) 33 | } 34 | } 35 | impl W { 36 | #[doc = "Bits 0:31 - Capture/Compare value"] 37 | #[inline(always)] 38 | pub fn cc(&mut self) -> CC_W { 39 | CC_W { w: self } 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/radio/dap.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register DAP[%s]"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register DAP[%s]"] 4 | pub type W = crate::W; 5 | #[doc = "Register DAP[%s] 6 | `reset()`'s with value 0"] 7 | impl crate::ResetValue for super::DAP { 8 | type Type = u32; 9 | #[inline(always)] 10 | fn reset_value() -> Self::Type { 11 | 0 12 | } 13 | } 14 | #[doc = "Reader of field `DAP`"] 15 | pub type DAP_R = crate::R; 16 | #[doc = "Write proxy for field `DAP`"] 17 | pub struct DAP_W<'a> { 18 | w: &'a mut W, 19 | } 20 | impl<'a> DAP_W<'a> { 21 | #[doc = r"Writes raw bits to the field"] 22 | #[inline(always)] 23 | pub unsafe fn bits(self, value: u16) -> &'a mut W { 24 | self.w.bits = (self.w.bits & !0xffff) | ((value as u32) & 0xffff); 25 | self.w 26 | } 27 | } 28 | impl R { 29 | #[doc = "Bits 0:15 - Device address prefix 0"] 30 | #[inline(always)] 31 | pub fn dap(&self) -> DAP_R { 32 | DAP_R::new((self.bits & 0xffff) as u16) 33 | } 34 | } 35 | impl W { 36 | #[doc = "Bits 0:15 - Device address prefix 0"] 37 | #[inline(always)] 38 | pub fn dap(&mut self) -> DAP_W { 39 | DAP_W { w: self } 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/temp/t0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register T0"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register T0"] 4 | pub type W = crate::W; 5 | #[doc = "Register T0 `reset()`'s with value 0xe2"] 6 | impl crate::ResetValue for super::T0 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0xe2 11 | } 12 | } 13 | #[doc = "Reader of field `T0`"] 14 | pub type T0_R = crate::R; 15 | #[doc = "Write proxy for field `T0`"] 16 | pub struct T0_W<'a> { 17 | w: &'a mut W, 18 | } 19 | impl<'a> T0_W<'a> { 20 | #[doc = r"Writes raw bits to the field"] 21 | #[inline(always)] 22 | pub unsafe fn bits(self, value: u8) -> &'a mut W { 23 | self.w.bits = (self.w.bits & !0xff) | ((value as u32) & 0xff); 24 | self.w 25 | } 26 | } 27 | impl R { 28 | #[doc = "Bits 0:7 - End point of 1st piece wise linear function"] 29 | #[inline(always)] 30 | pub fn t0(&self) -> T0_R { 31 | T0_R::new((self.bits & 0xff) as u8) 32 | } 33 | } 34 | impl W { 35 | #[doc = "Bits 0:7 - End point of 1st piece wise linear function"] 36 | #[inline(always)] 37 | pub fn t0(&mut self) -> T0_W { 38 | T0_W { w: self } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/temp/t2.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register T2"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register T2"] 4 | pub type W = crate::W; 5 | #[doc = "Register T2 `reset()`'s with value 0x14"] 6 | impl crate::ResetValue for super::T2 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0x14 11 | } 12 | } 13 | #[doc = "Reader of field `T2`"] 14 | pub type T2_R = crate::R; 15 | #[doc = "Write proxy for field `T2`"] 16 | pub struct T2_W<'a> { 17 | w: &'a mut W, 18 | } 19 | impl<'a> T2_W<'a> { 20 | #[doc = r"Writes raw bits to the field"] 21 | #[inline(always)] 22 | pub unsafe fn bits(self, value: u8) -> &'a mut W { 23 | self.w.bits = (self.w.bits & !0xff) | ((value as u32) & 0xff); 24 | self.w 25 | } 26 | } 27 | impl R { 28 | #[doc = "Bits 0:7 - End point of 3rd piece wise linear function"] 29 | #[inline(always)] 30 | pub fn t2(&self) -> T2_R { 31 | T2_R::new((self.bits & 0xff) as u8) 32 | } 33 | } 34 | impl W { 35 | #[doc = "Bits 0:7 - End point of 3rd piece wise linear function"] 36 | #[inline(always)] 37 | pub fn t2(&mut self) -> T2_W { 38 | T2_W { w: self } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/temp/t3.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register T3"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register T3"] 4 | pub type W = crate::W; 5 | #[doc = "Register T3 `reset()`'s with value 0x19"] 6 | impl crate::ResetValue for super::T3 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0x19 11 | } 12 | } 13 | #[doc = "Reader of field `T3`"] 14 | pub type T3_R = crate::R; 15 | #[doc = "Write proxy for field `T3`"] 16 | pub struct T3_W<'a> { 17 | w: &'a mut W, 18 | } 19 | impl<'a> T3_W<'a> { 20 | #[doc = r"Writes raw bits to the field"] 21 | #[inline(always)] 22 | pub unsafe fn bits(self, value: u8) -> &'a mut W { 23 | self.w.bits = (self.w.bits & !0xff) | ((value as u32) & 0xff); 24 | self.w 25 | } 26 | } 27 | impl R { 28 | #[doc = "Bits 0:7 - End point of 4th piece wise linear function"] 29 | #[inline(always)] 30 | pub fn t3(&self) -> T3_R { 31 | T3_R::new((self.bits & 0xff) as u8) 32 | } 33 | } 34 | impl W { 35 | #[doc = "Bits 0:7 - End point of 4th piece wise linear function"] 36 | #[inline(always)] 37 | pub fn t3(&mut self) -> T3_W { 38 | T3_W { w: self } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/temp/t4.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register T4"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register T4"] 4 | pub type W = crate::W; 5 | #[doc = "Register T4 `reset()`'s with value 0x50"] 6 | impl crate::ResetValue for super::T4 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0x50 11 | } 12 | } 13 | #[doc = "Reader of field `T4`"] 14 | pub type T4_R = crate::R; 15 | #[doc = "Write proxy for field `T4`"] 16 | pub struct T4_W<'a> { 17 | w: &'a mut W, 18 | } 19 | impl<'a> T4_W<'a> { 20 | #[doc = r"Writes raw bits to the field"] 21 | #[inline(always)] 22 | pub unsafe fn bits(self, value: u8) -> &'a mut W { 23 | self.w.bits = (self.w.bits & !0xff) | ((value as u32) & 0xff); 24 | self.w 25 | } 26 | } 27 | impl R { 28 | #[doc = "Bits 0:7 - End point of 5th piece wise linear function"] 29 | #[inline(always)] 30 | pub fn t4(&self) -> T4_R { 31 | T4_R::new((self.bits & 0xff) as u8) 32 | } 33 | } 34 | impl W { 35 | #[doc = "Bits 0:7 - End point of 5th piece wise linear function"] 36 | #[inline(always)] 37 | pub fn t4(&mut self) -> T4_W { 38 | T4_W { w: self } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/mwu/region/end.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register END"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register END"] 4 | pub type W = crate::W; 5 | #[doc = "Register END `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::END { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | #[doc = "Reader of field `END`"] 14 | pub type END_R = crate::R; 15 | #[doc = "Write proxy for field `END`"] 16 | pub struct END_W<'a> { 17 | w: &'a mut W, 18 | } 19 | impl<'a> END_W<'a> { 20 | #[doc = r"Writes raw bits to the field"] 21 | #[inline(always)] 22 | pub unsafe fn bits(self, value: u32) -> &'a mut W { 23 | self.w.bits = (self.w.bits & !0xffff_ffff) | ((value as u32) & 0xffff_ffff); 24 | self.w 25 | } 26 | } 27 | impl R { 28 | #[doc = "Bits 0:31 - End address of region."] 29 | #[inline(always)] 30 | pub fn end(&self) -> END_R { 31 | END_R::new((self.bits & 0xffff_ffff) as u32) 32 | } 33 | } 34 | impl W { 35 | #[doc = "Bits 0:31 - End address of region."] 36 | #[inline(always)] 37 | pub fn end(&mut self) -> END_W { 38 | END_W { w: self } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/ppi/fork/tep.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TEP"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register TEP"] 4 | pub type W = crate::W; 5 | #[doc = "Register TEP `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::TEP { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | #[doc = "Reader of field `TEP`"] 14 | pub type TEP_R = crate::R; 15 | #[doc = "Write proxy for field `TEP`"] 16 | pub struct TEP_W<'a> { 17 | w: &'a mut W, 18 | } 19 | impl<'a> TEP_W<'a> { 20 | #[doc = r"Writes raw bits to the field"] 21 | #[inline(always)] 22 | pub unsafe fn bits(self, value: u32) -> &'a mut W { 23 | self.w.bits = (self.w.bits & !0xffff_ffff) | ((value as u32) & 0xffff_ffff); 24 | self.w 25 | } 26 | } 27 | impl R { 28 | #[doc = "Bits 0:31 - Pointer to task register"] 29 | #[inline(always)] 30 | pub fn tep(&self) -> TEP_R { 31 | TEP_R::new((self.bits & 0xffff_ffff) as u32) 32 | } 33 | } 34 | impl W { 35 | #[doc = "Bits 0:31 - Pointer to task register"] 36 | #[inline(always)] 37 | pub fn tep(&mut self) -> TEP_W { 38 | TEP_W { w: self } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/nvmc/ihit.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register IHIT"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register IHIT"] 4 | pub type W = crate::W; 5 | #[doc = "Register IHIT `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::IHIT { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | #[doc = "Reader of field `HITS`"] 14 | pub type HITS_R = crate::R; 15 | #[doc = "Write proxy for field `HITS`"] 16 | pub struct HITS_W<'a> { 17 | w: &'a mut W, 18 | } 19 | impl<'a> HITS_W<'a> { 20 | #[doc = r"Writes raw bits to the field"] 21 | #[inline(always)] 22 | pub unsafe fn bits(self, value: u32) -> &'a mut W { 23 | self.w.bits = (self.w.bits & !0xffff_ffff) | ((value as u32) & 0xffff_ffff); 24 | self.w 25 | } 26 | } 27 | impl R { 28 | #[doc = "Bits 0:31 - Number of cache hits"] 29 | #[inline(always)] 30 | pub fn hits(&self) -> HITS_R { 31 | HITS_R::new((self.bits & 0xffff_ffff) as u32) 32 | } 33 | } 34 | impl W { 35 | #[doc = "Bits 0:31 - Number of cache hits"] 36 | #[inline(always)] 37 | pub fn hits(&mut self) -> HITS_W { 38 | HITS_W { w: self } 39 | } 40 | } 41 | --------------------------------------------------------------------------------