1272 lines
33 KiB
Rust
1272 lines
33 KiB
Rust
#[doc = r" Value read from the register"]
|
|
pub struct R {
|
|
bits: u16,
|
|
}
|
|
#[doc = r" Value to write to the register"]
|
|
pub struct W {
|
|
bits: u16,
|
|
}
|
|
impl super::CEXCTL1 {
|
|
#[doc = r" Modifies the contents of the register"]
|
|
#[inline]
|
|
pub fn modify<F>(&self, f: F)
|
|
where
|
|
for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
|
|
{
|
|
let bits = self.register.get();
|
|
let r = R { bits: bits };
|
|
let mut w = W { bits: bits };
|
|
f(&r, &mut w);
|
|
self.register.set(w.bits);
|
|
}
|
|
#[doc = r" Reads the contents of the register"]
|
|
#[inline]
|
|
pub fn read(&self) -> R {
|
|
R {
|
|
bits: self.register.get(),
|
|
}
|
|
}
|
|
#[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 = r" Writes the reset value to the register"]
|
|
#[inline]
|
|
pub fn reset(&self) {
|
|
self.write(|w| w)
|
|
}
|
|
}
|
|
#[doc = r" Value of the field"]
|
|
pub struct CEOUTR {
|
|
bits: bool,
|
|
}
|
|
impl CEOUTR {
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
self.bits
|
|
}
|
|
#[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 = "Possible values of the field `CEOUTPOL`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum CEOUTPOLR {
|
|
#[doc = "Noninverted"]
|
|
CEOUTPOL_0,
|
|
#[doc = "Inverted"]
|
|
CEOUTPOL_1,
|
|
}
|
|
impl CEOUTPOLR {
|
|
#[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 {
|
|
CEOUTPOLR::CEOUTPOL_0 => false,
|
|
CEOUTPOLR::CEOUTPOL_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> CEOUTPOLR {
|
|
match value {
|
|
false => CEOUTPOLR::CEOUTPOL_0,
|
|
true => CEOUTPOLR::CEOUTPOL_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `CEOUTPOL_0`"]
|
|
#[inline]
|
|
pub fn is_ceoutpol_0(&self) -> bool {
|
|
*self == CEOUTPOLR::CEOUTPOL_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `CEOUTPOL_1`"]
|
|
#[inline]
|
|
pub fn is_ceoutpol_1(&self) -> bool {
|
|
*self == CEOUTPOLR::CEOUTPOL_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `CEF`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum CEFR {
|
|
#[doc = "Comparator output is not filtered"]
|
|
CEF_0,
|
|
#[doc = "Comparator output is filtered"]
|
|
CEF_1,
|
|
}
|
|
impl CEFR {
|
|
#[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 {
|
|
CEFR::CEF_0 => false,
|
|
CEFR::CEF_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> CEFR {
|
|
match value {
|
|
false => CEFR::CEF_0,
|
|
true => CEFR::CEF_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `CEF_0`"]
|
|
#[inline]
|
|
pub fn is_cef_0(&self) -> bool {
|
|
*self == CEFR::CEF_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `CEF_1`"]
|
|
#[inline]
|
|
pub fn is_cef_1(&self) -> bool {
|
|
*self == CEFR::CEF_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `CEIES`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum CEIESR {
|
|
#[doc = "Rising edge for CEIFG, falling edge for CEIIFG"]
|
|
CEIES_0,
|
|
#[doc = "Falling edge for CEIFG, rising edge for CEIIFG"]
|
|
CEIES_1,
|
|
}
|
|
impl CEIESR {
|
|
#[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 {
|
|
CEIESR::CEIES_0 => false,
|
|
CEIESR::CEIES_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> CEIESR {
|
|
match value {
|
|
false => CEIESR::CEIES_0,
|
|
true => CEIESR::CEIES_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `CEIES_0`"]
|
|
#[inline]
|
|
pub fn is_ceies_0(&self) -> bool {
|
|
*self == CEIESR::CEIES_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `CEIES_1`"]
|
|
#[inline]
|
|
pub fn is_ceies_1(&self) -> bool {
|
|
*self == CEIESR::CEIES_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `CESHORT`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum CESHORTR {
|
|
#[doc = "Inputs not shorted"]
|
|
CESHORT_0,
|
|
#[doc = "Inputs shorted"]
|
|
CESHORT_1,
|
|
}
|
|
impl CESHORTR {
|
|
#[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 {
|
|
CESHORTR::CESHORT_0 => false,
|
|
CESHORTR::CESHORT_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> CESHORTR {
|
|
match value {
|
|
false => CESHORTR::CESHORT_0,
|
|
true => CESHORTR::CESHORT_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `CESHORT_0`"]
|
|
#[inline]
|
|
pub fn is_ceshort_0(&self) -> bool {
|
|
*self == CESHORTR::CESHORT_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `CESHORT_1`"]
|
|
#[inline]
|
|
pub fn is_ceshort_1(&self) -> bool {
|
|
*self == CESHORTR::CESHORT_1
|
|
}
|
|
}
|
|
#[doc = r" Value of the field"]
|
|
pub struct CEEXR {
|
|
bits: bool,
|
|
}
|
|
impl CEEXR {
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
self.bits
|
|
}
|
|
#[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 = "Possible values of the field `CEFDLY`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum CEFDLYR {
|
|
#[doc = "Typical filter delay of TBD (450) ns"]
|
|
CEFDLY_0,
|
|
#[doc = "Typical filter delay of TBD (900) ns"]
|
|
CEFDLY_1,
|
|
#[doc = "Typical filter delay of TBD (1800) ns"]
|
|
CEFDLY_2,
|
|
#[doc = "Typical filter delay of TBD (3600) ns"]
|
|
CEFDLY_3,
|
|
}
|
|
impl CEFDLYR {
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bits(&self) -> u8 {
|
|
match *self {
|
|
CEFDLYR::CEFDLY_0 => 0,
|
|
CEFDLYR::CEFDLY_1 => 1,
|
|
CEFDLYR::CEFDLY_2 => 2,
|
|
CEFDLYR::CEFDLY_3 => 3,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: u8) -> CEFDLYR {
|
|
match value {
|
|
0 => CEFDLYR::CEFDLY_0,
|
|
1 => CEFDLYR::CEFDLY_1,
|
|
2 => CEFDLYR::CEFDLY_2,
|
|
3 => CEFDLYR::CEFDLY_3,
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `CEFDLY_0`"]
|
|
#[inline]
|
|
pub fn is_cefdly_0(&self) -> bool {
|
|
*self == CEFDLYR::CEFDLY_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `CEFDLY_1`"]
|
|
#[inline]
|
|
pub fn is_cefdly_1(&self) -> bool {
|
|
*self == CEFDLYR::CEFDLY_1
|
|
}
|
|
#[doc = "Checks if the value of the field is `CEFDLY_2`"]
|
|
#[inline]
|
|
pub fn is_cefdly_2(&self) -> bool {
|
|
*self == CEFDLYR::CEFDLY_2
|
|
}
|
|
#[doc = "Checks if the value of the field is `CEFDLY_3`"]
|
|
#[inline]
|
|
pub fn is_cefdly_3(&self) -> bool {
|
|
*self == CEFDLYR::CEFDLY_3
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `CEPWRMD`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum CEPWRMDR {
|
|
#[doc = "High-speed mode"]
|
|
CEPWRMD_0,
|
|
#[doc = "Normal mode"]
|
|
CEPWRMD_1,
|
|
#[doc = "Ultra-low power mode"]
|
|
CEPWRMD_2,
|
|
#[doc = r" Reserved"]
|
|
_Reserved(u8),
|
|
}
|
|
impl CEPWRMDR {
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bits(&self) -> u8 {
|
|
match *self {
|
|
CEPWRMDR::CEPWRMD_0 => 0,
|
|
CEPWRMDR::CEPWRMD_1 => 1,
|
|
CEPWRMDR::CEPWRMD_2 => 2,
|
|
CEPWRMDR::_Reserved(bits) => bits,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: u8) -> CEPWRMDR {
|
|
match value {
|
|
0 => CEPWRMDR::CEPWRMD_0,
|
|
1 => CEPWRMDR::CEPWRMD_1,
|
|
2 => CEPWRMDR::CEPWRMD_2,
|
|
i => CEPWRMDR::_Reserved(i),
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `CEPWRMD_0`"]
|
|
#[inline]
|
|
pub fn is_cepwrmd_0(&self) -> bool {
|
|
*self == CEPWRMDR::CEPWRMD_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `CEPWRMD_1`"]
|
|
#[inline]
|
|
pub fn is_cepwrmd_1(&self) -> bool {
|
|
*self == CEPWRMDR::CEPWRMD_1
|
|
}
|
|
#[doc = "Checks if the value of the field is `CEPWRMD_2`"]
|
|
#[inline]
|
|
pub fn is_cepwrmd_2(&self) -> bool {
|
|
*self == CEPWRMDR::CEPWRMD_2
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `CEON`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum CEONR {
|
|
#[doc = "Off"]
|
|
CEON_0,
|
|
#[doc = "On"]
|
|
CEON_1,
|
|
}
|
|
impl CEONR {
|
|
#[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 {
|
|
CEONR::CEON_0 => false,
|
|
CEONR::CEON_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> CEONR {
|
|
match value {
|
|
false => CEONR::CEON_0,
|
|
true => CEONR::CEON_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `CEON_0`"]
|
|
#[inline]
|
|
pub fn is_ceon_0(&self) -> bool {
|
|
*self == CEONR::CEON_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `CEON_1`"]
|
|
#[inline]
|
|
pub fn is_ceon_1(&self) -> bool {
|
|
*self == CEONR::CEON_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `CEMRVL`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum CEMRVLR {
|
|
#[doc = "VREF0 is selected if CERS = 00, 01, or 10"]
|
|
CEMRVL_0,
|
|
#[doc = "VREF1 is selected if CERS = 00, 01, or 10"]
|
|
CEMRVL_1,
|
|
}
|
|
impl CEMRVLR {
|
|
#[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 {
|
|
CEMRVLR::CEMRVL_0 => false,
|
|
CEMRVLR::CEMRVL_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> CEMRVLR {
|
|
match value {
|
|
false => CEMRVLR::CEMRVL_0,
|
|
true => CEMRVLR::CEMRVL_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `CEMRVL_0`"]
|
|
#[inline]
|
|
pub fn is_cemrvl_0(&self) -> bool {
|
|
*self == CEMRVLR::CEMRVL_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `CEMRVL_1`"]
|
|
#[inline]
|
|
pub fn is_cemrvl_1(&self) -> bool {
|
|
*self == CEMRVLR::CEMRVL_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `CEMRVS`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum CEMRVSR {
|
|
#[doc = "Comparator output state selects between VREF0 or VREF1"]
|
|
CEMRVS_0,
|
|
#[doc = "CEMRVL selects between VREF0 or VREF1"]
|
|
CEMRVS_1,
|
|
}
|
|
impl CEMRVSR {
|
|
#[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 {
|
|
CEMRVSR::CEMRVS_0 => false,
|
|
CEMRVSR::CEMRVS_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> CEMRVSR {
|
|
match value {
|
|
false => CEMRVSR::CEMRVS_0,
|
|
true => CEMRVSR::CEMRVS_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `CEMRVS_0`"]
|
|
#[inline]
|
|
pub fn is_cemrvs_0(&self) -> bool {
|
|
*self == CEMRVSR::CEMRVS_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `CEMRVS_1`"]
|
|
#[inline]
|
|
pub fn is_cemrvs_1(&self) -> bool {
|
|
*self == CEMRVSR::CEMRVS_1
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _CEOUTW<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _CEOUTW<'a> {
|
|
#[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 u16) << OFFSET);
|
|
self.w.bits |= ((value & MASK) as u16) << OFFSET;
|
|
self.w
|
|
}
|
|
}
|
|
#[doc = "Values that can be written to the field `CEOUTPOL`"]
|
|
pub enum CEOUTPOLW {
|
|
#[doc = "Noninverted"]
|
|
CEOUTPOL_0,
|
|
#[doc = "Inverted"]
|
|
CEOUTPOL_1,
|
|
}
|
|
impl CEOUTPOLW {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
CEOUTPOLW::CEOUTPOL_0 => false,
|
|
CEOUTPOLW::CEOUTPOL_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _CEOUTPOLW<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _CEOUTPOLW<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: CEOUTPOLW) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Noninverted"]
|
|
#[inline]
|
|
pub fn ceoutpol_0(self) -> &'a mut W {
|
|
self.variant(CEOUTPOLW::CEOUTPOL_0)
|
|
}
|
|
#[doc = "Inverted"]
|
|
#[inline]
|
|
pub fn ceoutpol_1(self) -> &'a mut W {
|
|
self.variant(CEOUTPOLW::CEOUTPOL_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 u16) << OFFSET);
|
|
self.w.bits |= ((value & MASK) as u16) << OFFSET;
|
|
self.w
|
|
}
|
|
}
|
|
#[doc = "Values that can be written to the field `CEF`"]
|
|
pub enum CEFW {
|
|
#[doc = "Comparator output is not filtered"]
|
|
CEF_0,
|
|
#[doc = "Comparator output is filtered"]
|
|
CEF_1,
|
|
}
|
|
impl CEFW {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
CEFW::CEF_0 => false,
|
|
CEFW::CEF_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _CEFW<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _CEFW<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: CEFW) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Comparator output is not filtered"]
|
|
#[inline]
|
|
pub fn cef_0(self) -> &'a mut W {
|
|
self.variant(CEFW::CEF_0)
|
|
}
|
|
#[doc = "Comparator output is filtered"]
|
|
#[inline]
|
|
pub fn cef_1(self) -> &'a mut W {
|
|
self.variant(CEFW::CEF_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 u16) << OFFSET);
|
|
self.w.bits |= ((value & MASK) as u16) << OFFSET;
|
|
self.w
|
|
}
|
|
}
|
|
#[doc = "Values that can be written to the field `CEIES`"]
|
|
pub enum CEIESW {
|
|
#[doc = "Rising edge for CEIFG, falling edge for CEIIFG"]
|
|
CEIES_0,
|
|
#[doc = "Falling edge for CEIFG, rising edge for CEIIFG"]
|
|
CEIES_1,
|
|
}
|
|
impl CEIESW {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
CEIESW::CEIES_0 => false,
|
|
CEIESW::CEIES_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _CEIESW<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _CEIESW<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: CEIESW) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Rising edge for CEIFG, falling edge for CEIIFG"]
|
|
#[inline]
|
|
pub fn ceies_0(self) -> &'a mut W {
|
|
self.variant(CEIESW::CEIES_0)
|
|
}
|
|
#[doc = "Falling edge for CEIFG, rising edge for CEIIFG"]
|
|
#[inline]
|
|
pub fn ceies_1(self) -> &'a mut W {
|
|
self.variant(CEIESW::CEIES_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 = 3;
|
|
self.w.bits &= !((MASK as u16) << OFFSET);
|
|
self.w.bits |= ((value & MASK) as u16) << OFFSET;
|
|
self.w
|
|
}
|
|
}
|
|
#[doc = "Values that can be written to the field `CESHORT`"]
|
|
pub enum CESHORTW {
|
|
#[doc = "Inputs not shorted"]
|
|
CESHORT_0,
|
|
#[doc = "Inputs shorted"]
|
|
CESHORT_1,
|
|
}
|
|
impl CESHORTW {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
CESHORTW::CESHORT_0 => false,
|
|
CESHORTW::CESHORT_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _CESHORTW<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _CESHORTW<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: CESHORTW) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Inputs not shorted"]
|
|
#[inline]
|
|
pub fn ceshort_0(self) -> &'a mut W {
|
|
self.variant(CESHORTW::CESHORT_0)
|
|
}
|
|
#[doc = "Inputs shorted"]
|
|
#[inline]
|
|
pub fn ceshort_1(self) -> &'a mut W {
|
|
self.variant(CESHORTW::CESHORT_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 = 4;
|
|
self.w.bits &= !((MASK as u16) << OFFSET);
|
|
self.w.bits |= ((value & MASK) as u16) << OFFSET;
|
|
self.w
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _CEEXW<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _CEEXW<'a> {
|
|
#[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 = 5;
|
|
self.w.bits &= !((MASK as u16) << OFFSET);
|
|
self.w.bits |= ((value & MASK) as u16) << OFFSET;
|
|
self.w
|
|
}
|
|
}
|
|
#[doc = "Values that can be written to the field `CEFDLY`"]
|
|
pub enum CEFDLYW {
|
|
#[doc = "Typical filter delay of TBD (450) ns"]
|
|
CEFDLY_0,
|
|
#[doc = "Typical filter delay of TBD (900) ns"]
|
|
CEFDLY_1,
|
|
#[doc = "Typical filter delay of TBD (1800) ns"]
|
|
CEFDLY_2,
|
|
#[doc = "Typical filter delay of TBD (3600) ns"]
|
|
CEFDLY_3,
|
|
}
|
|
impl CEFDLYW {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> u8 {
|
|
match *self {
|
|
CEFDLYW::CEFDLY_0 => 0,
|
|
CEFDLYW::CEFDLY_1 => 1,
|
|
CEFDLYW::CEFDLY_2 => 2,
|
|
CEFDLYW::CEFDLY_3 => 3,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _CEFDLYW<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _CEFDLYW<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: CEFDLYW) -> &'a mut W {
|
|
{
|
|
self.bits(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Typical filter delay of TBD (450) ns"]
|
|
#[inline]
|
|
pub fn cefdly_0(self) -> &'a mut W {
|
|
self.variant(CEFDLYW::CEFDLY_0)
|
|
}
|
|
#[doc = "Typical filter delay of TBD (900) ns"]
|
|
#[inline]
|
|
pub fn cefdly_1(self) -> &'a mut W {
|
|
self.variant(CEFDLYW::CEFDLY_1)
|
|
}
|
|
#[doc = "Typical filter delay of TBD (1800) ns"]
|
|
#[inline]
|
|
pub fn cefdly_2(self) -> &'a mut W {
|
|
self.variant(CEFDLYW::CEFDLY_2)
|
|
}
|
|
#[doc = "Typical filter delay of TBD (3600) ns"]
|
|
#[inline]
|
|
pub fn cefdly_3(self) -> &'a mut W {
|
|
self.variant(CEFDLYW::CEFDLY_3)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bits(self, value: u8) -> &'a mut W {
|
|
const MASK: u8 = 3;
|
|
const OFFSET: u8 = 6;
|
|
self.w.bits &= !((MASK as u16) << OFFSET);
|
|
self.w.bits |= ((value & MASK) as u16) << OFFSET;
|
|
self.w
|
|
}
|
|
}
|
|
#[doc = "Values that can be written to the field `CEPWRMD`"]
|
|
pub enum CEPWRMDW {
|
|
#[doc = "High-speed mode"]
|
|
CEPWRMD_0,
|
|
#[doc = "Normal mode"]
|
|
CEPWRMD_1,
|
|
#[doc = "Ultra-low power mode"]
|
|
CEPWRMD_2,
|
|
}
|
|
impl CEPWRMDW {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> u8 {
|
|
match *self {
|
|
CEPWRMDW::CEPWRMD_0 => 0,
|
|
CEPWRMDW::CEPWRMD_1 => 1,
|
|
CEPWRMDW::CEPWRMD_2 => 2,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _CEPWRMDW<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _CEPWRMDW<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: CEPWRMDW) -> &'a mut W {
|
|
unsafe { self.bits(variant._bits()) }
|
|
}
|
|
#[doc = "High-speed mode"]
|
|
#[inline]
|
|
pub fn cepwrmd_0(self) -> &'a mut W {
|
|
self.variant(CEPWRMDW::CEPWRMD_0)
|
|
}
|
|
#[doc = "Normal mode"]
|
|
#[inline]
|
|
pub fn cepwrmd_1(self) -> &'a mut W {
|
|
self.variant(CEPWRMDW::CEPWRMD_1)
|
|
}
|
|
#[doc = "Ultra-low power mode"]
|
|
#[inline]
|
|
pub fn cepwrmd_2(self) -> &'a mut W {
|
|
self.variant(CEPWRMDW::CEPWRMD_2)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub unsafe fn bits(self, value: u8) -> &'a mut W {
|
|
const MASK: u8 = 3;
|
|
const OFFSET: u8 = 8;
|
|
self.w.bits &= !((MASK as u16) << OFFSET);
|
|
self.w.bits |= ((value & MASK) as u16) << OFFSET;
|
|
self.w
|
|
}
|
|
}
|
|
#[doc = "Values that can be written to the field `CEON`"]
|
|
pub enum CEONW {
|
|
#[doc = "Off"]
|
|
CEON_0,
|
|
#[doc = "On"]
|
|
CEON_1,
|
|
}
|
|
impl CEONW {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
CEONW::CEON_0 => false,
|
|
CEONW::CEON_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _CEONW<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _CEONW<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: CEONW) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Off"]
|
|
#[inline]
|
|
pub fn ceon_0(self) -> &'a mut W {
|
|
self.variant(CEONW::CEON_0)
|
|
}
|
|
#[doc = "On"]
|
|
#[inline]
|
|
pub fn ceon_1(self) -> &'a mut W {
|
|
self.variant(CEONW::CEON_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 u16) << OFFSET);
|
|
self.w.bits |= ((value & MASK) as u16) << OFFSET;
|
|
self.w
|
|
}
|
|
}
|
|
#[doc = "Values that can be written to the field `CEMRVL`"]
|
|
pub enum CEMRVLW {
|
|
#[doc = "VREF0 is selected if CERS = 00, 01, or 10"]
|
|
CEMRVL_0,
|
|
#[doc = "VREF1 is selected if CERS = 00, 01, or 10"]
|
|
CEMRVL_1,
|
|
}
|
|
impl CEMRVLW {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
CEMRVLW::CEMRVL_0 => false,
|
|
CEMRVLW::CEMRVL_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _CEMRVLW<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _CEMRVLW<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: CEMRVLW) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "VREF0 is selected if CERS = 00, 01, or 10"]
|
|
#[inline]
|
|
pub fn cemrvl_0(self) -> &'a mut W {
|
|
self.variant(CEMRVLW::CEMRVL_0)
|
|
}
|
|
#[doc = "VREF1 is selected if CERS = 00, 01, or 10"]
|
|
#[inline]
|
|
pub fn cemrvl_1(self) -> &'a mut W {
|
|
self.variant(CEMRVLW::CEMRVL_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 = 11;
|
|
self.w.bits &= !((MASK as u16) << OFFSET);
|
|
self.w.bits |= ((value & MASK) as u16) << OFFSET;
|
|
self.w
|
|
}
|
|
}
|
|
#[doc = "Values that can be written to the field `CEMRVS`"]
|
|
pub enum CEMRVSW {
|
|
#[doc = "Comparator output state selects between VREF0 or VREF1"]
|
|
CEMRVS_0,
|
|
#[doc = "CEMRVL selects between VREF0 or VREF1"]
|
|
CEMRVS_1,
|
|
}
|
|
impl CEMRVSW {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
CEMRVSW::CEMRVS_0 => false,
|
|
CEMRVSW::CEMRVS_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _CEMRVSW<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _CEMRVSW<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: CEMRVSW) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Comparator output state selects between VREF0 or VREF1"]
|
|
#[inline]
|
|
pub fn cemrvs_0(self) -> &'a mut W {
|
|
self.variant(CEMRVSW::CEMRVS_0)
|
|
}
|
|
#[doc = "CEMRVL selects between VREF0 or VREF1"]
|
|
#[inline]
|
|
pub fn cemrvs_1(self) -> &'a mut W {
|
|
self.variant(CEMRVSW::CEMRVS_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 u16) << OFFSET);
|
|
self.w.bits |= ((value & MASK) as u16) << OFFSET;
|
|
self.w
|
|
}
|
|
}
|
|
impl R {
|
|
#[doc = r" Value of the register as raw bits"]
|
|
#[inline]
|
|
pub fn bits(&self) -> u16 {
|
|
self.bits
|
|
}
|
|
#[doc = "Bit 0 - Comparator output value"]
|
|
#[inline]
|
|
pub fn ceout(&self) -> CEOUTR {
|
|
let bits = {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 0;
|
|
((self.bits >> OFFSET) & MASK as u16) != 0
|
|
};
|
|
CEOUTR { bits }
|
|
}
|
|
#[doc = "Bit 1 - Comparator output polarity"]
|
|
#[inline]
|
|
pub fn ceoutpol(&self) -> CEOUTPOLR {
|
|
CEOUTPOLR::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 1;
|
|
((self.bits >> OFFSET) & MASK as u16) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 2 - Comparator output filter"]
|
|
#[inline]
|
|
pub fn cef(&self) -> CEFR {
|
|
CEFR::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 2;
|
|
((self.bits >> OFFSET) & MASK as u16) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 3 - Interrupt edge select for CEIIFG and CEIFG"]
|
|
#[inline]
|
|
pub fn ceies(&self) -> CEIESR {
|
|
CEIESR::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 3;
|
|
((self.bits >> OFFSET) & MASK as u16) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 4 - Input short"]
|
|
#[inline]
|
|
pub fn ceshort(&self) -> CESHORTR {
|
|
CESHORTR::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 4;
|
|
((self.bits >> OFFSET) & MASK as u16) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 5 - Exchange"]
|
|
#[inline]
|
|
pub fn ceex(&self) -> CEEXR {
|
|
let bits = {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 5;
|
|
((self.bits >> OFFSET) & MASK as u16) != 0
|
|
};
|
|
CEEXR { bits }
|
|
}
|
|
#[doc = "Bits 6:7 - Filter delay"]
|
|
#[inline]
|
|
pub fn cefdly(&self) -> CEFDLYR {
|
|
CEFDLYR::_from({
|
|
const MASK: u8 = 3;
|
|
const OFFSET: u8 = 6;
|
|
((self.bits >> OFFSET) & MASK as u16) as u8
|
|
})
|
|
}
|
|
#[doc = "Bits 8:9 - Power Mode"]
|
|
#[inline]
|
|
pub fn cepwrmd(&self) -> CEPWRMDR {
|
|
CEPWRMDR::_from({
|
|
const MASK: u8 = 3;
|
|
const OFFSET: u8 = 8;
|
|
((self.bits >> OFFSET) & MASK as u16) as u8
|
|
})
|
|
}
|
|
#[doc = "Bit 10 - Comparator On"]
|
|
#[inline]
|
|
pub fn ceon(&self) -> CEONR {
|
|
CEONR::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 10;
|
|
((self.bits >> OFFSET) & MASK as u16) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 11 - This bit is valid of CEMRVS is set to 1"]
|
|
#[inline]
|
|
pub fn cemrvl(&self) -> CEMRVLR {
|
|
CEMRVLR::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 11;
|
|
((self.bits >> OFFSET) & MASK as u16) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 12 - This bit defines if the comparator output selects between VREF0 or VREF1 if CERS = 00, 01, or 10."]
|
|
#[inline]
|
|
pub fn cemrvs(&self) -> CEMRVSR {
|
|
CEMRVSR::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 12;
|
|
((self.bits >> OFFSET) & MASK as u16) != 0
|
|
})
|
|
}
|
|
}
|
|
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: u16) -> &mut Self {
|
|
self.bits = bits;
|
|
self
|
|
}
|
|
#[doc = "Bit 0 - Comparator output value"]
|
|
#[inline]
|
|
pub fn ceout(&mut self) -> _CEOUTW {
|
|
_CEOUTW { w: self }
|
|
}
|
|
#[doc = "Bit 1 - Comparator output polarity"]
|
|
#[inline]
|
|
pub fn ceoutpol(&mut self) -> _CEOUTPOLW {
|
|
_CEOUTPOLW { w: self }
|
|
}
|
|
#[doc = "Bit 2 - Comparator output filter"]
|
|
#[inline]
|
|
pub fn cef(&mut self) -> _CEFW {
|
|
_CEFW { w: self }
|
|
}
|
|
#[doc = "Bit 3 - Interrupt edge select for CEIIFG and CEIFG"]
|
|
#[inline]
|
|
pub fn ceies(&mut self) -> _CEIESW {
|
|
_CEIESW { w: self }
|
|
}
|
|
#[doc = "Bit 4 - Input short"]
|
|
#[inline]
|
|
pub fn ceshort(&mut self) -> _CESHORTW {
|
|
_CESHORTW { w: self }
|
|
}
|
|
#[doc = "Bit 5 - Exchange"]
|
|
#[inline]
|
|
pub fn ceex(&mut self) -> _CEEXW {
|
|
_CEEXW { w: self }
|
|
}
|
|
#[doc = "Bits 6:7 - Filter delay"]
|
|
#[inline]
|
|
pub fn cefdly(&mut self) -> _CEFDLYW {
|
|
_CEFDLYW { w: self }
|
|
}
|
|
#[doc = "Bits 8:9 - Power Mode"]
|
|
#[inline]
|
|
pub fn cepwrmd(&mut self) -> _CEPWRMDW {
|
|
_CEPWRMDW { w: self }
|
|
}
|
|
#[doc = "Bit 10 - Comparator On"]
|
|
#[inline]
|
|
pub fn ceon(&mut self) -> _CEONW {
|
|
_CEONW { w: self }
|
|
}
|
|
#[doc = "Bit 11 - This bit is valid of CEMRVS is set to 1"]
|
|
#[inline]
|
|
pub fn cemrvl(&mut self) -> _CEMRVLW {
|
|
_CEMRVLW { w: self }
|
|
}
|
|
#[doc = "Bit 12 - This bit defines if the comparator output selects between VREF0 or VREF1 if CERS = 00, 01, or 10."]
|
|
#[inline]
|
|
pub fn cemrvs(&mut self) -> _CEMRVSW {
|
|
_CEMRVSW { w: self }
|
|
}
|
|
}
|