#[doc = "Reader of register CR"]
pub type R = crate::R<u32, super::CR>;
#[doc = "Writer for register CR"]
pub type W = crate::W<u32, super::CR>;
#[doc = "Register CR `reset()`'s with value 0"]
impl crate::ResetValue for super::CR {
type Type = u32;
#[inline(always)]
fn reset_value() -> Self::Type {
0
}
}
#[doc = "Reader of field `WUCKSEL`"]
pub type WUCKSEL_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `WUCKSEL`"]
pub struct WUCKSEL_W<'a> {
w: &'a mut W,
}
impl<'a> WUCKSEL_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0x07) | ((value as u32) & 0x07);
self.w
}
}
#[doc = "Reader of field `TSEDGE`"]
pub type TSEDGE_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TSEDGE`"]
pub struct TSEDGE_W<'a> {
w: &'a mut W,
}
impl<'a> TSEDGE_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 3)) | (((value as u32) & 0x01) << 3);
self.w
}
}
#[doc = "Reader of field `REFCKON`"]
pub type REFCKON_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `REFCKON`"]
pub struct REFCKON_W<'a> {
w: &'a mut W,
}
impl<'a> REFCKON_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 4)) | (((value as u32) & 0x01) << 4);
self.w
}
}
#[doc = "Reader of field `BYPSHAD`"]
pub type BYPSHAD_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `BYPSHAD`"]
pub struct BYPSHAD_W<'a> {
w: &'a mut W,
}
impl<'a> BYPSHAD_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 5)) | (((value as u32) & 0x01) << 5);
self.w
}
}
#[doc = "Reader of field `FMT`"]
pub type FMT_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `FMT`"]
pub struct FMT_W<'a> {
w: &'a mut W,
}
impl<'a> FMT_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 6)) | (((value as u32) & 0x01) << 6);
self.w
}
}
#[doc = "Reader of field `ALRAE`"]
pub type ALRAE_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `ALRAE`"]
pub struct ALRAE_W<'a> {
w: &'a mut W,
}
impl<'a> ALRAE_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 8)) | (((value as u32) & 0x01) << 8);
self.w
}
}
#[doc = "Reader of field `ALRBE`"]
pub type ALRBE_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `ALRBE`"]
pub struct ALRBE_W<'a> {
w: &'a mut W,
}
impl<'a> ALRBE_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 9)) | (((value as u32) & 0x01) << 9);
self.w
}
}
#[doc = "Reader of field `WUTE`"]
pub type WUTE_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `WUTE`"]
pub struct WUTE_W<'a> {
w: &'a mut W,
}
impl<'a> WUTE_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 10)) | (((value as u32) & 0x01) << 10);
self.w
}
}
#[doc = "Reader of field `TSE`"]
pub type TSE_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TSE`"]
pub struct TSE_W<'a> {
w: &'a mut W,
}
impl<'a> TSE_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 11)) | (((value as u32) & 0x01) << 11);
self.w
}
}
#[doc = "Reader of field `ALRAIE`"]
pub type ALRAIE_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `ALRAIE`"]
pub struct ALRAIE_W<'a> {
w: &'a mut W,
}
impl<'a> ALRAIE_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 12)) | (((value as u32) & 0x01) << 12);
self.w
}
}
#[doc = "Reader of field `ALRBIE`"]
pub type ALRBIE_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `ALRBIE`"]
pub struct ALRBIE_W<'a> {
w: &'a mut W,
}
impl<'a> ALRBIE_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 13)) | (((value as u32) & 0x01) << 13);
self.w
}
}
#[doc = "Reader of field `WUTIE`"]
pub type WUTIE_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `WUTIE`"]
pub struct WUTIE_W<'a> {
w: &'a mut W,
}
impl<'a> WUTIE_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 14)) | (((value as u32) & 0x01) << 14);
self.w
}
}
#[doc = "Reader of field `TSIE`"]
pub type TSIE_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TSIE`"]
pub struct TSIE_W<'a> {
w: &'a mut W,
}
impl<'a> TSIE_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 15)) | (((value as u32) & 0x01) << 15);
self.w
}
}
#[doc = "Reader of field `ADD1H`"]
pub type ADD1H_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `ADD1H`"]
pub struct ADD1H_W<'a> {
w: &'a mut W,
}
impl<'a> ADD1H_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 16)) | (((value as u32) & 0x01) << 16);
self.w
}
}
#[doc = "Reader of field `SUB1H`"]
pub type SUB1H_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `SUB1H`"]
pub struct SUB1H_W<'a> {
w: &'a mut W,
}
impl<'a> SUB1H_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 17)) | (((value as u32) & 0x01) << 17);
self.w
}
}
#[doc = "Reader of field `BKP`"]
pub type BKP_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `BKP`"]
pub struct BKP_W<'a> {
w: &'a mut W,
}
impl<'a> BKP_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 18)) | (((value as u32) & 0x01) << 18);
self.w
}
}
#[doc = "Reader of field `COSEL`"]
pub type COSEL_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `COSEL`"]
pub struct COSEL_W<'a> {
w: &'a mut W,
}
impl<'a> COSEL_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 19)) | (((value as u32) & 0x01) << 19);
self.w
}
}
#[doc = "Reader of field `POL`"]
pub type POL_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `POL`"]
pub struct POL_W<'a> {
w: &'a mut W,
}
impl<'a> POL_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 20)) | (((value as u32) & 0x01) << 20);
self.w
}
}
#[doc = "Reader of field `OSEL`"]
pub type OSEL_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `OSEL`"]
pub struct OSEL_W<'a> {
w: &'a mut W,
}
impl<'a> OSEL_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x03 << 21)) | (((value as u32) & 0x03) << 21);
self.w
}
}
#[doc = "Reader of field `COE`"]
pub type COE_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `COE`"]
pub struct COE_W<'a> {
w: &'a mut W,
}
impl<'a> COE_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 23)) | (((value as u32) & 0x01) << 23);
self.w
}
}
#[doc = "Reader of field `ITSE`"]
pub type ITSE_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `ITSE`"]
pub struct ITSE_W<'a> {
w: &'a mut W,
}
impl<'a> ITSE_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 24)) | (((value as u32) & 0x01) << 24);
self.w
}
}
#[doc = "Reader of field `TAMPTS`"]
pub type TAMPTS_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TAMPTS`"]
pub struct TAMPTS_W<'a> {
w: &'a mut W,
}
impl<'a> TAMPTS_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 25)) | (((value as u32) & 0x01) << 25);
self.w
}
}
#[doc = "Reader of field `TAMPOE`"]
pub type TAMPOE_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TAMPOE`"]
pub struct TAMPOE_W<'a> {
w: &'a mut W,
}
impl<'a> TAMPOE_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 26)) | (((value as u32) & 0x01) << 26);
self.w
}
}
#[doc = "Reader of field `TAMPALRM_PU`"]
pub type TAMPALRM_PU_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TAMPALRM_PU`"]
pub struct TAMPALRM_PU_W<'a> {
w: &'a mut W,
}
impl<'a> TAMPALRM_PU_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 29)) | (((value as u32) & 0x01) << 29);
self.w
}
}
#[doc = "Reader of field `TAMPALRM_TYPE`"]
pub type TAMPALRM_TYPE_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TAMPALRM_TYPE`"]
pub struct TAMPALRM_TYPE_W<'a> {
w: &'a mut W,
}
impl<'a> TAMPALRM_TYPE_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 30)) | (((value as u32) & 0x01) << 30);
self.w
}
}
#[doc = "Reader of field `OUT2EN`"]
pub type OUT2EN_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `OUT2EN`"]
pub struct OUT2EN_W<'a> {
w: &'a mut W,
}
impl<'a> OUT2EN_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 31)) | (((value as u32) & 0x01) << 31);
self.w
}
}
impl R {
#[doc = "Bits 0:2 - WUCKSEL"]
#[inline(always)]
pub fn wucksel(&self) -> WUCKSEL_R {
WUCKSEL_R::new((self.bits & 0x07) as u8)
}
#[doc = "Bit 3 - TSEDGE"]
#[inline(always)]
pub fn tsedge(&self) -> TSEDGE_R {
TSEDGE_R::new(((self.bits >> 3) & 0x01) != 0)
}
#[doc = "Bit 4 - REFCKON"]
#[inline(always)]
pub fn refckon(&self) -> REFCKON_R {
REFCKON_R::new(((self.bits >> 4) & 0x01) != 0)
}
#[doc = "Bit 5 - BYPSHAD"]
#[inline(always)]
pub fn bypshad(&self) -> BYPSHAD_R {
BYPSHAD_R::new(((self.bits >> 5) & 0x01) != 0)
}
#[doc = "Bit 6 - FMT"]
#[inline(always)]
pub fn fmt(&self) -> FMT_R {
FMT_R::new(((self.bits >> 6) & 0x01) != 0)
}
#[doc = "Bit 8 - ALRAE"]
#[inline(always)]
pub fn alrae(&self) -> ALRAE_R {
ALRAE_R::new(((self.bits >> 8) & 0x01) != 0)
}
#[doc = "Bit 9 - ALRBE"]
#[inline(always)]
pub fn alrbe(&self) -> ALRBE_R {
ALRBE_R::new(((self.bits >> 9) & 0x01) != 0)
}
#[doc = "Bit 10 - WUTE"]
#[inline(always)]
pub fn wute(&self) -> WUTE_R {
WUTE_R::new(((self.bits >> 10) & 0x01) != 0)
}
#[doc = "Bit 11 - TSE"]
#[inline(always)]
pub fn tse(&self) -> TSE_R {
TSE_R::new(((self.bits >> 11) & 0x01) != 0)
}
#[doc = "Bit 12 - ALRAIE"]
#[inline(always)]
pub fn alraie(&self) -> ALRAIE_R {
ALRAIE_R::new(((self.bits >> 12) & 0x01) != 0)
}
#[doc = "Bit 13 - ALRBIE"]
#[inline(always)]
pub fn alrbie(&self) -> ALRBIE_R {
ALRBIE_R::new(((self.bits >> 13) & 0x01) != 0)
}
#[doc = "Bit 14 - WUTIE"]
#[inline(always)]
pub fn wutie(&self) -> WUTIE_R {
WUTIE_R::new(((self.bits >> 14) & 0x01) != 0)
}
#[doc = "Bit 15 - TSIE"]
#[inline(always)]
pub fn tsie(&self) -> TSIE_R {
TSIE_R::new(((self.bits >> 15) & 0x01) != 0)
}
#[doc = "Bit 16 - ADD1H"]
#[inline(always)]
pub fn add1h(&self) -> ADD1H_R {
ADD1H_R::new(((self.bits >> 16) & 0x01) != 0)
}
#[doc = "Bit 17 - SUB1H"]
#[inline(always)]
pub fn sub1h(&self) -> SUB1H_R {
SUB1H_R::new(((self.bits >> 17) & 0x01) != 0)
}
#[doc = "Bit 18 - BKP"]
#[inline(always)]
pub fn bkp(&self) -> BKP_R {
BKP_R::new(((self.bits >> 18) & 0x01) != 0)
}
#[doc = "Bit 19 - COSEL"]
#[inline(always)]
pub fn cosel(&self) -> COSEL_R {
COSEL_R::new(((self.bits >> 19) & 0x01) != 0)
}
#[doc = "Bit 20 - POL"]
#[inline(always)]
pub fn pol(&self) -> POL_R {
POL_R::new(((self.bits >> 20) & 0x01) != 0)
}
#[doc = "Bits 21:22 - OSEL"]
#[inline(always)]
pub fn osel(&self) -> OSEL_R {
OSEL_R::new(((self.bits >> 21) & 0x03) as u8)
}
#[doc = "Bit 23 - COE"]
#[inline(always)]
pub fn coe(&self) -> COE_R {
COE_R::new(((self.bits >> 23) & 0x01) != 0)
}
#[doc = "Bit 24 - ITSE"]
#[inline(always)]
pub fn itse(&self) -> ITSE_R {
ITSE_R::new(((self.bits >> 24) & 0x01) != 0)
}
#[doc = "Bit 25 - TAMPTS"]
#[inline(always)]
pub fn tampts(&self) -> TAMPTS_R {
TAMPTS_R::new(((self.bits >> 25) & 0x01) != 0)
}
#[doc = "Bit 26 - TAMPOE"]
#[inline(always)]
pub fn tampoe(&self) -> TAMPOE_R {
TAMPOE_R::new(((self.bits >> 26) & 0x01) != 0)
}
#[doc = "Bit 29 - TAMPALRM_PU"]
#[inline(always)]
pub fn tampalrm_pu(&self) -> TAMPALRM_PU_R {
TAMPALRM_PU_R::new(((self.bits >> 29) & 0x01) != 0)
}
#[doc = "Bit 30 - TAMPALRM_TYPE"]
#[inline(always)]
pub fn tampalrm_type(&self) -> TAMPALRM_TYPE_R {
TAMPALRM_TYPE_R::new(((self.bits >> 30) & 0x01) != 0)
}
#[doc = "Bit 31 - OUT2EN"]
#[inline(always)]
pub fn out2en(&self) -> OUT2EN_R {
OUT2EN_R::new(((self.bits >> 31) & 0x01) != 0)
}
}
impl W {
#[doc = "Bits 0:2 - WUCKSEL"]
#[inline(always)]
pub fn wucksel(&mut self) -> WUCKSEL_W {
WUCKSEL_W { w: self }
}
#[doc = "Bit 3 - TSEDGE"]
#[inline(always)]
pub fn tsedge(&mut self) -> TSEDGE_W {
TSEDGE_W { w: self }
}
#[doc = "Bit 4 - REFCKON"]
#[inline(always)]
pub fn refckon(&mut self) -> REFCKON_W {
REFCKON_W { w: self }
}
#[doc = "Bit 5 - BYPSHAD"]
#[inline(always)]
pub fn bypshad(&mut self) -> BYPSHAD_W {
BYPSHAD_W { w: self }
}
#[doc = "Bit 6 - FMT"]
#[inline(always)]
pub fn fmt(&mut self) -> FMT_W {
FMT_W { w: self }
}
#[doc = "Bit 8 - ALRAE"]
#[inline(always)]
pub fn alrae(&mut self) -> ALRAE_W {
ALRAE_W { w: self }
}
#[doc = "Bit 9 - ALRBE"]
#[inline(always)]
pub fn alrbe(&mut self) -> ALRBE_W {
ALRBE_W { w: self }
}
#[doc = "Bit 10 - WUTE"]
#[inline(always)]
pub fn wute(&mut self) -> WUTE_W {
WUTE_W { w: self }
}
#[doc = "Bit 11 - TSE"]
#[inline(always)]
pub fn tse(&mut self) -> TSE_W {
TSE_W { w: self }
}
#[doc = "Bit 12 - ALRAIE"]
#[inline(always)]
pub fn alraie(&mut self) -> ALRAIE_W {
ALRAIE_W { w: self }
}
#[doc = "Bit 13 - ALRBIE"]
#[inline(always)]
pub fn alrbie(&mut self) -> ALRBIE_W {
ALRBIE_W { w: self }
}
#[doc = "Bit 14 - WUTIE"]
#[inline(always)]
pub fn wutie(&mut self) -> WUTIE_W {
WUTIE_W { w: self }
}
#[doc = "Bit 15 - TSIE"]
#[inline(always)]
pub fn tsie(&mut self) -> TSIE_W {
TSIE_W { w: self }
}
#[doc = "Bit 16 - ADD1H"]
#[inline(always)]
pub fn add1h(&mut self) -> ADD1H_W {
ADD1H_W { w: self }
}
#[doc = "Bit 17 - SUB1H"]
#[inline(always)]
pub fn sub1h(&mut self) -> SUB1H_W {
SUB1H_W { w: self }
}
#[doc = "Bit 18 - BKP"]
#[inline(always)]
pub fn bkp(&mut self) -> BKP_W {
BKP_W { w: self }
}
#[doc = "Bit 19 - COSEL"]
#[inline(always)]
pub fn cosel(&mut self) -> COSEL_W {
COSEL_W { w: self }
}
#[doc = "Bit 20 - POL"]
#[inline(always)]
pub fn pol(&mut self) -> POL_W {
POL_W { w: self }
}
#[doc = "Bits 21:22 - OSEL"]
#[inline(always)]
pub fn osel(&mut self) -> OSEL_W {
OSEL_W { w: self }
}
#[doc = "Bit 23 - COE"]
#[inline(always)]
pub fn coe(&mut self) -> COE_W {
COE_W { w: self }
}
#[doc = "Bit 24 - ITSE"]
#[inline(always)]
pub fn itse(&mut self) -> ITSE_W {
ITSE_W { w: self }
}
#[doc = "Bit 25 - TAMPTS"]
#[inline(always)]
pub fn tampts(&mut self) -> TAMPTS_W {
TAMPTS_W { w: self }
}
#[doc = "Bit 26 - TAMPOE"]
#[inline(always)]
pub fn tampoe(&mut self) -> TAMPOE_W {
TAMPOE_W { w: self }
}
#[doc = "Bit 29 - TAMPALRM_PU"]
#[inline(always)]
pub fn tampalrm_pu(&mut self) -> TAMPALRM_PU_W {
TAMPALRM_PU_W { w: self }
}
#[doc = "Bit 30 - TAMPALRM_TYPE"]
#[inline(always)]
pub fn tampalrm_type(&mut self) -> TAMPALRM_TYPE_W {
TAMPALRM_TYPE_W { w: self }
}
#[doc = "Bit 31 - OUT2EN"]
#[inline(always)]
pub fn out2en(&mut self) -> OUT2EN_W {
OUT2EN_W { w: self }
}
}