723 lines
20 KiB
Rust
723 lines
20 KiB
Rust
#[doc = r" Value to write to the register"]
|
|
pub struct W {
|
|
bits: u32,
|
|
}
|
|
impl super::CSCLRIFG {
|
|
#[doc = r" Writes to the register"]
|
|
#[inline]
|
|
pub fn write<F>(&self, f: F)
|
|
where
|
|
F: FnOnce(&mut W) -> &mut W,
|
|
{
|
|
let mut w = W::reset_value();
|
|
f(&mut w);
|
|
self.register.set(w.bits);
|
|
}
|
|
}
|
|
#[doc = "Values that can be written to the field `CLR_LFXTIFG`"]
|
|
pub enum CLR_LFXTIFGW {
|
|
#[doc = "No effect"]
|
|
CLR_LFXTIFG_0,
|
|
#[doc = "Clear pending interrupt flag"]
|
|
CLR_LFXTIFG_1,
|
|
}
|
|
impl CLR_LFXTIFGW {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
CLR_LFXTIFGW::CLR_LFXTIFG_0 => false,
|
|
CLR_LFXTIFGW::CLR_LFXTIFG_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _CLR_LFXTIFGW<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _CLR_LFXTIFGW<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: CLR_LFXTIFGW) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "No effect"]
|
|
#[inline]
|
|
pub fn clr_lfxtifg_0(self) -> &'a mut W {
|
|
self.variant(CLR_LFXTIFGW::CLR_LFXTIFG_0)
|
|
}
|
|
#[doc = "Clear pending interrupt flag"]
|
|
#[inline]
|
|
pub fn clr_lfxtifg_1(self) -> &'a mut W {
|
|
self.variant(CLR_LFXTIFGW::CLR_LFXTIFG_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 0;
|
|
self.w.bits &= !((MASK as u32) << OFFSET);
|
|
self.w.bits |= ((value & MASK) as u32) << OFFSET;
|
|
self.w
|
|
}
|
|
}
|
|
#[doc = "Values that can be written to the field `CLR_HFXTIFG`"]
|
|
pub enum CLR_HFXTIFGW {
|
|
#[doc = "No effect"]
|
|
CLR_HFXTIFG_0,
|
|
#[doc = "Clear pending interrupt flag"]
|
|
CLR_HFXTIFG_1,
|
|
}
|
|
impl CLR_HFXTIFGW {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
CLR_HFXTIFGW::CLR_HFXTIFG_0 => false,
|
|
CLR_HFXTIFGW::CLR_HFXTIFG_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _CLR_HFXTIFGW<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _CLR_HFXTIFGW<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: CLR_HFXTIFGW) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "No effect"]
|
|
#[inline]
|
|
pub fn clr_hfxtifg_0(self) -> &'a mut W {
|
|
self.variant(CLR_HFXTIFGW::CLR_HFXTIFG_0)
|
|
}
|
|
#[doc = "Clear pending interrupt flag"]
|
|
#[inline]
|
|
pub fn clr_hfxtifg_1(self) -> &'a mut W {
|
|
self.variant(CLR_HFXTIFGW::CLR_HFXTIFG_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 1;
|
|
self.w.bits &= !((MASK as u32) << OFFSET);
|
|
self.w.bits |= ((value & MASK) as u32) << OFFSET;
|
|
self.w
|
|
}
|
|
}
|
|
#[doc = "Values that can be written to the field `CLR_HFXT2IFG`"]
|
|
pub enum CLR_HFXT2IFGW {
|
|
#[doc = "No effect"]
|
|
CLR_HFXT2IFG_0,
|
|
#[doc = "Clear pending interrupt flag"]
|
|
CLR_HFXT2IFG_1,
|
|
}
|
|
impl CLR_HFXT2IFGW {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
CLR_HFXT2IFGW::CLR_HFXT2IFG_0 => false,
|
|
CLR_HFXT2IFGW::CLR_HFXT2IFG_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _CLR_HFXT2IFGW<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _CLR_HFXT2IFGW<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: CLR_HFXT2IFGW) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "No effect"]
|
|
#[inline]
|
|
pub fn clr_hfxt2ifg_0(self) -> &'a mut W {
|
|
self.variant(CLR_HFXT2IFGW::CLR_HFXT2IFG_0)
|
|
}
|
|
#[doc = "Clear pending interrupt flag"]
|
|
#[inline]
|
|
pub fn clr_hfxt2ifg_1(self) -> &'a mut W {
|
|
self.variant(CLR_HFXT2IFGW::CLR_HFXT2IFG_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 2;
|
|
self.w.bits &= !((MASK as u32) << OFFSET);
|
|
self.w.bits |= ((value & MASK) as u32) << OFFSET;
|
|
self.w
|
|
}
|
|
}
|
|
#[doc = "Values that can be written to the field `CLR_DCOR_OPNIFG`"]
|
|
pub enum CLR_DCOR_OPNIFGW {
|
|
#[doc = "No effect"]
|
|
CLR_DCOR_OPNIFG_0,
|
|
#[doc = "Clear pending interrupt flag"]
|
|
CLR_DCOR_OPNIFG_1,
|
|
}
|
|
impl CLR_DCOR_OPNIFGW {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
CLR_DCOR_OPNIFGW::CLR_DCOR_OPNIFG_0 => false,
|
|
CLR_DCOR_OPNIFGW::CLR_DCOR_OPNIFG_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _CLR_DCOR_OPNIFGW<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _CLR_DCOR_OPNIFGW<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: CLR_DCOR_OPNIFGW) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "No effect"]
|
|
#[inline]
|
|
pub fn clr_dcor_opnifg_0(self) -> &'a mut W {
|
|
self.variant(CLR_DCOR_OPNIFGW::CLR_DCOR_OPNIFG_0)
|
|
}
|
|
#[doc = "Clear pending interrupt flag"]
|
|
#[inline]
|
|
pub fn clr_dcor_opnifg_1(self) -> &'a mut W {
|
|
self.variant(CLR_DCOR_OPNIFGW::CLR_DCOR_OPNIFG_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 6;
|
|
self.w.bits &= !((MASK as u32) << OFFSET);
|
|
self.w.bits |= ((value & MASK) as u32) << OFFSET;
|
|
self.w
|
|
}
|
|
}
|
|
#[doc = "Values that can be written to the field `CLR_CALIFG`"]
|
|
pub enum CLR_CALIFGW {
|
|
#[doc = "No effect"]
|
|
CLR_CALIFG_0,
|
|
#[doc = "Clear pending interrupt flag"]
|
|
CLR_CALIFG_1,
|
|
}
|
|
impl CLR_CALIFGW {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
CLR_CALIFGW::CLR_CALIFG_0 => false,
|
|
CLR_CALIFGW::CLR_CALIFG_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _CLR_CALIFGW<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _CLR_CALIFGW<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: CLR_CALIFGW) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "No effect"]
|
|
#[inline]
|
|
pub fn clr_califg_0(self) -> &'a mut W {
|
|
self.variant(CLR_CALIFGW::CLR_CALIFG_0)
|
|
}
|
|
#[doc = "Clear pending interrupt flag"]
|
|
#[inline]
|
|
pub fn clr_califg_1(self) -> &'a mut W {
|
|
self.variant(CLR_CALIFGW::CLR_CALIFG_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 15;
|
|
self.w.bits &= !((MASK as u32) << OFFSET);
|
|
self.w.bits |= ((value & MASK) as u32) << OFFSET;
|
|
self.w
|
|
}
|
|
}
|
|
#[doc = "Values that can be written to the field `CLR_FCNTLFIFG`"]
|
|
pub enum CLR_FCNTLFIFGW {
|
|
#[doc = "No effect"]
|
|
CLR_FCNTLFIFG_0,
|
|
#[doc = "Clear pending interrupt flag"]
|
|
CLR_FCNTLFIFG_1,
|
|
}
|
|
impl CLR_FCNTLFIFGW {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
CLR_FCNTLFIFGW::CLR_FCNTLFIFG_0 => false,
|
|
CLR_FCNTLFIFGW::CLR_FCNTLFIFG_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _CLR_FCNTLFIFGW<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _CLR_FCNTLFIFGW<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: CLR_FCNTLFIFGW) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "No effect"]
|
|
#[inline]
|
|
pub fn clr_fcntlfifg_0(self) -> &'a mut W {
|
|
self.variant(CLR_FCNTLFIFGW::CLR_FCNTLFIFG_0)
|
|
}
|
|
#[doc = "Clear pending interrupt flag"]
|
|
#[inline]
|
|
pub fn clr_fcntlfifg_1(self) -> &'a mut W {
|
|
self.variant(CLR_FCNTLFIFGW::CLR_FCNTLFIFG_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 8;
|
|
self.w.bits &= !((MASK as u32) << OFFSET);
|
|
self.w.bits |= ((value & MASK) as u32) << OFFSET;
|
|
self.w
|
|
}
|
|
}
|
|
#[doc = "Values that can be written to the field `CLR_FCNTHFIFG`"]
|
|
pub enum CLR_FCNTHFIFGW {
|
|
#[doc = "No effect"]
|
|
CLR_FCNTHFIFG_0,
|
|
#[doc = "Clear pending interrupt flag"]
|
|
CLR_FCNTHFIFG_1,
|
|
}
|
|
impl CLR_FCNTHFIFGW {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
CLR_FCNTHFIFGW::CLR_FCNTHFIFG_0 => false,
|
|
CLR_FCNTHFIFGW::CLR_FCNTHFIFG_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _CLR_FCNTHFIFGW<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _CLR_FCNTHFIFGW<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: CLR_FCNTHFIFGW) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "No effect"]
|
|
#[inline]
|
|
pub fn clr_fcnthfifg_0(self) -> &'a mut W {
|
|
self.variant(CLR_FCNTHFIFGW::CLR_FCNTHFIFG_0)
|
|
}
|
|
#[doc = "Clear pending interrupt flag"]
|
|
#[inline]
|
|
pub fn clr_fcnthfifg_1(self) -> &'a mut W {
|
|
self.variant(CLR_FCNTHFIFGW::CLR_FCNTHFIFG_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 9;
|
|
self.w.bits &= !((MASK as u32) << OFFSET);
|
|
self.w.bits |= ((value & MASK) as u32) << OFFSET;
|
|
self.w
|
|
}
|
|
}
|
|
#[doc = "Values that can be written to the field `CLR_FCNTHF2IFG`"]
|
|
pub enum CLR_FCNTHF2IFGW {
|
|
#[doc = "No effect"]
|
|
CLR_FCNTHF2IFG_0,
|
|
#[doc = "Clear pending interrupt flag"]
|
|
CLR_FCNTHF2IFG_1,
|
|
}
|
|
impl CLR_FCNTHF2IFGW {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
CLR_FCNTHF2IFGW::CLR_FCNTHF2IFG_0 => false,
|
|
CLR_FCNTHF2IFGW::CLR_FCNTHF2IFG_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _CLR_FCNTHF2IFGW<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _CLR_FCNTHF2IFGW<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: CLR_FCNTHF2IFGW) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "No effect"]
|
|
#[inline]
|
|
pub fn clr_fcnthf2ifg_0(self) -> &'a mut W {
|
|
self.variant(CLR_FCNTHF2IFGW::CLR_FCNTHF2IFG_0)
|
|
}
|
|
#[doc = "Clear pending interrupt flag"]
|
|
#[inline]
|
|
pub fn clr_fcnthf2ifg_1(self) -> &'a mut W {
|
|
self.variant(CLR_FCNTHF2IFGW::CLR_FCNTHF2IFG_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 10;
|
|
self.w.bits &= !((MASK as u32) << OFFSET);
|
|
self.w.bits |= ((value & MASK) as u32) << OFFSET;
|
|
self.w
|
|
}
|
|
}
|
|
#[doc = "Values that can be written to the field `CLR_PLLOOLIFG`"]
|
|
pub enum CLR_PLLOOLIFGW {
|
|
#[doc = "No effect"]
|
|
CLR_PLLOOLIFG_0,
|
|
#[doc = "Clear pending interrupt flag"]
|
|
CLR_PLLOOLIFG_1,
|
|
}
|
|
impl CLR_PLLOOLIFGW {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
CLR_PLLOOLIFGW::CLR_PLLOOLIFG_0 => false,
|
|
CLR_PLLOOLIFGW::CLR_PLLOOLIFG_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _CLR_PLLOOLIFGW<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _CLR_PLLOOLIFGW<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: CLR_PLLOOLIFGW) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "No effect"]
|
|
#[inline]
|
|
pub fn clr_plloolifg_0(self) -> &'a mut W {
|
|
self.variant(CLR_PLLOOLIFGW::CLR_PLLOOLIFG_0)
|
|
}
|
|
#[doc = "Clear pending interrupt flag"]
|
|
#[inline]
|
|
pub fn clr_plloolifg_1(self) -> &'a mut W {
|
|
self.variant(CLR_PLLOOLIFGW::CLR_PLLOOLIFG_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 12;
|
|
self.w.bits &= !((MASK as u32) << OFFSET);
|
|
self.w.bits |= ((value & MASK) as u32) << OFFSET;
|
|
self.w
|
|
}
|
|
}
|
|
#[doc = "Values that can be written to the field `CLR_PLLLOSIFG`"]
|
|
pub enum CLR_PLLLOSIFGW {
|
|
#[doc = "No effect"]
|
|
CLR_PLLLOSIFG_0,
|
|
#[doc = "Clear pending interrupt flag"]
|
|
CLR_PLLLOSIFG_1,
|
|
}
|
|
impl CLR_PLLLOSIFGW {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
CLR_PLLLOSIFGW::CLR_PLLLOSIFG_0 => false,
|
|
CLR_PLLLOSIFGW::CLR_PLLLOSIFG_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _CLR_PLLLOSIFGW<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _CLR_PLLLOSIFGW<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: CLR_PLLLOSIFGW) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "No effect"]
|
|
#[inline]
|
|
pub fn clr_plllosifg_0(self) -> &'a mut W {
|
|
self.variant(CLR_PLLLOSIFGW::CLR_PLLLOSIFG_0)
|
|
}
|
|
#[doc = "Clear pending interrupt flag"]
|
|
#[inline]
|
|
pub fn clr_plllosifg_1(self) -> &'a mut W {
|
|
self.variant(CLR_PLLLOSIFGW::CLR_PLLLOSIFG_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 13;
|
|
self.w.bits &= !((MASK as u32) << OFFSET);
|
|
self.w.bits |= ((value & MASK) as u32) << OFFSET;
|
|
self.w
|
|
}
|
|
}
|
|
#[doc = "Values that can be written to the field `CLR_PLLOORIFG`"]
|
|
pub enum CLR_PLLOORIFGW {
|
|
#[doc = "No effect"]
|
|
CLR_PLLOORIFG_0,
|
|
#[doc = "Clear pending interrupt flag"]
|
|
CLR_PLLOORIFG_1,
|
|
}
|
|
impl CLR_PLLOORIFGW {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
CLR_PLLOORIFGW::CLR_PLLOORIFG_0 => false,
|
|
CLR_PLLOORIFGW::CLR_PLLOORIFG_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _CLR_PLLOORIFGW<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _CLR_PLLOORIFGW<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: CLR_PLLOORIFGW) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "No effect"]
|
|
#[inline]
|
|
pub fn clr_plloorifg_0(self) -> &'a mut W {
|
|
self.variant(CLR_PLLOORIFGW::CLR_PLLOORIFG_0)
|
|
}
|
|
#[doc = "Clear pending interrupt flag"]
|
|
#[inline]
|
|
pub fn clr_plloorifg_1(self) -> &'a mut W {
|
|
self.variant(CLR_PLLOORIFGW::CLR_PLLOORIFG_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 14;
|
|
self.w.bits &= !((MASK as u32) << OFFSET);
|
|
self.w.bits |= ((value & MASK) as u32) << OFFSET;
|
|
self.w
|
|
}
|
|
}
|
|
impl W {
|
|
#[doc = r" Reset value of the register"]
|
|
#[inline]
|
|
pub fn reset_value() -> W {
|
|
W { bits: 0 }
|
|
}
|
|
#[doc = r" Writes raw bits to the register"]
|
|
#[inline]
|
|
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
|
self.bits = bits;
|
|
self
|
|
}
|
|
#[doc = "Bit 0 - Clear LFXT oscillator fault interrupt flag"]
|
|
#[inline]
|
|
pub fn clr_lfxtifg(&mut self) -> _CLR_LFXTIFGW {
|
|
_CLR_LFXTIFGW { w: self }
|
|
}
|
|
#[doc = "Bit 1 - Clear HFXT oscillator fault interrupt flag"]
|
|
#[inline]
|
|
pub fn clr_hfxtifg(&mut self) -> _CLR_HFXTIFGW {
|
|
_CLR_HFXTIFGW { w: self }
|
|
}
|
|
#[doc = "Bit 2 - Clear HFXT2 oscillator fault interrupt flag"]
|
|
#[inline]
|
|
pub fn clr_hfxt2ifg(&mut self) -> _CLR_HFXT2IFGW {
|
|
_CLR_HFXT2IFGW { w: self }
|
|
}
|
|
#[doc = "Bit 6 - Clear DCO external resistor open circuit fault interrupt flag."]
|
|
#[inline]
|
|
pub fn clr_dcor_opnifg(&mut self) -> _CLR_DCOR_OPNIFGW {
|
|
_CLR_DCOR_OPNIFGW { w: self }
|
|
}
|
|
#[doc = "Bit 15 - REFCNT period counter clear interrupt flag"]
|
|
#[inline]
|
|
pub fn clr_califg(&mut self) -> _CLR_CALIFGW {
|
|
_CLR_CALIFGW { w: self }
|
|
}
|
|
#[doc = "Bit 8 - Start fault counter clear interrupt flag LFXT"]
|
|
#[inline]
|
|
pub fn clr_fcntlfifg(&mut self) -> _CLR_FCNTLFIFGW {
|
|
_CLR_FCNTLFIFGW { w: self }
|
|
}
|
|
#[doc = "Bit 9 - Start fault counter clear interrupt flag HFXT"]
|
|
#[inline]
|
|
pub fn clr_fcnthfifg(&mut self) -> _CLR_FCNTHFIFGW {
|
|
_CLR_FCNTHFIFGW { w: self }
|
|
}
|
|
#[doc = "Bit 10 - Start fault counter clear interrupt flag HFXT2"]
|
|
#[inline]
|
|
pub fn clr_fcnthf2ifg(&mut self) -> _CLR_FCNTHF2IFGW {
|
|
_CLR_FCNTHF2IFGW { w: self }
|
|
}
|
|
#[doc = "Bit 12 - PLL out-of-lock clear interrupt flag"]
|
|
#[inline]
|
|
pub fn clr_plloolifg(&mut self) -> _CLR_PLLOOLIFGW {
|
|
_CLR_PLLOOLIFGW { w: self }
|
|
}
|
|
#[doc = "Bit 13 - PLL loss-of-signal clear interrupt flag"]
|
|
#[inline]
|
|
pub fn clr_plllosifg(&mut self) -> _CLR_PLLLOSIFGW {
|
|
_CLR_PLLLOSIFGW { w: self }
|
|
}
|
|
#[doc = "Bit 14 - PLL out-of-range clear interrupt flag"]
|
|
#[inline]
|
|
pub fn clr_plloorifg(&mut self) -> _CLR_PLLOORIFGW {
|
|
_CLR_PLLOORIFGW { w: self }
|
|
}
|
|
}
|