#[doc = r"Value read from the register"]
pub struct R {
bits: u32,
}
#[doc = r"Value to write to the register"]
pub struct W {
bits: u32,
}
impl super::IER {
#[doc = r"Modifies the contents of the register"]
#[inline(always)]
pub fn modify<F>(&self, f: F)
where
for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
{
let bits = self.register.get();
self.register.set(f(&R { bits }, &mut W { bits }).bits);
}
#[doc = r"Reads the contents of the register"]
#[inline(always)]
pub fn read(&self) -> R {
R {
bits: self.register.get(),
}
}
#[doc = r"Writes to the register"]
#[inline(always)]
pub fn write<F>(&self, f: F)
where
F: FnOnce(&mut W) -> &mut W,
{
self.register.set(
f(&mut W {
bits: Self::reset_value(),
})
.bits,
);
}
#[doc = r"Reset value of the register"]
#[inline(always)]
pub const fn reset_value() -> u32 {
0
}
#[doc = r"Writes the reset value to the register"]
#[inline(always)]
pub fn reset(&self) {
self.register.set(Self::reset_value())
}
}
#[doc = "Possible values of the field `SLKIE`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum SLKIER {
#[doc = "No interrupt when SLAKI bit is set"]
DISABLED,
#[doc = "Interrupt generated when SLAKI bit is set"]
ENABLED,
}
impl SLKIER {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
SLKIER::DISABLED => false,
SLKIER::ENABLED => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> SLKIER {
match value {
false => SLKIER::DISABLED,
true => SLKIER::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == SLKIER::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == SLKIER::ENABLED
}
}
#[doc = "Values that can be written to the field `SLKIE`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum SLKIEW {
#[doc = "No interrupt when SLAKI bit is set"]
DISABLED,
#[doc = "Interrupt generated when SLAKI bit is set"]
ENABLED,
}
impl SLKIEW {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _bits(&self) -> bool {
match *self {
SLKIEW::DISABLED => false,
SLKIEW::ENABLED => true,
}
}
}
#[doc = r"Proxy"]
pub struct _SLKIEW<'a> {
w: &'a mut W,
}
impl<'a> _SLKIEW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: SLKIEW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "No interrupt when SLAKI bit is set"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(SLKIEW::DISABLED)
}
#[doc = "Interrupt generated when SLAKI bit is set"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(SLKIEW::ENABLED)
}
#[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 &= !(0x01 << 17);
self.w.bits |= ((value as u32) & 0x01) << 17;
self.w
}
}
#[doc = "Possible values of the field `WKUIE`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum WKUIER {
#[doc = "No interrupt when WKUI is set"]
DISABLED,
#[doc = "Interrupt generated when WKUI bit is set"]
ENABLED,
}
impl WKUIER {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
WKUIER::DISABLED => false,
WKUIER::ENABLED => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> WKUIER {
match value {
false => WKUIER::DISABLED,
true => WKUIER::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == WKUIER::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == WKUIER::ENABLED
}
}
#[doc = "Values that can be written to the field `WKUIE`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum WKUIEW {
#[doc = "No interrupt when WKUI is set"]
DISABLED,
#[doc = "Interrupt generated when WKUI bit is set"]
ENABLED,
}
impl WKUIEW {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _bits(&self) -> bool {
match *self {
WKUIEW::DISABLED => false,
WKUIEW::ENABLED => true,
}
}
}
#[doc = r"Proxy"]
pub struct _WKUIEW<'a> {
w: &'a mut W,
}
impl<'a> _WKUIEW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: WKUIEW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "No interrupt when WKUI is set"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(WKUIEW::DISABLED)
}
#[doc = "Interrupt generated when WKUI bit is set"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(WKUIEW::ENABLED)
}
#[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 &= !(0x01 << 16);
self.w.bits |= ((value as u32) & 0x01) << 16;
self.w
}
}
#[doc = "Possible values of the field `ERRIE`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ERRIER {
#[doc = "No interrupt will be generated when an error condition is pending in the CAN_ESR"]
DISABLED,
#[doc = "An interrupt will be generation when an error condition is pending in the CAN_ESR"]
ENABLED,
}
impl ERRIER {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
ERRIER::DISABLED => false,
ERRIER::ENABLED => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> ERRIER {
match value {
false => ERRIER::DISABLED,
true => ERRIER::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == ERRIER::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == ERRIER::ENABLED
}
}
#[doc = "Values that can be written to the field `ERRIE`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ERRIEW {
#[doc = "No interrupt will be generated when an error condition is pending in the CAN_ESR"]
DISABLED,
#[doc = "An interrupt will be generation when an error condition is pending in the CAN_ESR"]
ENABLED,
}
impl ERRIEW {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _bits(&self) -> bool {
match *self {
ERRIEW::DISABLED => false,
ERRIEW::ENABLED => true,
}
}
}
#[doc = r"Proxy"]
pub struct _ERRIEW<'a> {
w: &'a mut W,
}
impl<'a> _ERRIEW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: ERRIEW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "No interrupt will be generated when an error condition is pending in the CAN_ESR"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(ERRIEW::DISABLED)
}
#[doc = "An interrupt will be generation when an error condition is pending in the CAN_ESR"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(ERRIEW::ENABLED)
}
#[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 &= !(0x01 << 15);
self.w.bits |= ((value as u32) & 0x01) << 15;
self.w
}
}
#[doc = "Possible values of the field `LECIE`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum LECIER {
#[doc = "ERRI bit will not be set when the error code in LEC\\[2:0\\] is set by hardware on error detection"]
DISABLED,
#[doc = "ERRI bit will be set when the error code in LEC\\[2:0\\] is set by hardware on error detection"]
ENABLED,
}
impl LECIER {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
LECIER::DISABLED => false,
LECIER::ENABLED => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> LECIER {
match value {
false => LECIER::DISABLED,
true => LECIER::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == LECIER::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == LECIER::ENABLED
}
}
#[doc = "Values that can be written to the field `LECIE`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum LECIEW {
#[doc = "ERRI bit will not be set when the error code in LEC\\[2:0\\] is set by hardware on error detection"]
DISABLED,
#[doc = "ERRI bit will be set when the error code in LEC\\[2:0\\] is set by hardware on error detection"]
ENABLED,
}
impl LECIEW {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _bits(&self) -> bool {
match *self {
LECIEW::DISABLED => false,
LECIEW::ENABLED => true,
}
}
}
#[doc = r"Proxy"]
pub struct _LECIEW<'a> {
w: &'a mut W,
}
impl<'a> _LECIEW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: LECIEW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "ERRI bit will not be set when the error code in LEC\\[2:0\\] is set by hardware on error detection"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(LECIEW::DISABLED)
}
#[doc = "ERRI bit will be set when the error code in LEC\\[2:0\\] is set by hardware on error detection"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(LECIEW::ENABLED)
}
#[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 &= !(0x01 << 11);
self.w.bits |= ((value as u32) & 0x01) << 11;
self.w
}
}
#[doc = "Possible values of the field `BOFIE`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum BOFIER {
#[doc = "ERRI bit will not be set when BOFF is set"]
DISABLED,
#[doc = "ERRI bit will be set when BOFF is set"]
ENABLED,
}
impl BOFIER {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
BOFIER::DISABLED => false,
BOFIER::ENABLED => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> BOFIER {
match value {
false => BOFIER::DISABLED,
true => BOFIER::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == BOFIER::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == BOFIER::ENABLED
}
}
#[doc = "Values that can be written to the field `BOFIE`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum BOFIEW {
#[doc = "ERRI bit will not be set when BOFF is set"]
DISABLED,
#[doc = "ERRI bit will be set when BOFF is set"]
ENABLED,
}
impl BOFIEW {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _bits(&self) -> bool {
match *self {
BOFIEW::DISABLED => false,
BOFIEW::ENABLED => true,
}
}
}
#[doc = r"Proxy"]
pub struct _BOFIEW<'a> {
w: &'a mut W,
}
impl<'a> _BOFIEW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: BOFIEW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "ERRI bit will not be set when BOFF is set"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(BOFIEW::DISABLED)
}
#[doc = "ERRI bit will be set when BOFF is set"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(BOFIEW::ENABLED)
}
#[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 &= !(0x01 << 10);
self.w.bits |= ((value as u32) & 0x01) << 10;
self.w
}
}
#[doc = "Possible values of the field `EPVIE`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum EPVIER {
#[doc = "ERRI bit will not be set when EPVF is set"]
DISABLED,
#[doc = "ERRI bit will be set when EPVF is set"]
ENABLED,
}
impl EPVIER {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
EPVIER::DISABLED => false,
EPVIER::ENABLED => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> EPVIER {
match value {
false => EPVIER::DISABLED,
true => EPVIER::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == EPVIER::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == EPVIER::ENABLED
}
}
#[doc = "Values that can be written to the field `EPVIE`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum EPVIEW {
#[doc = "ERRI bit will not be set when EPVF is set"]
DISABLED,
#[doc = "ERRI bit will be set when EPVF is set"]
ENABLED,
}
impl EPVIEW {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _bits(&self) -> bool {
match *self {
EPVIEW::DISABLED => false,
EPVIEW::ENABLED => true,
}
}
}
#[doc = r"Proxy"]
pub struct _EPVIEW<'a> {
w: &'a mut W,
}
impl<'a> _EPVIEW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: EPVIEW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "ERRI bit will not be set when EPVF is set"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(EPVIEW::DISABLED)
}
#[doc = "ERRI bit will be set when EPVF is set"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(EPVIEW::ENABLED)
}
#[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 &= !(0x01 << 9);
self.w.bits |= ((value as u32) & 0x01) << 9;
self.w
}
}
#[doc = "Possible values of the field `EWGIE`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum EWGIER {
#[doc = "ERRI bit will not be set when EWGF is set"]
DISABLED,
#[doc = "ERRI bit will be set when EWGF is set"]
ENABLED,
}
impl EWGIER {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
EWGIER::DISABLED => false,
EWGIER::ENABLED => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> EWGIER {
match value {
false => EWGIER::DISABLED,
true => EWGIER::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == EWGIER::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == EWGIER::ENABLED
}
}
#[doc = "Values that can be written to the field `EWGIE`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum EWGIEW {
#[doc = "ERRI bit will not be set when EWGF is set"]
DISABLED,
#[doc = "ERRI bit will be set when EWGF is set"]
ENABLED,
}
impl EWGIEW {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _bits(&self) -> bool {
match *self {
EWGIEW::DISABLED => false,
EWGIEW::ENABLED => true,
}
}
}
#[doc = r"Proxy"]
pub struct _EWGIEW<'a> {
w: &'a mut W,
}
impl<'a> _EWGIEW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: EWGIEW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "ERRI bit will not be set when EWGF is set"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(EWGIEW::DISABLED)
}
#[doc = "ERRI bit will be set when EWGF is set"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(EWGIEW::ENABLED)
}
#[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 &= !(0x01 << 8);
self.w.bits |= ((value as u32) & 0x01) << 8;
self.w
}
}
#[doc = "Possible values of the field `FOVIE1`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum FOVIE1R {
#[doc = "No interrupt when FOVR is set"]
DISABLED,
#[doc = "Interrupt generation when FOVR is set"]
ENABLED,
}
impl FOVIE1R {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
FOVIE1R::DISABLED => false,
FOVIE1R::ENABLED => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> FOVIE1R {
match value {
false => FOVIE1R::DISABLED,
true => FOVIE1R::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == FOVIE1R::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == FOVIE1R::ENABLED
}
}
#[doc = "Values that can be written to the field `FOVIE1`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum FOVIE1W {
#[doc = "No interrupt when FOVR is set"]
DISABLED,
#[doc = "Interrupt generation when FOVR is set"]
ENABLED,
}
impl FOVIE1W {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _bits(&self) -> bool {
match *self {
FOVIE1W::DISABLED => false,
FOVIE1W::ENABLED => true,
}
}
}
#[doc = r"Proxy"]
pub struct _FOVIE1W<'a> {
w: &'a mut W,
}
impl<'a> _FOVIE1W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: FOVIE1W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "No interrupt when FOVR is set"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(FOVIE1W::DISABLED)
}
#[doc = "Interrupt generation when FOVR is set"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(FOVIE1W::ENABLED)
}
#[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 &= !(0x01 << 6);
self.w.bits |= ((value as u32) & 0x01) << 6;
self.w
}
}
#[doc = "Possible values of the field `FFIE1`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum FFIE1R {
#[doc = "No interrupt when FULL bit is set"]
DISABLED,
#[doc = "Interrupt generated when FULL bit is set"]
ENABLED,
}
impl FFIE1R {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
FFIE1R::DISABLED => false,
FFIE1R::ENABLED => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> FFIE1R {
match value {
false => FFIE1R::DISABLED,
true => FFIE1R::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == FFIE1R::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == FFIE1R::ENABLED
}
}
#[doc = "Values that can be written to the field `FFIE1`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum FFIE1W {
#[doc = "No interrupt when FULL bit is set"]
DISABLED,
#[doc = "Interrupt generated when FULL bit is set"]
ENABLED,
}
impl FFIE1W {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _bits(&self) -> bool {
match *self {
FFIE1W::DISABLED => false,
FFIE1W::ENABLED => true,
}
}
}
#[doc = r"Proxy"]
pub struct _FFIE1W<'a> {
w: &'a mut W,
}
impl<'a> _FFIE1W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: FFIE1W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "No interrupt when FULL bit is set"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(FFIE1W::DISABLED)
}
#[doc = "Interrupt generated when FULL bit is set"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(FFIE1W::ENABLED)
}
#[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 &= !(0x01 << 5);
self.w.bits |= ((value as u32) & 0x01) << 5;
self.w
}
}
#[doc = "Possible values of the field `FMPIE1`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum FMPIE1R {
#[doc = "No interrupt generated when state of FMP\\[1:0\\] bits are not 00b"]
DISABLED,
#[doc = "Interrupt generated when state of FMP\\[1:0\\] bits are not 00b"]
ENABLED,
}
impl FMPIE1R {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
FMPIE1R::DISABLED => false,
FMPIE1R::ENABLED => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> FMPIE1R {
match value {
false => FMPIE1R::DISABLED,
true => FMPIE1R::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == FMPIE1R::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == FMPIE1R::ENABLED
}
}
#[doc = "Values that can be written to the field `FMPIE1`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum FMPIE1W {
#[doc = "No interrupt generated when state of FMP\\[1:0\\] bits are not 00b"]
DISABLED,
#[doc = "Interrupt generated when state of FMP\\[1:0\\] bits are not 00b"]
ENABLED,
}
impl FMPIE1W {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _bits(&self) -> bool {
match *self {
FMPIE1W::DISABLED => false,
FMPIE1W::ENABLED => true,
}
}
}
#[doc = r"Proxy"]
pub struct _FMPIE1W<'a> {
w: &'a mut W,
}
impl<'a> _FMPIE1W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: FMPIE1W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "No interrupt generated when state of FMP\\[1:0\\] bits are not 00b"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(FMPIE1W::DISABLED)
}
#[doc = "Interrupt generated when state of FMP\\[1:0\\] bits are not 00b"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(FMPIE1W::ENABLED)
}
#[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 &= !(0x01 << 4);
self.w.bits |= ((value as u32) & 0x01) << 4;
self.w
}
}
#[doc = "Possible values of the field `FOVIE0`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum FOVIE0R {
#[doc = "No interrupt when FOVR bit is set"]
DISABLED,
#[doc = "Interrupt generated when FOVR bit is set"]
ENABLED,
}
impl FOVIE0R {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
FOVIE0R::DISABLED => false,
FOVIE0R::ENABLED => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> FOVIE0R {
match value {
false => FOVIE0R::DISABLED,
true => FOVIE0R::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == FOVIE0R::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == FOVIE0R::ENABLED
}
}
#[doc = "Values that can be written to the field `FOVIE0`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum FOVIE0W {
#[doc = "No interrupt when FOVR bit is set"]
DISABLED,
#[doc = "Interrupt generated when FOVR bit is set"]
ENABLED,
}
impl FOVIE0W {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _bits(&self) -> bool {
match *self {
FOVIE0W::DISABLED => false,
FOVIE0W::ENABLED => true,
}
}
}
#[doc = r"Proxy"]
pub struct _FOVIE0W<'a> {
w: &'a mut W,
}
impl<'a> _FOVIE0W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: FOVIE0W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "No interrupt when FOVR bit is set"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(FOVIE0W::DISABLED)
}
#[doc = "Interrupt generated when FOVR bit is set"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(FOVIE0W::ENABLED)
}
#[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 &= !(0x01 << 3);
self.w.bits |= ((value as u32) & 0x01) << 3;
self.w
}
}
#[doc = "Possible values of the field `FFIE0`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum FFIE0R {
#[doc = "No interrupt when FULL bit is set"]
DISABLED,
#[doc = "Interrupt generated when FULL bit is set"]
ENABLED,
}
impl FFIE0R {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
FFIE0R::DISABLED => false,
FFIE0R::ENABLED => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> FFIE0R {
match value {
false => FFIE0R::DISABLED,
true => FFIE0R::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == FFIE0R::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == FFIE0R::ENABLED
}
}
#[doc = "Values that can be written to the field `FFIE0`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum FFIE0W {
#[doc = "No interrupt when FULL bit is set"]
DISABLED,
#[doc = "Interrupt generated when FULL bit is set"]
ENABLED,
}
impl FFIE0W {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _bits(&self) -> bool {
match *self {
FFIE0W::DISABLED => false,
FFIE0W::ENABLED => true,
}
}
}
#[doc = r"Proxy"]
pub struct _FFIE0W<'a> {
w: &'a mut W,
}
impl<'a> _FFIE0W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: FFIE0W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "No interrupt when FULL bit is set"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(FFIE0W::DISABLED)
}
#[doc = "Interrupt generated when FULL bit is set"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(FFIE0W::ENABLED)
}
#[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 &= !(0x01 << 2);
self.w.bits |= ((value as u32) & 0x01) << 2;
self.w
}
}
#[doc = "Possible values of the field `FMPIE0`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum FMPIE0R {
#[doc = "No interrupt generated when state of FMP\\[1:0\\] bits are not 00"]
DISABLED,
#[doc = "Interrupt generated when state of FMP\\[1:0\\] bits are not 00b"]
ENABLED,
}
impl FMPIE0R {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
FMPIE0R::DISABLED => false,
FMPIE0R::ENABLED => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> FMPIE0R {
match value {
false => FMPIE0R::DISABLED,
true => FMPIE0R::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == FMPIE0R::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == FMPIE0R::ENABLED
}
}
#[doc = "Values that can be written to the field `FMPIE0`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum FMPIE0W {
#[doc = "No interrupt generated when state of FMP\\[1:0\\] bits are not 00"]
DISABLED,
#[doc = "Interrupt generated when state of FMP\\[1:0\\] bits are not 00b"]
ENABLED,
}
impl FMPIE0W {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _bits(&self) -> bool {
match *self {
FMPIE0W::DISABLED => false,
FMPIE0W::ENABLED => true,
}
}
}
#[doc = r"Proxy"]
pub struct _FMPIE0W<'a> {
w: &'a mut W,
}
impl<'a> _FMPIE0W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: FMPIE0W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "No interrupt generated when state of FMP\\[1:0\\] bits are not 00"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(FMPIE0W::DISABLED)
}
#[doc = "Interrupt generated when state of FMP\\[1:0\\] bits are not 00b"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(FMPIE0W::ENABLED)
}
#[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 &= !(0x01 << 1);
self.w.bits |= ((value as u32) & 0x01) << 1;
self.w
}
}
#[doc = "Possible values of the field `TMEIE`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TMEIER {
#[doc = "No interrupt when RQCPx bit is set"]
DISABLED,
#[doc = "Interrupt generated when RQCPx bit is set"]
ENABLED,
}
impl TMEIER {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
TMEIER::DISABLED => false,
TMEIER::ENABLED => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> TMEIER {
match value {
false => TMEIER::DISABLED,
true => TMEIER::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == TMEIER::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == TMEIER::ENABLED
}
}
#[doc = "Values that can be written to the field `TMEIE`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TMEIEW {
#[doc = "No interrupt when RQCPx bit is set"]
DISABLED,
#[doc = "Interrupt generated when RQCPx bit is set"]
ENABLED,
}
impl TMEIEW {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _bits(&self) -> bool {
match *self {
TMEIEW::DISABLED => false,
TMEIEW::ENABLED => true,
}
}
}
#[doc = r"Proxy"]
pub struct _TMEIEW<'a> {
w: &'a mut W,
}
impl<'a> _TMEIEW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: TMEIEW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "No interrupt when RQCPx bit is set"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(TMEIEW::DISABLED)
}
#[doc = "Interrupt generated when RQCPx bit is set"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(TMEIEW::ENABLED)
}
#[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 &= !(0x01 << 0);
self.w.bits |= ((value as u32) & 0x01) << 0;
self.w
}
}
impl R {
#[doc = r"Value of the register as raw bits"]
#[inline(always)]
pub fn bits(&self) -> u32 {
self.bits
}
#[doc = "Bit 17 - SLKIE"]
#[inline(always)]
pub fn slkie(&self) -> SLKIER {
SLKIER::_from(((self.bits >> 17) & 0x01) != 0)
}
#[doc = "Bit 16 - WKUIE"]
#[inline(always)]
pub fn wkuie(&self) -> WKUIER {
WKUIER::_from(((self.bits >> 16) & 0x01) != 0)
}
#[doc = "Bit 15 - ERRIE"]
#[inline(always)]
pub fn errie(&self) -> ERRIER {
ERRIER::_from(((self.bits >> 15) & 0x01) != 0)
}
#[doc = "Bit 11 - LECIE"]
#[inline(always)]
pub fn lecie(&self) -> LECIER {
LECIER::_from(((self.bits >> 11) & 0x01) != 0)
}
#[doc = "Bit 10 - BOFIE"]
#[inline(always)]
pub fn bofie(&self) -> BOFIER {
BOFIER::_from(((self.bits >> 10) & 0x01) != 0)
}
#[doc = "Bit 9 - EPVIE"]
#[inline(always)]
pub fn epvie(&self) -> EPVIER {
EPVIER::_from(((self.bits >> 9) & 0x01) != 0)
}
#[doc = "Bit 8 - EWGIE"]
#[inline(always)]
pub fn ewgie(&self) -> EWGIER {
EWGIER::_from(((self.bits >> 8) & 0x01) != 0)
}
#[doc = "Bit 6 - FOVIE1"]
#[inline(always)]
pub fn fovie1(&self) -> FOVIE1R {
FOVIE1R::_from(((self.bits >> 6) & 0x01) != 0)
}
#[doc = "Bit 5 - FFIE1"]
#[inline(always)]
pub fn ffie1(&self) -> FFIE1R {
FFIE1R::_from(((self.bits >> 5) & 0x01) != 0)
}
#[doc = "Bit 4 - FMPIE1"]
#[inline(always)]
pub fn fmpie1(&self) -> FMPIE1R {
FMPIE1R::_from(((self.bits >> 4) & 0x01) != 0)
}
#[doc = "Bit 3 - FOVIE0"]
#[inline(always)]
pub fn fovie0(&self) -> FOVIE0R {
FOVIE0R::_from(((self.bits >> 3) & 0x01) != 0)
}
#[doc = "Bit 2 - FFIE0"]
#[inline(always)]
pub fn ffie0(&self) -> FFIE0R {
FFIE0R::_from(((self.bits >> 2) & 0x01) != 0)
}
#[doc = "Bit 1 - FMPIE0"]
#[inline(always)]
pub fn fmpie0(&self) -> FMPIE0R {
FMPIE0R::_from(((self.bits >> 1) & 0x01) != 0)
}
#[doc = "Bit 0 - TMEIE"]
#[inline(always)]
pub fn tmeie(&self) -> TMEIER {
TMEIER::_from(((self.bits >> 0) & 0x01) != 0)
}
}
impl W {
#[doc = r"Writes raw bits to the register"]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.bits = bits;
self
}
#[doc = "Bit 17 - SLKIE"]
#[inline(always)]
pub fn slkie(&mut self) -> _SLKIEW {
_SLKIEW { w: self }
}
#[doc = "Bit 16 - WKUIE"]
#[inline(always)]
pub fn wkuie(&mut self) -> _WKUIEW {
_WKUIEW { w: self }
}
#[doc = "Bit 15 - ERRIE"]
#[inline(always)]
pub fn errie(&mut self) -> _ERRIEW {
_ERRIEW { w: self }
}
#[doc = "Bit 11 - LECIE"]
#[inline(always)]
pub fn lecie(&mut self) -> _LECIEW {
_LECIEW { w: self }
}
#[doc = "Bit 10 - BOFIE"]
#[inline(always)]
pub fn bofie(&mut self) -> _BOFIEW {
_BOFIEW { w: self }
}
#[doc = "Bit 9 - EPVIE"]
#[inline(always)]
pub fn epvie(&mut self) -> _EPVIEW {
_EPVIEW { w: self }
}
#[doc = "Bit 8 - EWGIE"]
#[inline(always)]
pub fn ewgie(&mut self) -> _EWGIEW {
_EWGIEW { w: self }
}
#[doc = "Bit 6 - FOVIE1"]
#[inline(always)]
pub fn fovie1(&mut self) -> _FOVIE1W {
_FOVIE1W { w: self }
}
#[doc = "Bit 5 - FFIE1"]
#[inline(always)]
pub fn ffie1(&mut self) -> _FFIE1W {
_FFIE1W { w: self }
}
#[doc = "Bit 4 - FMPIE1"]
#[inline(always)]
pub fn fmpie1(&mut self) -> _FMPIE1W {
_FMPIE1W { w: self }
}
#[doc = "Bit 3 - FOVIE0"]
#[inline(always)]
pub fn fovie0(&mut self) -> _FOVIE0W {
_FOVIE0W { w: self }
}
#[doc = "Bit 2 - FFIE0"]
#[inline(always)]
pub fn ffie0(&mut self) -> _FFIE0W {
_FFIE0W { w: self }
}
#[doc = "Bit 1 - FMPIE0"]
#[inline(always)]
pub fn fmpie0(&mut self) -> _FMPIE0W {
_FMPIE0W { w: self }
}
#[doc = "Bit 0 - TMEIE"]
#[inline(always)]
pub fn tmeie(&mut self) -> _TMEIEW {
_TMEIEW { w: self }
}
}