#[doc = "Register `CR` reader"]
pub struct R(crate::R<CR_SPEC>);
impl core::ops::Deref for R {
type Target = crate::R<CR_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<CR_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<CR_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `CR` writer"]
pub struct W(crate::W<CR_SPEC>);
impl core::ops::Deref for W {
type Target = crate::W<CR_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<CR_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<CR_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Wakeup clock selection\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(u8)]
pub enum WUCKSEL_A {
#[doc = "0: RTC/16 clock is selected"]
Div16 = 0,
#[doc = "1: RTC/8 clock is selected"]
Div8 = 1,
#[doc = "2: RTC/4 clock is selected"]
Div4 = 2,
#[doc = "3: RTC/2 clock is selected"]
Div2 = 3,
#[doc = "4: ck_spre (usually 1 Hz) clock is selected"]
ClockSpare = 4,
#[doc = "6: ck_spre (usually 1 Hz) clock is selected and 2^16 is added to the WUT counter value"]
ClockSpareWithOffset = 6,
}
impl From<WUCKSEL_A> for u8 {
#[inline(always)]
fn from(variant: WUCKSEL_A) -> Self {
variant as _
}
}
#[doc = "Field `WUCKSEL` reader - Wakeup clock selection"]
pub type WUCKSEL_R = crate::FieldReader<u8, WUCKSEL_A>;
impl WUCKSEL_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> Option<WUCKSEL_A> {
match self.bits {
0 => Some(WUCKSEL_A::Div16),
1 => Some(WUCKSEL_A::Div8),
2 => Some(WUCKSEL_A::Div4),
3 => Some(WUCKSEL_A::Div2),
4 => Some(WUCKSEL_A::ClockSpare),
6 => Some(WUCKSEL_A::ClockSpareWithOffset),
_ => None,
}
}
#[doc = "Checks if the value of the field is `Div16`"]
#[inline(always)]
pub fn is_div16(&self) -> bool {
*self == WUCKSEL_A::Div16
}
#[doc = "Checks if the value of the field is `Div8`"]
#[inline(always)]
pub fn is_div8(&self) -> bool {
*self == WUCKSEL_A::Div8
}
#[doc = "Checks if the value of the field is `Div4`"]
#[inline(always)]
pub fn is_div4(&self) -> bool {
*self == WUCKSEL_A::Div4
}
#[doc = "Checks if the value of the field is `Div2`"]
#[inline(always)]
pub fn is_div2(&self) -> bool {
*self == WUCKSEL_A::Div2
}
#[doc = "Checks if the value of the field is `ClockSpare`"]
#[inline(always)]
pub fn is_clock_spare(&self) -> bool {
*self == WUCKSEL_A::ClockSpare
}
#[doc = "Checks if the value of the field is `ClockSpareWithOffset`"]
#[inline(always)]
pub fn is_clock_spare_with_offset(&self) -> bool {
*self == WUCKSEL_A::ClockSpareWithOffset
}
}
#[doc = "Field `WUCKSEL` writer - Wakeup clock selection"]
pub type WUCKSEL_W<'a> = crate::FieldWriter<'a, u32, CR_SPEC, u8, WUCKSEL_A, 3, 0>;
impl<'a> WUCKSEL_W<'a> {
#[doc = "RTC/16 clock is selected"]
#[inline(always)]
pub fn div16(self) -> &'a mut W {
self.variant(WUCKSEL_A::Div16)
}
#[doc = "RTC/8 clock is selected"]
#[inline(always)]
pub fn div8(self) -> &'a mut W {
self.variant(WUCKSEL_A::Div8)
}
#[doc = "RTC/4 clock is selected"]
#[inline(always)]
pub fn div4(self) -> &'a mut W {
self.variant(WUCKSEL_A::Div4)
}
#[doc = "RTC/2 clock is selected"]
#[inline(always)]
pub fn div2(self) -> &'a mut W {
self.variant(WUCKSEL_A::Div2)
}
#[doc = "ck_spre (usually 1 Hz) clock is selected"]
#[inline(always)]
pub fn clock_spare(self) -> &'a mut W {
self.variant(WUCKSEL_A::ClockSpare)
}
#[doc = "ck_spre (usually 1 Hz) clock is selected and 2^16 is added to the WUT counter value"]
#[inline(always)]
pub fn clock_spare_with_offset(self) -> &'a mut W {
self.variant(WUCKSEL_A::ClockSpareWithOffset)
}
}
#[doc = "Time-stamp event active edge\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TSEDGE_A {
#[doc = "0: RTC_TS input rising edge generates a time-stamp event"]
RisingEdge = 0,
#[doc = "1: RTC_TS input falling edge generates a time-stamp event"]
FallingEdge = 1,
}
impl From<TSEDGE_A> for bool {
#[inline(always)]
fn from(variant: TSEDGE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `TSEDGE` reader - Time-stamp event active edge"]
pub type TSEDGE_R = crate::BitReader<TSEDGE_A>;
impl TSEDGE_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> TSEDGE_A {
match self.bits {
false => TSEDGE_A::RisingEdge,
true => TSEDGE_A::FallingEdge,
}
}
#[doc = "Checks if the value of the field is `RisingEdge`"]
#[inline(always)]
pub fn is_rising_edge(&self) -> bool {
*self == TSEDGE_A::RisingEdge
}
#[doc = "Checks if the value of the field is `FallingEdge`"]
#[inline(always)]
pub fn is_falling_edge(&self) -> bool {
*self == TSEDGE_A::FallingEdge
}
}
#[doc = "Field `TSEDGE` writer - Time-stamp event active edge"]
pub type TSEDGE_W<'a> = crate::BitWriter<'a, u32, CR_SPEC, TSEDGE_A, 3>;
impl<'a> TSEDGE_W<'a> {
#[doc = "RTC_TS input rising edge generates a time-stamp event"]
#[inline(always)]
pub fn rising_edge(self) -> &'a mut W {
self.variant(TSEDGE_A::RisingEdge)
}
#[doc = "RTC_TS input falling edge generates a time-stamp event"]
#[inline(always)]
pub fn falling_edge(self) -> &'a mut W {
self.variant(TSEDGE_A::FallingEdge)
}
}
#[doc = "Reference clock detection enable (50 or 60 Hz)\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum REFCKON_A {
#[doc = "0: RTC_REFIN detection disabled"]
Disabled = 0,
#[doc = "1: RTC_REFIN detection enabled"]
Enabled = 1,
}
impl From<REFCKON_A> for bool {
#[inline(always)]
fn from(variant: REFCKON_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `REFCKON` reader - Reference clock detection enable (50 or 60 Hz)"]
pub type REFCKON_R = crate::BitReader<REFCKON_A>;
impl REFCKON_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> REFCKON_A {
match self.bits {
false => REFCKON_A::Disabled,
true => REFCKON_A::Enabled,
}
}
#[doc = "Checks if the value of the field is `Disabled`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == REFCKON_A::Disabled
}
#[doc = "Checks if the value of the field is `Enabled`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == REFCKON_A::Enabled
}
}
#[doc = "Field `REFCKON` writer - Reference clock detection enable (50 or 60 Hz)"]
pub type REFCKON_W<'a> = crate::BitWriter<'a, u32, CR_SPEC, REFCKON_A, 4>;
impl<'a> REFCKON_W<'a> {
#[doc = "RTC_REFIN detection disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(REFCKON_A::Disabled)
}
#[doc = "RTC_REFIN detection enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(REFCKON_A::Enabled)
}
}
#[doc = "Bypass the shadow registers\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum BYPSHAD_A {
#[doc = "0: Calendar values (when reading from RTC_SSR, RTC_TR, and RTC_DR) are taken from the shadow registers, which are updated once every two RTCCLK cycles"]
ShadowReg = 0,
#[doc = "1: Calendar values (when reading from RTC_SSR, RTC_TR, and RTC_DR) are taken directly from the calendar counters"]
BypassShadowReg = 1,
}
impl From<BYPSHAD_A> for bool {
#[inline(always)]
fn from(variant: BYPSHAD_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `BYPSHAD` reader - Bypass the shadow registers"]
pub type BYPSHAD_R = crate::BitReader<BYPSHAD_A>;
impl BYPSHAD_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> BYPSHAD_A {
match self.bits {
false => BYPSHAD_A::ShadowReg,
true => BYPSHAD_A::BypassShadowReg,
}
}
#[doc = "Checks if the value of the field is `ShadowReg`"]
#[inline(always)]
pub fn is_shadow_reg(&self) -> bool {
*self == BYPSHAD_A::ShadowReg
}
#[doc = "Checks if the value of the field is `BypassShadowReg`"]
#[inline(always)]
pub fn is_bypass_shadow_reg(&self) -> bool {
*self == BYPSHAD_A::BypassShadowReg
}
}
#[doc = "Field `BYPSHAD` writer - Bypass the shadow registers"]
pub type BYPSHAD_W<'a> = crate::BitWriter<'a, u32, CR_SPEC, BYPSHAD_A, 5>;
impl<'a> BYPSHAD_W<'a> {
#[doc = "Calendar values (when reading from RTC_SSR, RTC_TR, and RTC_DR) are taken from the shadow registers, which are updated once every two RTCCLK cycles"]
#[inline(always)]
pub fn shadow_reg(self) -> &'a mut W {
self.variant(BYPSHAD_A::ShadowReg)
}
#[doc = "Calendar values (when reading from RTC_SSR, RTC_TR, and RTC_DR) are taken directly from the calendar counters"]
#[inline(always)]
pub fn bypass_shadow_reg(self) -> &'a mut W {
self.variant(BYPSHAD_A::BypassShadowReg)
}
}
#[doc = "Hour format\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum FMT_A {
#[doc = "0: 24 hour/day format"]
TwentyFourHour = 0,
#[doc = "1: AM/PM hour format"]
AmPm = 1,
}
impl From<FMT_A> for bool {
#[inline(always)]
fn from(variant: FMT_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `FMT` reader - Hour format"]
pub type FMT_R = crate::BitReader<FMT_A>;
impl FMT_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> FMT_A {
match self.bits {
false => FMT_A::TwentyFourHour,
true => FMT_A::AmPm,
}
}
#[doc = "Checks if the value of the field is `TwentyFourHour`"]
#[inline(always)]
pub fn is_twenty_four_hour(&self) -> bool {
*self == FMT_A::TwentyFourHour
}
#[doc = "Checks if the value of the field is `AmPm`"]
#[inline(always)]
pub fn is_am_pm(&self) -> bool {
*self == FMT_A::AmPm
}
}
#[doc = "Field `FMT` writer - Hour format"]
pub type FMT_W<'a> = crate::BitWriter<'a, u32, CR_SPEC, FMT_A, 6>;
impl<'a> FMT_W<'a> {
#[doc = "24 hour/day format"]
#[inline(always)]
pub fn twenty_four_hour(self) -> &'a mut W {
self.variant(FMT_A::TwentyFourHour)
}
#[doc = "AM/PM hour format"]
#[inline(always)]
pub fn am_pm(self) -> &'a mut W {
self.variant(FMT_A::AmPm)
}
}
#[doc = "Alarm A enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ALRAE_A {
#[doc = "0: Alarm A disabled"]
Disabled = 0,
#[doc = "1: Alarm A enabled"]
Enabled = 1,
}
impl From<ALRAE_A> for bool {
#[inline(always)]
fn from(variant: ALRAE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `ALRAE` reader - Alarm A enable"]
pub type ALRAE_R = crate::BitReader<ALRAE_A>;
impl ALRAE_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> ALRAE_A {
match self.bits {
false => ALRAE_A::Disabled,
true => ALRAE_A::Enabled,
}
}
#[doc = "Checks if the value of the field is `Disabled`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == ALRAE_A::Disabled
}
#[doc = "Checks if the value of the field is `Enabled`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == ALRAE_A::Enabled
}
}
#[doc = "Field `ALRAE` writer - Alarm A enable"]
pub type ALRAE_W<'a> = crate::BitWriter<'a, u32, CR_SPEC, ALRAE_A, 8>;
impl<'a> ALRAE_W<'a> {
#[doc = "Alarm A disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(ALRAE_A::Disabled)
}
#[doc = "Alarm A enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(ALRAE_A::Enabled)
}
}
#[doc = "Alarm B enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ALRBE_A {
#[doc = "0: Alarm B disabled"]
Disabled = 0,
#[doc = "1: Alarm B enabled"]
Enabled = 1,
}
impl From<ALRBE_A> for bool {
#[inline(always)]
fn from(variant: ALRBE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `ALRBE` reader - Alarm B enable"]
pub type ALRBE_R = crate::BitReader<ALRBE_A>;
impl ALRBE_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> ALRBE_A {
match self.bits {
false => ALRBE_A::Disabled,
true => ALRBE_A::Enabled,
}
}
#[doc = "Checks if the value of the field is `Disabled`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == ALRBE_A::Disabled
}
#[doc = "Checks if the value of the field is `Enabled`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == ALRBE_A::Enabled
}
}
#[doc = "Field `ALRBE` writer - Alarm B enable"]
pub type ALRBE_W<'a> = crate::BitWriter<'a, u32, CR_SPEC, ALRBE_A, 9>;
impl<'a> ALRBE_W<'a> {
#[doc = "Alarm B disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(ALRBE_A::Disabled)
}
#[doc = "Alarm B enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(ALRBE_A::Enabled)
}
}
#[doc = "Wakeup timer enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum WUTE_A {
#[doc = "0: Wakeup timer disabled"]
Disabled = 0,
#[doc = "1: Wakeup timer enabled"]
Enabled = 1,
}
impl From<WUTE_A> for bool {
#[inline(always)]
fn from(variant: WUTE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `WUTE` reader - Wakeup timer enable"]
pub type WUTE_R = crate::BitReader<WUTE_A>;
impl WUTE_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> WUTE_A {
match self.bits {
false => WUTE_A::Disabled,
true => WUTE_A::Enabled,
}
}
#[doc = "Checks if the value of the field is `Disabled`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == WUTE_A::Disabled
}
#[doc = "Checks if the value of the field is `Enabled`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == WUTE_A::Enabled
}
}
#[doc = "Field `WUTE` writer - Wakeup timer enable"]
pub type WUTE_W<'a> = crate::BitWriter<'a, u32, CR_SPEC, WUTE_A, 10>;
impl<'a> WUTE_W<'a> {
#[doc = "Wakeup timer disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(WUTE_A::Disabled)
}
#[doc = "Wakeup timer enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(WUTE_A::Enabled)
}
}
#[doc = "Time stamp enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TSE_A {
#[doc = "0: Timestamp disabled"]
Disabled = 0,
#[doc = "1: Timestamp enabled"]
Enabled = 1,
}
impl From<TSE_A> for bool {
#[inline(always)]
fn from(variant: TSE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `TSE` reader - Time stamp enable"]
pub type TSE_R = crate::BitReader<TSE_A>;
impl TSE_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> TSE_A {
match self.bits {
false => TSE_A::Disabled,
true => TSE_A::Enabled,
}
}
#[doc = "Checks if the value of the field is `Disabled`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == TSE_A::Disabled
}
#[doc = "Checks if the value of the field is `Enabled`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == TSE_A::Enabled
}
}
#[doc = "Field `TSE` writer - Time stamp enable"]
pub type TSE_W<'a> = crate::BitWriter<'a, u32, CR_SPEC, TSE_A, 11>;
impl<'a> TSE_W<'a> {
#[doc = "Timestamp disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(TSE_A::Disabled)
}
#[doc = "Timestamp enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(TSE_A::Enabled)
}
}
#[doc = "Alarm A interrupt enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ALRAIE_A {
#[doc = "0: Alarm A interrupt disabled"]
Disabled = 0,
#[doc = "1: Alarm A interrupt enabled"]
Enabled = 1,
}
impl From<ALRAIE_A> for bool {
#[inline(always)]
fn from(variant: ALRAIE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `ALRAIE` reader - Alarm A interrupt enable"]
pub type ALRAIE_R = crate::BitReader<ALRAIE_A>;
impl ALRAIE_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> ALRAIE_A {
match self.bits {
false => ALRAIE_A::Disabled,
true => ALRAIE_A::Enabled,
}
}
#[doc = "Checks if the value of the field is `Disabled`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == ALRAIE_A::Disabled
}
#[doc = "Checks if the value of the field is `Enabled`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == ALRAIE_A::Enabled
}
}
#[doc = "Field `ALRAIE` writer - Alarm A interrupt enable"]
pub type ALRAIE_W<'a> = crate::BitWriter<'a, u32, CR_SPEC, ALRAIE_A, 12>;
impl<'a> ALRAIE_W<'a> {
#[doc = "Alarm A interrupt disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(ALRAIE_A::Disabled)
}
#[doc = "Alarm A interrupt enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(ALRAIE_A::Enabled)
}
}
#[doc = "Alarm B interrupt enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ALRBIE_A {
#[doc = "0: Alarm B Interrupt disabled"]
Disabled = 0,
#[doc = "1: Alarm B Interrupt enabled"]
Enabled = 1,
}
impl From<ALRBIE_A> for bool {
#[inline(always)]
fn from(variant: ALRBIE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `ALRBIE` reader - Alarm B interrupt enable"]
pub type ALRBIE_R = crate::BitReader<ALRBIE_A>;
impl ALRBIE_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> ALRBIE_A {
match self.bits {
false => ALRBIE_A::Disabled,
true => ALRBIE_A::Enabled,
}
}
#[doc = "Checks if the value of the field is `Disabled`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == ALRBIE_A::Disabled
}
#[doc = "Checks if the value of the field is `Enabled`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == ALRBIE_A::Enabled
}
}
#[doc = "Field `ALRBIE` writer - Alarm B interrupt enable"]
pub type ALRBIE_W<'a> = crate::BitWriter<'a, u32, CR_SPEC, ALRBIE_A, 13>;
impl<'a> ALRBIE_W<'a> {
#[doc = "Alarm B Interrupt disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(ALRBIE_A::Disabled)
}
#[doc = "Alarm B Interrupt enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(ALRBIE_A::Enabled)
}
}
#[doc = "Wakeup timer interrupt enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum WUTIE_A {
#[doc = "0: Wakeup timer interrupt disabled"]
Disabled = 0,
#[doc = "1: Wakeup timer interrupt enabled"]
Enabled = 1,
}
impl From<WUTIE_A> for bool {
#[inline(always)]
fn from(variant: WUTIE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `WUTIE` reader - Wakeup timer interrupt enable"]
pub type WUTIE_R = crate::BitReader<WUTIE_A>;
impl WUTIE_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> WUTIE_A {
match self.bits {
false => WUTIE_A::Disabled,
true => WUTIE_A::Enabled,
}
}
#[doc = "Checks if the value of the field is `Disabled`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == WUTIE_A::Disabled
}
#[doc = "Checks if the value of the field is `Enabled`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == WUTIE_A::Enabled
}
}
#[doc = "Field `WUTIE` writer - Wakeup timer interrupt enable"]
pub type WUTIE_W<'a> = crate::BitWriter<'a, u32, CR_SPEC, WUTIE_A, 14>;
impl<'a> WUTIE_W<'a> {
#[doc = "Wakeup timer interrupt disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(WUTIE_A::Disabled)
}
#[doc = "Wakeup timer interrupt enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(WUTIE_A::Enabled)
}
}
#[doc = "Time-stamp interrupt enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TSIE_A {
#[doc = "0: Time-stamp Interrupt disabled"]
Disabled = 0,
#[doc = "1: Time-stamp Interrupt enabled"]
Enabled = 1,
}
impl From<TSIE_A> for bool {
#[inline(always)]
fn from(variant: TSIE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `TSIE` reader - Time-stamp interrupt enable"]
pub type TSIE_R = crate::BitReader<TSIE_A>;
impl TSIE_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> TSIE_A {
match self.bits {
false => TSIE_A::Disabled,
true => TSIE_A::Enabled,
}
}
#[doc = "Checks if the value of the field is `Disabled`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == TSIE_A::Disabled
}
#[doc = "Checks if the value of the field is `Enabled`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == TSIE_A::Enabled
}
}
#[doc = "Field `TSIE` writer - Time-stamp interrupt enable"]
pub type TSIE_W<'a> = crate::BitWriter<'a, u32, CR_SPEC, TSIE_A, 15>;
impl<'a> TSIE_W<'a> {
#[doc = "Time-stamp Interrupt disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(TSIE_A::Disabled)
}
#[doc = "Time-stamp Interrupt enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(TSIE_A::Enabled)
}
}
#[doc = "Add 1 hour (summer time change)\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADD1H_A {
#[doc = "1: Adds 1 hour to the current time. This can be used for summer time change outside initialization mode"]
Add1 = 1,
}
impl From<ADD1H_A> for bool {
#[inline(always)]
fn from(variant: ADD1H_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `ADD1H` reader - Add 1 hour (summer time change)"]
pub type ADD1H_R = crate::BitReader<ADD1H_A>;
impl ADD1H_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> Option<ADD1H_A> {
match self.bits {
true => Some(ADD1H_A::Add1),
_ => None,
}
}
#[doc = "Checks if the value of the field is `Add1`"]
#[inline(always)]
pub fn is_add1(&self) -> bool {
*self == ADD1H_A::Add1
}
}
#[doc = "Field `ADD1H` writer - Add 1 hour (summer time change)"]
pub type ADD1H_W<'a> = crate::BitWriter<'a, u32, CR_SPEC, ADD1H_A, 16>;
impl<'a> ADD1H_W<'a> {
#[doc = "Adds 1 hour to the current time. This can be used for summer time change outside initialization mode"]
#[inline(always)]
pub fn add1(self) -> &'a mut W {
self.variant(ADD1H_A::Add1)
}
}
#[doc = "Subtract 1 hour (winter time change)\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum SUB1H_A {
#[doc = "1: Subtracts 1 hour to the current time. This can be used for winter time change outside initialization mode"]
Sub1 = 1,
}
impl From<SUB1H_A> for bool {
#[inline(always)]
fn from(variant: SUB1H_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `SUB1H` reader - Subtract 1 hour (winter time change)"]
pub type SUB1H_R = crate::BitReader<SUB1H_A>;
impl SUB1H_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> Option<SUB1H_A> {
match self.bits {
true => Some(SUB1H_A::Sub1),
_ => None,
}
}
#[doc = "Checks if the value of the field is `Sub1`"]
#[inline(always)]
pub fn is_sub1(&self) -> bool {
*self == SUB1H_A::Sub1
}
}
#[doc = "Field `SUB1H` writer - Subtract 1 hour (winter time change)"]
pub type SUB1H_W<'a> = crate::BitWriter<'a, u32, CR_SPEC, SUB1H_A, 17>;
impl<'a> SUB1H_W<'a> {
#[doc = "Subtracts 1 hour to the current time. This can be used for winter time change outside initialization mode"]
#[inline(always)]
pub fn sub1(self) -> &'a mut W {
self.variant(SUB1H_A::Sub1)
}
}
#[doc = "Backup\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum BKP_A {
#[doc = "0: Daylight Saving Time change has not been performed"]
DstNotChanged = 0,
#[doc = "1: Daylight Saving Time change has been performed"]
DstChanged = 1,
}
impl From<BKP_A> for bool {
#[inline(always)]
fn from(variant: BKP_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `BKP` reader - Backup"]
pub type BKP_R = crate::BitReader<BKP_A>;
impl BKP_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> BKP_A {
match self.bits {
false => BKP_A::DstNotChanged,
true => BKP_A::DstChanged,
}
}
#[doc = "Checks if the value of the field is `DstNotChanged`"]
#[inline(always)]
pub fn is_dst_not_changed(&self) -> bool {
*self == BKP_A::DstNotChanged
}
#[doc = "Checks if the value of the field is `DstChanged`"]
#[inline(always)]
pub fn is_dst_changed(&self) -> bool {
*self == BKP_A::DstChanged
}
}
#[doc = "Field `BKP` writer - Backup"]
pub type BKP_W<'a> = crate::BitWriter<'a, u32, CR_SPEC, BKP_A, 18>;
impl<'a> BKP_W<'a> {
#[doc = "Daylight Saving Time change has not been performed"]
#[inline(always)]
pub fn dst_not_changed(self) -> &'a mut W {
self.variant(BKP_A::DstNotChanged)
}
#[doc = "Daylight Saving Time change has been performed"]
#[inline(always)]
pub fn dst_changed(self) -> &'a mut W {
self.variant(BKP_A::DstChanged)
}
}
#[doc = "Calibration output selection\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum COSEL_A {
#[doc = "0: Calibration output is 512 Hz (with default prescaler setting)"]
CalFreq512hz = 0,
#[doc = "1: Calibration output is 1 Hz (with default prescaler setting)"]
CalFreq1hz = 1,
}
impl From<COSEL_A> for bool {
#[inline(always)]
fn from(variant: COSEL_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `COSEL` reader - Calibration output selection"]
pub type COSEL_R = crate::BitReader<COSEL_A>;
impl COSEL_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> COSEL_A {
match self.bits {
false => COSEL_A::CalFreq512hz,
true => COSEL_A::CalFreq1hz,
}
}
#[doc = "Checks if the value of the field is `CalFreq512hz`"]
#[inline(always)]
pub fn is_cal_freq_512hz(&self) -> bool {
*self == COSEL_A::CalFreq512hz
}
#[doc = "Checks if the value of the field is `CalFreq1hz`"]
#[inline(always)]
pub fn is_cal_freq_1hz(&self) -> bool {
*self == COSEL_A::CalFreq1hz
}
}
#[doc = "Field `COSEL` writer - Calibration output selection"]
pub type COSEL_W<'a> = crate::BitWriter<'a, u32, CR_SPEC, COSEL_A, 19>;
impl<'a> COSEL_W<'a> {
#[doc = "Calibration output is 512 Hz (with default prescaler setting)"]
#[inline(always)]
pub fn cal_freq_512hz(self) -> &'a mut W {
self.variant(COSEL_A::CalFreq512hz)
}
#[doc = "Calibration output is 1 Hz (with default prescaler setting)"]
#[inline(always)]
pub fn cal_freq_1hz(self) -> &'a mut W {
self.variant(COSEL_A::CalFreq1hz)
}
}
#[doc = "Output polarity\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum POL_A {
#[doc = "0: The pin is high when ALRAF/ALRBF/WUTF is asserted (depending on OSEL\\[1:0\\])"]
High = 0,
#[doc = "1: The pin is low when ALRAF/ALRBF/WUTF is asserted (depending on OSEL\\[1:0\\])"]
Low = 1,
}
impl From<POL_A> for bool {
#[inline(always)]
fn from(variant: POL_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `POL` reader - Output polarity"]
pub type POL_R = crate::BitReader<POL_A>;
impl POL_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> POL_A {
match self.bits {
false => POL_A::High,
true => POL_A::Low,
}
}
#[doc = "Checks if the value of the field is `High`"]
#[inline(always)]
pub fn is_high(&self) -> bool {
*self == POL_A::High
}
#[doc = "Checks if the value of the field is `Low`"]
#[inline(always)]
pub fn is_low(&self) -> bool {
*self == POL_A::Low
}
}
#[doc = "Field `POL` writer - Output polarity"]
pub type POL_W<'a> = crate::BitWriter<'a, u32, CR_SPEC, POL_A, 20>;
impl<'a> POL_W<'a> {
#[doc = "The pin is high when ALRAF/ALRBF/WUTF is asserted (depending on OSEL\\[1:0\\])"]
#[inline(always)]
pub fn high(self) -> &'a mut W {
self.variant(POL_A::High)
}
#[doc = "The pin is low when ALRAF/ALRBF/WUTF is asserted (depending on OSEL\\[1:0\\])"]
#[inline(always)]
pub fn low(self) -> &'a mut W {
self.variant(POL_A::Low)
}
}
#[doc = "Output selection\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(u8)]
pub enum OSEL_A {
#[doc = "0: Output disabled"]
Disabled = 0,
#[doc = "1: Alarm A output enabled"]
AlarmA = 1,
#[doc = "2: Alarm B output enabled"]
AlarmB = 2,
#[doc = "3: Wakeup output enabled"]
Wakeup = 3,
}
impl From<OSEL_A> for u8 {
#[inline(always)]
fn from(variant: OSEL_A) -> Self {
variant as _
}
}
#[doc = "Field `OSEL` reader - Output selection"]
pub type OSEL_R = crate::FieldReader<u8, OSEL_A>;
impl OSEL_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> OSEL_A {
match self.bits {
0 => OSEL_A::Disabled,
1 => OSEL_A::AlarmA,
2 => OSEL_A::AlarmB,
3 => OSEL_A::Wakeup,
_ => unreachable!(),
}
}
#[doc = "Checks if the value of the field is `Disabled`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == OSEL_A::Disabled
}
#[doc = "Checks if the value of the field is `AlarmA`"]
#[inline(always)]
pub fn is_alarm_a(&self) -> bool {
*self == OSEL_A::AlarmA
}
#[doc = "Checks if the value of the field is `AlarmB`"]
#[inline(always)]
pub fn is_alarm_b(&self) -> bool {
*self == OSEL_A::AlarmB
}
#[doc = "Checks if the value of the field is `Wakeup`"]
#[inline(always)]
pub fn is_wakeup(&self) -> bool {
*self == OSEL_A::Wakeup
}
}
#[doc = "Field `OSEL` writer - Output selection"]
pub type OSEL_W<'a> = crate::FieldWriterSafe<'a, u32, CR_SPEC, u8, OSEL_A, 2, 21>;
impl<'a> OSEL_W<'a> {
#[doc = "Output disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(OSEL_A::Disabled)
}
#[doc = "Alarm A output enabled"]
#[inline(always)]
pub fn alarm_a(self) -> &'a mut W {
self.variant(OSEL_A::AlarmA)
}
#[doc = "Alarm B output enabled"]
#[inline(always)]
pub fn alarm_b(self) -> &'a mut W {
self.variant(OSEL_A::AlarmB)
}
#[doc = "Wakeup output enabled"]
#[inline(always)]
pub fn wakeup(self) -> &'a mut W {
self.variant(OSEL_A::Wakeup)
}
}
#[doc = "Calibration output enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum COE_A {
#[doc = "0: Calibration output disabled"]
Disabled = 0,
#[doc = "1: Calibration output enabled"]
Enabled = 1,
}
impl From<COE_A> for bool {
#[inline(always)]
fn from(variant: COE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `COE` reader - Calibration output enable"]
pub type COE_R = crate::BitReader<COE_A>;
impl COE_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> COE_A {
match self.bits {
false => COE_A::Disabled,
true => COE_A::Enabled,
}
}
#[doc = "Checks if the value of the field is `Disabled`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == COE_A::Disabled
}
#[doc = "Checks if the value of the field is `Enabled`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == COE_A::Enabled
}
}
#[doc = "Field `COE` writer - Calibration output enable"]
pub type COE_W<'a> = crate::BitWriter<'a, u32, CR_SPEC, COE_A, 23>;
impl<'a> COE_W<'a> {
#[doc = "Calibration output disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(COE_A::Disabled)
}
#[doc = "Calibration output enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(COE_A::Enabled)
}
}
#[doc = "Field `ITSE` reader - timestamp on internal event enable"]
pub type ITSE_R = crate::BitReader<bool>;
#[doc = "Field `ITSE` writer - timestamp on internal event enable"]
pub type ITSE_W<'a> = crate::BitWriter<'a, u32, CR_SPEC, bool, 24>;
impl R {
#[doc = "Bits 0:2 - Wakeup clock selection"]
#[inline(always)]
pub fn wucksel(&self) -> WUCKSEL_R {
WUCKSEL_R::new((self.bits & 7) as u8)
}
#[doc = "Bit 3 - Time-stamp event active edge"]
#[inline(always)]
pub fn tsedge(&self) -> TSEDGE_R {
TSEDGE_R::new(((self.bits >> 3) & 1) != 0)
}
#[doc = "Bit 4 - Reference clock detection enable (50 or 60 Hz)"]
#[inline(always)]
pub fn refckon(&self) -> REFCKON_R {
REFCKON_R::new(((self.bits >> 4) & 1) != 0)
}
#[doc = "Bit 5 - Bypass the shadow registers"]
#[inline(always)]
pub fn bypshad(&self) -> BYPSHAD_R {
BYPSHAD_R::new(((self.bits >> 5) & 1) != 0)
}
#[doc = "Bit 6 - Hour format"]
#[inline(always)]
pub fn fmt(&self) -> FMT_R {
FMT_R::new(((self.bits >> 6) & 1) != 0)
}
#[doc = "Bit 8 - Alarm A enable"]
#[inline(always)]
pub fn alrae(&self) -> ALRAE_R {
ALRAE_R::new(((self.bits >> 8) & 1) != 0)
}
#[doc = "Bit 9 - Alarm B enable"]
#[inline(always)]
pub fn alrbe(&self) -> ALRBE_R {
ALRBE_R::new(((self.bits >> 9) & 1) != 0)
}
#[doc = "Bit 10 - Wakeup timer enable"]
#[inline(always)]
pub fn wute(&self) -> WUTE_R {
WUTE_R::new(((self.bits >> 10) & 1) != 0)
}
#[doc = "Bit 11 - Time stamp enable"]
#[inline(always)]
pub fn tse(&self) -> TSE_R {
TSE_R::new(((self.bits >> 11) & 1) != 0)
}
#[doc = "Bit 12 - Alarm A interrupt enable"]
#[inline(always)]
pub fn alraie(&self) -> ALRAIE_R {
ALRAIE_R::new(((self.bits >> 12) & 1) != 0)
}
#[doc = "Bit 13 - Alarm B interrupt enable"]
#[inline(always)]
pub fn alrbie(&self) -> ALRBIE_R {
ALRBIE_R::new(((self.bits >> 13) & 1) != 0)
}
#[doc = "Bit 14 - Wakeup timer interrupt enable"]
#[inline(always)]
pub fn wutie(&self) -> WUTIE_R {
WUTIE_R::new(((self.bits >> 14) & 1) != 0)
}
#[doc = "Bit 15 - Time-stamp interrupt enable"]
#[inline(always)]
pub fn tsie(&self) -> TSIE_R {
TSIE_R::new(((self.bits >> 15) & 1) != 0)
}
#[doc = "Bit 16 - Add 1 hour (summer time change)"]
#[inline(always)]
pub fn add1h(&self) -> ADD1H_R {
ADD1H_R::new(((self.bits >> 16) & 1) != 0)
}
#[doc = "Bit 17 - Subtract 1 hour (winter time change)"]
#[inline(always)]
pub fn sub1h(&self) -> SUB1H_R {
SUB1H_R::new(((self.bits >> 17) & 1) != 0)
}
#[doc = "Bit 18 - Backup"]
#[inline(always)]
pub fn bkp(&self) -> BKP_R {
BKP_R::new(((self.bits >> 18) & 1) != 0)
}
#[doc = "Bit 19 - Calibration output selection"]
#[inline(always)]
pub fn cosel(&self) -> COSEL_R {
COSEL_R::new(((self.bits >> 19) & 1) != 0)
}
#[doc = "Bit 20 - Output polarity"]
#[inline(always)]
pub fn pol(&self) -> POL_R {
POL_R::new(((self.bits >> 20) & 1) != 0)
}
#[doc = "Bits 21:22 - Output selection"]
#[inline(always)]
pub fn osel(&self) -> OSEL_R {
OSEL_R::new(((self.bits >> 21) & 3) as u8)
}
#[doc = "Bit 23 - Calibration output enable"]
#[inline(always)]
pub fn coe(&self) -> COE_R {
COE_R::new(((self.bits >> 23) & 1) != 0)
}
#[doc = "Bit 24 - timestamp on internal event enable"]
#[inline(always)]
pub fn itse(&self) -> ITSE_R {
ITSE_R::new(((self.bits >> 24) & 1) != 0)
}
}
impl W {
#[doc = "Bits 0:2 - Wakeup clock selection"]
#[inline(always)]
pub fn wucksel(&mut self) -> WUCKSEL_W {
WUCKSEL_W::new(self)
}
#[doc = "Bit 3 - Time-stamp event active edge"]
#[inline(always)]
pub fn tsedge(&mut self) -> TSEDGE_W {
TSEDGE_W::new(self)
}
#[doc = "Bit 4 - Reference clock detection enable (50 or 60 Hz)"]
#[inline(always)]
pub fn refckon(&mut self) -> REFCKON_W {
REFCKON_W::new(self)
}
#[doc = "Bit 5 - Bypass the shadow registers"]
#[inline(always)]
pub fn bypshad(&mut self) -> BYPSHAD_W {
BYPSHAD_W::new(self)
}
#[doc = "Bit 6 - Hour format"]
#[inline(always)]
pub fn fmt(&mut self) -> FMT_W {
FMT_W::new(self)
}
#[doc = "Bit 8 - Alarm A enable"]
#[inline(always)]
pub fn alrae(&mut self) -> ALRAE_W {
ALRAE_W::new(self)
}
#[doc = "Bit 9 - Alarm B enable"]
#[inline(always)]
pub fn alrbe(&mut self) -> ALRBE_W {
ALRBE_W::new(self)
}
#[doc = "Bit 10 - Wakeup timer enable"]
#[inline(always)]
pub fn wute(&mut self) -> WUTE_W {
WUTE_W::new(self)
}
#[doc = "Bit 11 - Time stamp enable"]
#[inline(always)]
pub fn tse(&mut self) -> TSE_W {
TSE_W::new(self)
}
#[doc = "Bit 12 - Alarm A interrupt enable"]
#[inline(always)]
pub fn alraie(&mut self) -> ALRAIE_W {
ALRAIE_W::new(self)
}
#[doc = "Bit 13 - Alarm B interrupt enable"]
#[inline(always)]
pub fn alrbie(&mut self) -> ALRBIE_W {
ALRBIE_W::new(self)
}
#[doc = "Bit 14 - Wakeup timer interrupt enable"]
#[inline(always)]
pub fn wutie(&mut self) -> WUTIE_W {
WUTIE_W::new(self)
}
#[doc = "Bit 15 - Time-stamp interrupt enable"]
#[inline(always)]
pub fn tsie(&mut self) -> TSIE_W {
TSIE_W::new(self)
}
#[doc = "Bit 16 - Add 1 hour (summer time change)"]
#[inline(always)]
pub fn add1h(&mut self) -> ADD1H_W {
ADD1H_W::new(self)
}
#[doc = "Bit 17 - Subtract 1 hour (winter time change)"]
#[inline(always)]
pub fn sub1h(&mut self) -> SUB1H_W {
SUB1H_W::new(self)
}
#[doc = "Bit 18 - Backup"]
#[inline(always)]
pub fn bkp(&mut self) -> BKP_W {
BKP_W::new(self)
}
#[doc = "Bit 19 - Calibration output selection"]
#[inline(always)]
pub fn cosel(&mut self) -> COSEL_W {
COSEL_W::new(self)
}
#[doc = "Bit 20 - Output polarity"]
#[inline(always)]
pub fn pol(&mut self) -> POL_W {
POL_W::new(self)
}
#[doc = "Bits 21:22 - Output selection"]
#[inline(always)]
pub fn osel(&mut self) -> OSEL_W {
OSEL_W::new(self)
}
#[doc = "Bit 23 - Calibration output enable"]
#[inline(always)]
pub fn coe(&mut self) -> COE_W {
COE_W::new(self)
}
#[doc = "Bit 24 - timestamp on internal event enable"]
#[inline(always)]
pub fn itse(&mut self) -> ITSE_W {
ITSE_W::new(self)
}
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.0.bits(bits);
self
}
}
#[doc = "control register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cr](index.html) module"]
pub struct CR_SPEC;
impl crate::RegisterSpec for CR_SPEC {
type Ux = u32;
}
#[doc = "`read()` method returns [cr::R](R) reader structure"]
impl crate::Readable for CR_SPEC {
type Reader = R;
}
#[doc = "`write(|w| ..)` method takes [cr::W](W) writer structure"]
impl crate::Writable for CR_SPEC {
type Writer = W;
}
#[doc = "`reset()` method sets CR to value 0"]
impl crate::Resettable for CR_SPEC {
#[inline(always)]
fn reset_value() -> Self::Ux {
0
}
}