#[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::CPT1CCR {
#[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 = r"Value of the field"]
pub struct TECMP2R {
bits: bool,
}
impl TECMP2R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[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"Proxy"]
pub struct _TECMP2W<'a> {
w: &'a mut W,
}
impl<'a> _TECMP2W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 31);
self.w.bits |= ((value as u32) & 0x01) << 31;
self.w
}
}
#[doc = r"Value of the field"]
pub struct TECMP1R {
bits: bool,
}
impl TECMP1R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[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"Proxy"]
pub struct _TECMP1W<'a> {
w: &'a mut W,
}
impl<'a> _TECMP1W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 30);
self.w.bits |= ((value as u32) & 0x01) << 30;
self.w
}
}
#[doc = r"Value of the field"]
pub struct TE1RSTR {
bits: bool,
}
impl TE1RSTR {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[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"Proxy"]
pub struct _TE1RSTW<'a> {
w: &'a mut W,
}
impl<'a> _TE1RSTW<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 29);
self.w.bits |= ((value as u32) & 0x01) << 29;
self.w
}
}
#[doc = r"Value of the field"]
pub struct TE1SETR {
bits: bool,
}
impl TE1SETR {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[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"Proxy"]
pub struct _TE1SETW<'a> {
w: &'a mut W,
}
impl<'a> _TE1SETW<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 28);
self.w.bits |= ((value as u32) & 0x01) << 28;
self.w
}
}
#[doc = r"Value of the field"]
pub struct TDCMP2R {
bits: bool,
}
impl TDCMP2R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[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"Proxy"]
pub struct _TDCMP2W<'a> {
w: &'a mut W,
}
impl<'a> _TDCMP2W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 27);
self.w.bits |= ((value as u32) & 0x01) << 27;
self.w
}
}
#[doc = r"Value of the field"]
pub struct TDCMP1R {
bits: bool,
}
impl TDCMP1R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[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"Proxy"]
pub struct _TDCMP1W<'a> {
w: &'a mut W,
}
impl<'a> _TDCMP1W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 26);
self.w.bits |= ((value as u32) & 0x01) << 26;
self.w
}
}
#[doc = r"Value of the field"]
pub struct TD1RSTR {
bits: bool,
}
impl TD1RSTR {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[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"Proxy"]
pub struct _TD1RSTW<'a> {
w: &'a mut W,
}
impl<'a> _TD1RSTW<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 25);
self.w.bits |= ((value as u32) & 0x01) << 25;
self.w
}
}
#[doc = r"Value of the field"]
pub struct TD1SETR {
bits: bool,
}
impl TD1SETR {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[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"Proxy"]
pub struct _TD1SETW<'a> {
w: &'a mut W,
}
impl<'a> _TD1SETW<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 24);
self.w.bits |= ((value as u32) & 0x01) << 24;
self.w
}
}
#[doc = r"Value of the field"]
pub struct TBCMP2R {
bits: bool,
}
impl TBCMP2R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[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"Proxy"]
pub struct _TBCMP2W<'a> {
w: &'a mut W,
}
impl<'a> _TBCMP2W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 19);
self.w.bits |= ((value as u32) & 0x01) << 19;
self.w
}
}
#[doc = r"Value of the field"]
pub struct TBCMP1R {
bits: bool,
}
impl TBCMP1R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[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"Proxy"]
pub struct _TBCMP1W<'a> {
w: &'a mut W,
}
impl<'a> _TBCMP1W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 18);
self.w.bits |= ((value as u32) & 0x01) << 18;
self.w
}
}
#[doc = r"Value of the field"]
pub struct TB1RSTR {
bits: bool,
}
impl TB1RSTR {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[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"Proxy"]
pub struct _TB1RSTW<'a> {
w: &'a mut W,
}
impl<'a> _TB1RSTW<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 17);
self.w.bits |= ((value as u32) & 0x01) << 17;
self.w
}
}
#[doc = r"Value of the field"]
pub struct TB1SETR {
bits: bool,
}
impl TB1SETR {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[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"Proxy"]
pub struct _TB1SETW<'a> {
w: &'a mut W,
}
impl<'a> _TB1SETW<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 16);
self.w.bits |= ((value as u32) & 0x01) << 16;
self.w
}
}
#[doc = r"Value of the field"]
pub struct TACMP2R {
bits: bool,
}
impl TACMP2R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[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"Proxy"]
pub struct _TACMP2W<'a> {
w: &'a mut W,
}
impl<'a> _TACMP2W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 15);
self.w.bits |= ((value as u32) & 0x01) << 15;
self.w
}
}
#[doc = r"Value of the field"]
pub struct TACMP1R {
bits: bool,
}
impl TACMP1R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[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"Proxy"]
pub struct _TACMP1W<'a> {
w: &'a mut W,
}
impl<'a> _TACMP1W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 14);
self.w.bits |= ((value as u32) & 0x01) << 14;
self.w
}
}
#[doc = r"Value of the field"]
pub struct TA1RSTR {
bits: bool,
}
impl TA1RSTR {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[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"Proxy"]
pub struct _TA1RSTW<'a> {
w: &'a mut W,
}
impl<'a> _TA1RSTW<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 13);
self.w.bits |= ((value as u32) & 0x01) << 13;
self.w
}
}
#[doc = r"Value of the field"]
pub struct TA1SETR {
bits: bool,
}
impl TA1SETR {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[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"Proxy"]
pub struct _TA1SETW<'a> {
w: &'a mut W,
}
impl<'a> _TA1SETW<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 12);
self.w.bits |= ((value as u32) & 0x01) << 12;
self.w
}
}
#[doc = r"Value of the field"]
pub struct EXEV10CPTR {
bits: bool,
}
impl EXEV10CPTR {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[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"Proxy"]
pub struct _EXEV10CPTW<'a> {
w: &'a mut W,
}
impl<'a> _EXEV10CPTW<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 11);
self.w.bits |= ((value as u32) & 0x01) << 11;
self.w
}
}
#[doc = r"Value of the field"]
pub struct EXEV9CPTR {
bits: bool,
}
impl EXEV9CPTR {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[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"Proxy"]
pub struct _EXEV9CPTW<'a> {
w: &'a mut W,
}
impl<'a> _EXEV9CPTW<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 10);
self.w.bits |= ((value as u32) & 0x01) << 10;
self.w
}
}
#[doc = r"Value of the field"]
pub struct EXEV8CPTR {
bits: bool,
}
impl EXEV8CPTR {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[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"Proxy"]
pub struct _EXEV8CPTW<'a> {
w: &'a mut W,
}
impl<'a> _EXEV8CPTW<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 9);
self.w.bits |= ((value as u32) & 0x01) << 9;
self.w
}
}
#[doc = r"Value of the field"]
pub struct EXEV7CPTR {
bits: bool,
}
impl EXEV7CPTR {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[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"Proxy"]
pub struct _EXEV7CPTW<'a> {
w: &'a mut W,
}
impl<'a> _EXEV7CPTW<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 8);
self.w.bits |= ((value as u32) & 0x01) << 8;
self.w
}
}
#[doc = r"Value of the field"]
pub struct EXEV6CPTR {
bits: bool,
}
impl EXEV6CPTR {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[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"Proxy"]
pub struct _EXEV6CPTW<'a> {
w: &'a mut W,
}
impl<'a> _EXEV6CPTW<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 7);
self.w.bits |= ((value as u32) & 0x01) << 7;
self.w
}
}
#[doc = r"Value of the field"]
pub struct EXEV5CPTR {
bits: bool,
}
impl EXEV5CPTR {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[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"Proxy"]
pub struct _EXEV5CPTW<'a> {
w: &'a mut W,
}
impl<'a> _EXEV5CPTW<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 6);
self.w.bits |= ((value as u32) & 0x01) << 6;
self.w
}
}
#[doc = r"Value of the field"]
pub struct EXEV4CPTR {
bits: bool,
}
impl EXEV4CPTR {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[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"Proxy"]
pub struct _EXEV4CPTW<'a> {
w: &'a mut W,
}
impl<'a> _EXEV4CPTW<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 5);
self.w.bits |= ((value as u32) & 0x01) << 5;
self.w
}
}
#[doc = r"Value of the field"]
pub struct EXEV3CPTR {
bits: bool,
}
impl EXEV3CPTR {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[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"Proxy"]
pub struct _EXEV3CPTW<'a> {
w: &'a mut W,
}
impl<'a> _EXEV3CPTW<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 4);
self.w.bits |= ((value as u32) & 0x01) << 4;
self.w
}
}
#[doc = r"Value of the field"]
pub struct EXEV2CPTR {
bits: bool,
}
impl EXEV2CPTR {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[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"Proxy"]
pub struct _EXEV2CPTW<'a> {
w: &'a mut W,
}
impl<'a> _EXEV2CPTW<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 3);
self.w.bits |= ((value as u32) & 0x01) << 3;
self.w
}
}
#[doc = r"Value of the field"]
pub struct EXEV1CPTR {
bits: bool,
}
impl EXEV1CPTR {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[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"Proxy"]
pub struct _EXEV1CPTW<'a> {
w: &'a mut W,
}
impl<'a> _EXEV1CPTW<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 2);
self.w.bits |= ((value as u32) & 0x01) << 2;
self.w
}
}
#[doc = r"Value of the field"]
pub struct UDPCPTR {
bits: bool,
}
impl UDPCPTR {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[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"Proxy"]
pub struct _UDPCPTW<'a> {
w: &'a mut W,
}
impl<'a> _UDPCPTW<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 1);
self.w.bits |= ((value as u32) & 0x01) << 1;
self.w
}
}
#[doc = r"Value of the field"]
pub struct SWCPTR {
bits: bool,
}
impl SWCPTR {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[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"Proxy"]
pub struct _SWCPTW<'a> {
w: &'a mut W,
}
impl<'a> _SWCPTW<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(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 31 - Timer E Compare 2"]
#[inline(always)]
pub fn tecmp2(&self) -> TECMP2R {
let bits = ((self.bits >> 31) & 0x01) != 0;
TECMP2R { bits }
}
#[doc = "Bit 30 - Timer E Compare 1"]
#[inline(always)]
pub fn tecmp1(&self) -> TECMP1R {
let bits = ((self.bits >> 30) & 0x01) != 0;
TECMP1R { bits }
}
#[doc = "Bit 29 - Timer E output 1 Reset"]
#[inline(always)]
pub fn te1rst(&self) -> TE1RSTR {
let bits = ((self.bits >> 29) & 0x01) != 0;
TE1RSTR { bits }
}
#[doc = "Bit 28 - Timer E output 1 Set"]
#[inline(always)]
pub fn te1set(&self) -> TE1SETR {
let bits = ((self.bits >> 28) & 0x01) != 0;
TE1SETR { bits }
}
#[doc = "Bit 27 - Timer D Compare 2"]
#[inline(always)]
pub fn tdcmp2(&self) -> TDCMP2R {
let bits = ((self.bits >> 27) & 0x01) != 0;
TDCMP2R { bits }
}
#[doc = "Bit 26 - Timer D Compare 1"]
#[inline(always)]
pub fn tdcmp1(&self) -> TDCMP1R {
let bits = ((self.bits >> 26) & 0x01) != 0;
TDCMP1R { bits }
}
#[doc = "Bit 25 - Timer D output 1 Reset"]
#[inline(always)]
pub fn td1rst(&self) -> TD1RSTR {
let bits = ((self.bits >> 25) & 0x01) != 0;
TD1RSTR { bits }
}
#[doc = "Bit 24 - Timer D output 1 Set"]
#[inline(always)]
pub fn td1set(&self) -> TD1SETR {
let bits = ((self.bits >> 24) & 0x01) != 0;
TD1SETR { bits }
}
#[doc = "Bit 19 - Timer B Compare 2"]
#[inline(always)]
pub fn tbcmp2(&self) -> TBCMP2R {
let bits = ((self.bits >> 19) & 0x01) != 0;
TBCMP2R { bits }
}
#[doc = "Bit 18 - Timer B Compare 1"]
#[inline(always)]
pub fn tbcmp1(&self) -> TBCMP1R {
let bits = ((self.bits >> 18) & 0x01) != 0;
TBCMP1R { bits }
}
#[doc = "Bit 17 - Timer B output 1 Reset"]
#[inline(always)]
pub fn tb1rst(&self) -> TB1RSTR {
let bits = ((self.bits >> 17) & 0x01) != 0;
TB1RSTR { bits }
}
#[doc = "Bit 16 - Timer B output 1 Set"]
#[inline(always)]
pub fn tb1set(&self) -> TB1SETR {
let bits = ((self.bits >> 16) & 0x01) != 0;
TB1SETR { bits }
}
#[doc = "Bit 15 - Timer A Compare 2"]
#[inline(always)]
pub fn tacmp2(&self) -> TACMP2R {
let bits = ((self.bits >> 15) & 0x01) != 0;
TACMP2R { bits }
}
#[doc = "Bit 14 - Timer A Compare 1"]
#[inline(always)]
pub fn tacmp1(&self) -> TACMP1R {
let bits = ((self.bits >> 14) & 0x01) != 0;
TACMP1R { bits }
}
#[doc = "Bit 13 - Timer A output 1 Reset"]
#[inline(always)]
pub fn ta1rst(&self) -> TA1RSTR {
let bits = ((self.bits >> 13) & 0x01) != 0;
TA1RSTR { bits }
}
#[doc = "Bit 12 - Timer A output 1 Set"]
#[inline(always)]
pub fn ta1set(&self) -> TA1SETR {
let bits = ((self.bits >> 12) & 0x01) != 0;
TA1SETR { bits }
}
#[doc = "Bit 11 - External Event 10 Capture"]
#[inline(always)]
pub fn exev10cpt(&self) -> EXEV10CPTR {
let bits = ((self.bits >> 11) & 0x01) != 0;
EXEV10CPTR { bits }
}
#[doc = "Bit 10 - External Event 9 Capture"]
#[inline(always)]
pub fn exev9cpt(&self) -> EXEV9CPTR {
let bits = ((self.bits >> 10) & 0x01) != 0;
EXEV9CPTR { bits }
}
#[doc = "Bit 9 - External Event 8 Capture"]
#[inline(always)]
pub fn exev8cpt(&self) -> EXEV8CPTR {
let bits = ((self.bits >> 9) & 0x01) != 0;
EXEV8CPTR { bits }
}
#[doc = "Bit 8 - External Event 7 Capture"]
#[inline(always)]
pub fn exev7cpt(&self) -> EXEV7CPTR {
let bits = ((self.bits >> 8) & 0x01) != 0;
EXEV7CPTR { bits }
}
#[doc = "Bit 7 - External Event 6 Capture"]
#[inline(always)]
pub fn exev6cpt(&self) -> EXEV6CPTR {
let bits = ((self.bits >> 7) & 0x01) != 0;
EXEV6CPTR { bits }
}
#[doc = "Bit 6 - External Event 5 Capture"]
#[inline(always)]
pub fn exev5cpt(&self) -> EXEV5CPTR {
let bits = ((self.bits >> 6) & 0x01) != 0;
EXEV5CPTR { bits }
}
#[doc = "Bit 5 - External Event 4 Capture"]
#[inline(always)]
pub fn exev4cpt(&self) -> EXEV4CPTR {
let bits = ((self.bits >> 5) & 0x01) != 0;
EXEV4CPTR { bits }
}
#[doc = "Bit 4 - External Event 3 Capture"]
#[inline(always)]
pub fn exev3cpt(&self) -> EXEV3CPTR {
let bits = ((self.bits >> 4) & 0x01) != 0;
EXEV3CPTR { bits }
}
#[doc = "Bit 3 - External Event 2 Capture"]
#[inline(always)]
pub fn exev2cpt(&self) -> EXEV2CPTR {
let bits = ((self.bits >> 3) & 0x01) != 0;
EXEV2CPTR { bits }
}
#[doc = "Bit 2 - External Event 1 Capture"]
#[inline(always)]
pub fn exev1cpt(&self) -> EXEV1CPTR {
let bits = ((self.bits >> 2) & 0x01) != 0;
EXEV1CPTR { bits }
}
#[doc = "Bit 1 - Update Capture"]
#[inline(always)]
pub fn udpcpt(&self) -> UDPCPTR {
let bits = ((self.bits >> 1) & 0x01) != 0;
UDPCPTR { bits }
}
#[doc = "Bit 0 - Software Capture"]
#[inline(always)]
pub fn swcpt(&self) -> SWCPTR {
let bits = ((self.bits >> 0) & 0x01) != 0;
SWCPTR { bits }
}
}
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 31 - Timer E Compare 2"]
#[inline(always)]
pub fn tecmp2(&mut self) -> _TECMP2W {
_TECMP2W { w: self }
}
#[doc = "Bit 30 - Timer E Compare 1"]
#[inline(always)]
pub fn tecmp1(&mut self) -> _TECMP1W {
_TECMP1W { w: self }
}
#[doc = "Bit 29 - Timer E output 1 Reset"]
#[inline(always)]
pub fn te1rst(&mut self) -> _TE1RSTW {
_TE1RSTW { w: self }
}
#[doc = "Bit 28 - Timer E output 1 Set"]
#[inline(always)]
pub fn te1set(&mut self) -> _TE1SETW {
_TE1SETW { w: self }
}
#[doc = "Bit 27 - Timer D Compare 2"]
#[inline(always)]
pub fn tdcmp2(&mut self) -> _TDCMP2W {
_TDCMP2W { w: self }
}
#[doc = "Bit 26 - Timer D Compare 1"]
#[inline(always)]
pub fn tdcmp1(&mut self) -> _TDCMP1W {
_TDCMP1W { w: self }
}
#[doc = "Bit 25 - Timer D output 1 Reset"]
#[inline(always)]
pub fn td1rst(&mut self) -> _TD1RSTW {
_TD1RSTW { w: self }
}
#[doc = "Bit 24 - Timer D output 1 Set"]
#[inline(always)]
pub fn td1set(&mut self) -> _TD1SETW {
_TD1SETW { w: self }
}
#[doc = "Bit 19 - Timer B Compare 2"]
#[inline(always)]
pub fn tbcmp2(&mut self) -> _TBCMP2W {
_TBCMP2W { w: self }
}
#[doc = "Bit 18 - Timer B Compare 1"]
#[inline(always)]
pub fn tbcmp1(&mut self) -> _TBCMP1W {
_TBCMP1W { w: self }
}
#[doc = "Bit 17 - Timer B output 1 Reset"]
#[inline(always)]
pub fn tb1rst(&mut self) -> _TB1RSTW {
_TB1RSTW { w: self }
}
#[doc = "Bit 16 - Timer B output 1 Set"]
#[inline(always)]
pub fn tb1set(&mut self) -> _TB1SETW {
_TB1SETW { w: self }
}
#[doc = "Bit 15 - Timer A Compare 2"]
#[inline(always)]
pub fn tacmp2(&mut self) -> _TACMP2W {
_TACMP2W { w: self }
}
#[doc = "Bit 14 - Timer A Compare 1"]
#[inline(always)]
pub fn tacmp1(&mut self) -> _TACMP1W {
_TACMP1W { w: self }
}
#[doc = "Bit 13 - Timer A output 1 Reset"]
#[inline(always)]
pub fn ta1rst(&mut self) -> _TA1RSTW {
_TA1RSTW { w: self }
}
#[doc = "Bit 12 - Timer A output 1 Set"]
#[inline(always)]
pub fn ta1set(&mut self) -> _TA1SETW {
_TA1SETW { w: self }
}
#[doc = "Bit 11 - External Event 10 Capture"]
#[inline(always)]
pub fn exev10cpt(&mut self) -> _EXEV10CPTW {
_EXEV10CPTW { w: self }
}
#[doc = "Bit 10 - External Event 9 Capture"]
#[inline(always)]
pub fn exev9cpt(&mut self) -> _EXEV9CPTW {
_EXEV9CPTW { w: self }
}
#[doc = "Bit 9 - External Event 8 Capture"]
#[inline(always)]
pub fn exev8cpt(&mut self) -> _EXEV8CPTW {
_EXEV8CPTW { w: self }
}
#[doc = "Bit 8 - External Event 7 Capture"]
#[inline(always)]
pub fn exev7cpt(&mut self) -> _EXEV7CPTW {
_EXEV7CPTW { w: self }
}
#[doc = "Bit 7 - External Event 6 Capture"]
#[inline(always)]
pub fn exev6cpt(&mut self) -> _EXEV6CPTW {
_EXEV6CPTW { w: self }
}
#[doc = "Bit 6 - External Event 5 Capture"]
#[inline(always)]
pub fn exev5cpt(&mut self) -> _EXEV5CPTW {
_EXEV5CPTW { w: self }
}
#[doc = "Bit 5 - External Event 4 Capture"]
#[inline(always)]
pub fn exev4cpt(&mut self) -> _EXEV4CPTW {
_EXEV4CPTW { w: self }
}
#[doc = "Bit 4 - External Event 3 Capture"]
#[inline(always)]
pub fn exev3cpt(&mut self) -> _EXEV3CPTW {
_EXEV3CPTW { w: self }
}
#[doc = "Bit 3 - External Event 2 Capture"]
#[inline(always)]
pub fn exev2cpt(&mut self) -> _EXEV2CPTW {
_EXEV2CPTW { w: self }
}
#[doc = "Bit 2 - External Event 1 Capture"]
#[inline(always)]
pub fn exev1cpt(&mut self) -> _EXEV1CPTW {
_EXEV1CPTW { w: self }
}
#[doc = "Bit 1 - Update Capture"]
#[inline(always)]
pub fn udpcpt(&mut self) -> _UDPCPTW {
_UDPCPTW { w: self }
}
#[doc = "Bit 0 - Software Capture"]
#[inline(always)]
pub fn swcpt(&mut self) -> _SWCPTW {
_SWCPTW { w: self }
}
}