693 lines
19 KiB
Rust
693 lines
19 KiB
Rust
#[doc = r" Value read from the register"]
|
|
pub struct R {
|
|
bits: u32,
|
|
}
|
|
impl super::CSIFG {
|
|
#[doc = r" Reads the contents of the register"]
|
|
#[inline]
|
|
pub fn read(&self) -> R {
|
|
R {
|
|
bits: self.register.get(),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `LFXTIFG`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum LFXTIFGR {
|
|
#[doc = "No fault condition occurred after the last reset"]
|
|
LFXTIFG_0,
|
|
#[doc = "LFXT fault. A LFXT fault occurred after the last reset"]
|
|
LFXTIFG_1,
|
|
}
|
|
impl LFXTIFGR {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
LFXTIFGR::LFXTIFG_0 => false,
|
|
LFXTIFGR::LFXTIFG_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> LFXTIFGR {
|
|
match value {
|
|
false => LFXTIFGR::LFXTIFG_0,
|
|
true => LFXTIFGR::LFXTIFG_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `LFXTIFG_0`"]
|
|
#[inline]
|
|
pub fn is_lfxtifg_0(&self) -> bool {
|
|
*self == LFXTIFGR::LFXTIFG_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `LFXTIFG_1`"]
|
|
#[inline]
|
|
pub fn is_lfxtifg_1(&self) -> bool {
|
|
*self == LFXTIFGR::LFXTIFG_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `HFXTIFG`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum HFXTIFGR {
|
|
#[doc = "No fault condition occurred after the last reset"]
|
|
HFXTIFG_0,
|
|
#[doc = "HFXT fault. A HFXT fault occurred after the last reset"]
|
|
HFXTIFG_1,
|
|
}
|
|
impl HFXTIFGR {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
HFXTIFGR::HFXTIFG_0 => false,
|
|
HFXTIFGR::HFXTIFG_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> HFXTIFGR {
|
|
match value {
|
|
false => HFXTIFGR::HFXTIFG_0,
|
|
true => HFXTIFGR::HFXTIFG_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `HFXTIFG_0`"]
|
|
#[inline]
|
|
pub fn is_hfxtifg_0(&self) -> bool {
|
|
*self == HFXTIFGR::HFXTIFG_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `HFXTIFG_1`"]
|
|
#[inline]
|
|
pub fn is_hfxtifg_1(&self) -> bool {
|
|
*self == HFXTIFGR::HFXTIFG_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `HFXT2IFG`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum HFXT2IFGR {
|
|
#[doc = "No fault condition occurred after the last reset"]
|
|
HFXT2IFG_0,
|
|
#[doc = "HFXT2 fault. A HFXT2 fault occurred after the last reset"]
|
|
HFXT2IFG_1,
|
|
}
|
|
impl HFXT2IFGR {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
HFXT2IFGR::HFXT2IFG_0 => false,
|
|
HFXT2IFGR::HFXT2IFG_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> HFXT2IFGR {
|
|
match value {
|
|
false => HFXT2IFGR::HFXT2IFG_0,
|
|
true => HFXT2IFGR::HFXT2IFG_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `HFXT2IFG_0`"]
|
|
#[inline]
|
|
pub fn is_hfxt2ifg_0(&self) -> bool {
|
|
*self == HFXT2IFGR::HFXT2IFG_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `HFXT2IFG_1`"]
|
|
#[inline]
|
|
pub fn is_hfxt2ifg_1(&self) -> bool {
|
|
*self == HFXT2IFGR::HFXT2IFG_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `DCOR_SHTIFG`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum DCOR_SHTIFGR {
|
|
#[doc = "DCO external resistor present"]
|
|
DCOR_SHTIFG_0,
|
|
#[doc = "DCO external resistor short circuit fault"]
|
|
DCOR_SHTIFG_1,
|
|
}
|
|
impl DCOR_SHTIFGR {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
DCOR_SHTIFGR::DCOR_SHTIFG_0 => false,
|
|
DCOR_SHTIFGR::DCOR_SHTIFG_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> DCOR_SHTIFGR {
|
|
match value {
|
|
false => DCOR_SHTIFGR::DCOR_SHTIFG_0,
|
|
true => DCOR_SHTIFGR::DCOR_SHTIFG_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `DCOR_SHTIFG_0`"]
|
|
#[inline]
|
|
pub fn is_dcor_shtifg_0(&self) -> bool {
|
|
*self == DCOR_SHTIFGR::DCOR_SHTIFG_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `DCOR_SHTIFG_1`"]
|
|
#[inline]
|
|
pub fn is_dcor_shtifg_1(&self) -> bool {
|
|
*self == DCOR_SHTIFGR::DCOR_SHTIFG_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `DCOR_OPNIFG`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum DCOR_OPNIFGR {
|
|
#[doc = "DCO external resistor present"]
|
|
DCOR_OPNIFG_0,
|
|
#[doc = "DCO external resistor open circuit fault"]
|
|
DCOR_OPNIFG_1,
|
|
}
|
|
impl DCOR_OPNIFGR {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
DCOR_OPNIFGR::DCOR_OPNIFG_0 => false,
|
|
DCOR_OPNIFGR::DCOR_OPNIFG_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> DCOR_OPNIFGR {
|
|
match value {
|
|
false => DCOR_OPNIFGR::DCOR_OPNIFG_0,
|
|
true => DCOR_OPNIFGR::DCOR_OPNIFG_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `DCOR_OPNIFG_0`"]
|
|
#[inline]
|
|
pub fn is_dcor_opnifg_0(&self) -> bool {
|
|
*self == DCOR_OPNIFGR::DCOR_OPNIFG_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `DCOR_OPNIFG_1`"]
|
|
#[inline]
|
|
pub fn is_dcor_opnifg_1(&self) -> bool {
|
|
*self == DCOR_OPNIFGR::DCOR_OPNIFG_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `FCNTLFIFG`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum FCNTLFIFGR {
|
|
#[doc = "Start counter not expired"]
|
|
FCNTLFIFG_0,
|
|
#[doc = "Start counter expired"]
|
|
FCNTLFIFG_1,
|
|
}
|
|
impl FCNTLFIFGR {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
FCNTLFIFGR::FCNTLFIFG_0 => false,
|
|
FCNTLFIFGR::FCNTLFIFG_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> FCNTLFIFGR {
|
|
match value {
|
|
false => FCNTLFIFGR::FCNTLFIFG_0,
|
|
true => FCNTLFIFGR::FCNTLFIFG_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `FCNTLFIFG_0`"]
|
|
#[inline]
|
|
pub fn is_fcntlfifg_0(&self) -> bool {
|
|
*self == FCNTLFIFGR::FCNTLFIFG_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `FCNTLFIFG_1`"]
|
|
#[inline]
|
|
pub fn is_fcntlfifg_1(&self) -> bool {
|
|
*self == FCNTLFIFGR::FCNTLFIFG_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `FCNTHFIFG`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum FCNTHFIFGR {
|
|
#[doc = "Start counter not expired"]
|
|
FCNTHFIFG_0,
|
|
#[doc = "Start counter expired"]
|
|
FCNTHFIFG_1,
|
|
}
|
|
impl FCNTHFIFGR {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
FCNTHFIFGR::FCNTHFIFG_0 => false,
|
|
FCNTHFIFGR::FCNTHFIFG_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> FCNTHFIFGR {
|
|
match value {
|
|
false => FCNTHFIFGR::FCNTHFIFG_0,
|
|
true => FCNTHFIFGR::FCNTHFIFG_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `FCNTHFIFG_0`"]
|
|
#[inline]
|
|
pub fn is_fcnthfifg_0(&self) -> bool {
|
|
*self == FCNTHFIFGR::FCNTHFIFG_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `FCNTHFIFG_1`"]
|
|
#[inline]
|
|
pub fn is_fcnthfifg_1(&self) -> bool {
|
|
*self == FCNTHFIFGR::FCNTHFIFG_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `FCNTHF2IFG`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum FCNTHF2IFGR {
|
|
#[doc = "Start counter not expired"]
|
|
FCNTHF2IFG_0,
|
|
#[doc = "Start counter expired"]
|
|
FCNTHF2IFG_1,
|
|
}
|
|
impl FCNTHF2IFGR {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
FCNTHF2IFGR::FCNTHF2IFG_0 => false,
|
|
FCNTHF2IFGR::FCNTHF2IFG_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> FCNTHF2IFGR {
|
|
match value {
|
|
false => FCNTHF2IFGR::FCNTHF2IFG_0,
|
|
true => FCNTHF2IFGR::FCNTHF2IFG_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `FCNTHF2IFG_0`"]
|
|
#[inline]
|
|
pub fn is_fcnthf2ifg_0(&self) -> bool {
|
|
*self == FCNTHF2IFGR::FCNTHF2IFG_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `FCNTHF2IFG_1`"]
|
|
#[inline]
|
|
pub fn is_fcnthf2ifg_1(&self) -> bool {
|
|
*self == FCNTHF2IFGR::FCNTHF2IFG_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `PLLOOLIFG`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum PLLOOLIFGR {
|
|
#[doc = "No interrupt pending"]
|
|
PLLOOLIFG_0,
|
|
#[doc = "Interrupt pending"]
|
|
PLLOOLIFG_1,
|
|
}
|
|
impl PLLOOLIFGR {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
PLLOOLIFGR::PLLOOLIFG_0 => false,
|
|
PLLOOLIFGR::PLLOOLIFG_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> PLLOOLIFGR {
|
|
match value {
|
|
false => PLLOOLIFGR::PLLOOLIFG_0,
|
|
true => PLLOOLIFGR::PLLOOLIFG_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `PLLOOLIFG_0`"]
|
|
#[inline]
|
|
pub fn is_plloolifg_0(&self) -> bool {
|
|
*self == PLLOOLIFGR::PLLOOLIFG_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `PLLOOLIFG_1`"]
|
|
#[inline]
|
|
pub fn is_plloolifg_1(&self) -> bool {
|
|
*self == PLLOOLIFGR::PLLOOLIFG_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `PLLLOSIFG`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum PLLLOSIFGR {
|
|
#[doc = "No interrupt pending"]
|
|
PLLLOSIFG_0,
|
|
#[doc = "Interrupt pending"]
|
|
PLLLOSIFG_1,
|
|
}
|
|
impl PLLLOSIFGR {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
PLLLOSIFGR::PLLLOSIFG_0 => false,
|
|
PLLLOSIFGR::PLLLOSIFG_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> PLLLOSIFGR {
|
|
match value {
|
|
false => PLLLOSIFGR::PLLLOSIFG_0,
|
|
true => PLLLOSIFGR::PLLLOSIFG_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `PLLLOSIFG_0`"]
|
|
#[inline]
|
|
pub fn is_plllosifg_0(&self) -> bool {
|
|
*self == PLLLOSIFGR::PLLLOSIFG_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `PLLLOSIFG_1`"]
|
|
#[inline]
|
|
pub fn is_plllosifg_1(&self) -> bool {
|
|
*self == PLLLOSIFGR::PLLLOSIFG_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `PLLOORIFG`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum PLLOORIFGR {
|
|
#[doc = "No interrupt pending"]
|
|
PLLOORIFG_0,
|
|
#[doc = "Interrupt pending"]
|
|
PLLOORIFG_1,
|
|
}
|
|
impl PLLOORIFGR {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
PLLOORIFGR::PLLOORIFG_0 => false,
|
|
PLLOORIFGR::PLLOORIFG_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> PLLOORIFGR {
|
|
match value {
|
|
false => PLLOORIFGR::PLLOORIFG_0,
|
|
true => PLLOORIFGR::PLLOORIFG_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `PLLOORIFG_0`"]
|
|
#[inline]
|
|
pub fn is_plloorifg_0(&self) -> bool {
|
|
*self == PLLOORIFGR::PLLOORIFG_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `PLLOORIFG_1`"]
|
|
#[inline]
|
|
pub fn is_plloorifg_1(&self) -> bool {
|
|
*self == PLLOORIFGR::PLLOORIFG_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `CALIFG`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum CALIFGR {
|
|
#[doc = "REFCNT period counter not expired"]
|
|
CALIFG_0,
|
|
#[doc = "REFCNT period counter expired"]
|
|
CALIFG_1,
|
|
}
|
|
impl CALIFGR {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
CALIFGR::CALIFG_0 => false,
|
|
CALIFGR::CALIFG_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> CALIFGR {
|
|
match value {
|
|
false => CALIFGR::CALIFG_0,
|
|
true => CALIFGR::CALIFG_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `CALIFG_0`"]
|
|
#[inline]
|
|
pub fn is_califg_0(&self) -> bool {
|
|
*self == CALIFGR::CALIFG_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `CALIFG_1`"]
|
|
#[inline]
|
|
pub fn is_califg_1(&self) -> bool {
|
|
*self == CALIFGR::CALIFG_1
|
|
}
|
|
}
|
|
impl R {
|
|
#[doc = r" Value of the register as raw bits"]
|
|
#[inline]
|
|
pub fn bits(&self) -> u32 {
|
|
self.bits
|
|
}
|
|
#[doc = "Bit 0 - LFXT oscillator fault flag"]
|
|
#[inline]
|
|
pub fn lfxtifg(&self) -> LFXTIFGR {
|
|
LFXTIFGR::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 0;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 1 - HFXT oscillator fault flag"]
|
|
#[inline]
|
|
pub fn hfxtifg(&self) -> HFXTIFGR {
|
|
HFXTIFGR::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 1;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 2 - HFXT2 oscillator fault flag"]
|
|
#[inline]
|
|
pub fn hfxt2ifg(&self) -> HFXT2IFGR {
|
|
HFXT2IFGR::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 2;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 5 - DCO external resistor short circuit fault flag."]
|
|
#[inline]
|
|
pub fn dcor_shtifg(&self) -> DCOR_SHTIFGR {
|
|
DCOR_SHTIFGR::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 5;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 6 - DCO external resistor open circuit fault flag."]
|
|
#[inline]
|
|
pub fn dcor_opnifg(&self) -> DCOR_OPNIFGR {
|
|
DCOR_OPNIFGR::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 6;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 8 - Start fault counter interrupt flag LFXT"]
|
|
#[inline]
|
|
pub fn fcntlfifg(&self) -> FCNTLFIFGR {
|
|
FCNTLFIFGR::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 8;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 9 - Start fault counter interrupt flag HFXT"]
|
|
#[inline]
|
|
pub fn fcnthfifg(&self) -> FCNTHFIFGR {
|
|
FCNTHFIFGR::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 9;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 11 - Start fault counter interrupt flag HFXT2"]
|
|
#[inline]
|
|
pub fn fcnthf2ifg(&self) -> FCNTHF2IFGR {
|
|
FCNTHF2IFGR::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 11;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 12 - PLL out-of-lock interrupt flag"]
|
|
#[inline]
|
|
pub fn plloolifg(&self) -> PLLOOLIFGR {
|
|
PLLOOLIFGR::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 12;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 13 - PLL loss-of-signal interrupt flag"]
|
|
#[inline]
|
|
pub fn plllosifg(&self) -> PLLLOSIFGR {
|
|
PLLLOSIFGR::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 13;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 14 - PLL out-of-range interrupt flag"]
|
|
#[inline]
|
|
pub fn plloorifg(&self) -> PLLOORIFGR {
|
|
PLLOORIFGR::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 14;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 15 - REFCNT period counter expired"]
|
|
#[inline]
|
|
pub fn califg(&self) -> CALIFGR {
|
|
CALIFGR::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 15;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
}
|