#[doc = r" Value to write to the register"]
pub struct W {
bits: u32,
}
impl super::IFCR {
#[doc = r" Writes to the register"]
#[inline]
pub fn write<F>(&self, f: F)
where
F: FnOnce(&mut W) -> &mut W,
{
let mut w = W::reset_value();
f(&mut w);
self.register.set(w.bits);
}
}
#[doc = "Values that can be written to the field `CGIF1`"]
pub enum CGIF1W {
#[doc = "Clears the GIF, TEIF, HTIF, TCIF flags in the ISR register"]
CLEAR,
}
impl CGIF1W {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline]
pub fn _bits(&self) -> bool {
match *self {
CGIF1W::CLEAR => true,
}
}
}
#[doc = r" Proxy"]
pub struct _CGIF1W<'a> {
w: &'a mut W,
}
impl<'a> _CGIF1W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: CGIF1W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clears the GIF, TEIF, HTIF, TCIF flags in the ISR register"]
#[inline]
pub fn clear(self) -> &'a mut W {
self.variant(CGIF1W::CLEAR)
}
#[doc = r" Sets the field bit"]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r" Clears the field bit"]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r" Writes raw bits to the field"]
#[inline]
pub fn bit(self, value: bool) -> &'a mut W {
const MASK: bool = true;
const OFFSET: u8 = 0;
self.w.bits &= !((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `CTCIF1`"]
pub enum CTCIF1W {
#[doc = "Clears the TCIF flag in the ISR register"]
CLEAR,
}
impl CTCIF1W {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline]
pub fn _bits(&self) -> bool {
match *self {
CTCIF1W::CLEAR => true,
}
}
}
#[doc = r" Proxy"]
pub struct _CTCIF1W<'a> {
w: &'a mut W,
}
impl<'a> _CTCIF1W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: CTCIF1W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clears the TCIF flag in the ISR register"]
#[inline]
pub fn clear(self) -> &'a mut W {
self.variant(CTCIF1W::CLEAR)
}
#[doc = r" Sets the field bit"]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r" Clears the field bit"]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r" Writes raw bits to the field"]
#[inline]
pub fn bit(self, value: bool) -> &'a mut W {
const MASK: bool = true;
const OFFSET: u8 = 1;
self.w.bits &= !((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `CHTIF1`"]
pub enum CHTIF1W {
#[doc = "Clears the HTIF flag in the ISR register"]
CLEAR,
}
impl CHTIF1W {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline]
pub fn _bits(&self) -> bool {
match *self {
CHTIF1W::CLEAR => true,
}
}
}
#[doc = r" Proxy"]
pub struct _CHTIF1W<'a> {
w: &'a mut W,
}
impl<'a> _CHTIF1W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: CHTIF1W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clears the HTIF flag in the ISR register"]
#[inline]
pub fn clear(self) -> &'a mut W {
self.variant(CHTIF1W::CLEAR)
}
#[doc = r" Sets the field bit"]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r" Clears the field bit"]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r" Writes raw bits to the field"]
#[inline]
pub fn bit(self, value: bool) -> &'a mut W {
const MASK: bool = true;
const OFFSET: u8 = 2;
self.w.bits &= !((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `CTEIF1`"]
pub enum CTEIF1W {
#[doc = "Clears the TEIF flag in the ISR register"]
CLEAR,
}
impl CTEIF1W {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline]
pub fn _bits(&self) -> bool {
match *self {
CTEIF1W::CLEAR => true,
}
}
}
#[doc = r" Proxy"]
pub struct _CTEIF1W<'a> {
w: &'a mut W,
}
impl<'a> _CTEIF1W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: CTEIF1W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clears the TEIF flag in the ISR register"]
#[inline]
pub fn clear(self) -> &'a mut W {
self.variant(CTEIF1W::CLEAR)
}
#[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 u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `CGIF2`"]
pub type CGIF2W = CGIF1W;
#[doc = r" Proxy"]
pub struct _CGIF2W<'a> {
w: &'a mut W,
}
impl<'a> _CGIF2W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: CGIF2W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clears the GIF, TEIF, HTIF, TCIF flags in the ISR register"]
#[inline]
pub fn clear(self) -> &'a mut W {
self.variant(CGIF1W::CLEAR)
}
#[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 u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `CTCIF2`"]
pub type CTCIF2W = CTCIF1W;
#[doc = r" Proxy"]
pub struct _CTCIF2W<'a> {
w: &'a mut W,
}
impl<'a> _CTCIF2W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: CTCIF2W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clears the TCIF flag in the ISR register"]
#[inline]
pub fn clear(self) -> &'a mut W {
self.variant(CTCIF1W::CLEAR)
}
#[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 u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `CHTIF2`"]
pub type CHTIF2W = CHTIF1W;
#[doc = r" Proxy"]
pub struct _CHTIF2W<'a> {
w: &'a mut W,
}
impl<'a> _CHTIF2W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: CHTIF2W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clears the HTIF flag in the ISR register"]
#[inline]
pub fn clear(self) -> &'a mut W {
self.variant(CHTIF1W::CLEAR)
}
#[doc = r" Sets the field bit"]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r" Clears the field bit"]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r" Writes raw bits to the field"]
#[inline]
pub fn bit(self, value: bool) -> &'a mut W {
const MASK: bool = true;
const OFFSET: u8 = 6;
self.w.bits &= !((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `CTEIF2`"]
pub type CTEIF2W = CTEIF1W;
#[doc = r" Proxy"]
pub struct _CTEIF2W<'a> {
w: &'a mut W,
}
impl<'a> _CTEIF2W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: CTEIF2W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clears the TEIF flag in the ISR register"]
#[inline]
pub fn clear(self) -> &'a mut W {
self.variant(CTEIF1W::CLEAR)
}
#[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 = 7;
self.w.bits &= !((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `CGIF3`"]
pub type CGIF3W = CGIF1W;
#[doc = r" Proxy"]
pub struct _CGIF3W<'a> {
w: &'a mut W,
}
impl<'a> _CGIF3W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: CGIF3W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clears the GIF, TEIF, HTIF, TCIF flags in the ISR register"]
#[inline]
pub fn clear(self) -> &'a mut W {
self.variant(CGIF1W::CLEAR)
}
#[doc = r" Sets the field bit"]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r" Clears the field bit"]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r" Writes raw bits to the field"]
#[inline]
pub fn bit(self, value: bool) -> &'a mut W {
const MASK: bool = true;
const OFFSET: u8 = 8;
self.w.bits &= !((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `CTCIF3`"]
pub type CTCIF3W = CTCIF1W;
#[doc = r" Proxy"]
pub struct _CTCIF3W<'a> {
w: &'a mut W,
}
impl<'a> _CTCIF3W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: CTCIF3W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clears the TCIF flag in the ISR register"]
#[inline]
pub fn clear(self) -> &'a mut W {
self.variant(CTCIF1W::CLEAR)
}
#[doc = r" Sets the field bit"]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r" Clears the field bit"]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r" Writes raw bits to the field"]
#[inline]
pub fn bit(self, value: bool) -> &'a mut W {
const MASK: bool = true;
const OFFSET: u8 = 9;
self.w.bits &= !((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `CHTIF3`"]
pub type CHTIF3W = CHTIF1W;
#[doc = r" Proxy"]
pub struct _CHTIF3W<'a> {
w: &'a mut W,
}
impl<'a> _CHTIF3W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: CHTIF3W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clears the HTIF flag in the ISR register"]
#[inline]
pub fn clear(self) -> &'a mut W {
self.variant(CHTIF1W::CLEAR)
}
#[doc = r" Sets the field bit"]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r" Clears the field bit"]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r" Writes raw bits to the field"]
#[inline]
pub fn bit(self, value: bool) -> &'a mut W {
const MASK: bool = true;
const OFFSET: u8 = 10;
self.w.bits &= !((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `CTEIF3`"]
pub type CTEIF3W = CTEIF1W;
#[doc = r" Proxy"]
pub struct _CTEIF3W<'a> {
w: &'a mut W,
}
impl<'a> _CTEIF3W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: CTEIF3W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clears the TEIF flag in the ISR register"]
#[inline]
pub fn clear(self) -> &'a mut W {
self.variant(CTEIF1W::CLEAR)
}
#[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 u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `CGIF4`"]
pub type CGIF4W = CGIF1W;
#[doc = r" Proxy"]
pub struct _CGIF4W<'a> {
w: &'a mut W,
}
impl<'a> _CGIF4W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: CGIF4W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clears the GIF, TEIF, HTIF, TCIF flags in the ISR register"]
#[inline]
pub fn clear(self) -> &'a mut W {
self.variant(CGIF1W::CLEAR)
}
#[doc = r" Sets the field bit"]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r" Clears the field bit"]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r" Writes raw bits to the field"]
#[inline]
pub fn bit(self, value: bool) -> &'a mut W {
const MASK: bool = true;
const OFFSET: u8 = 12;
self.w.bits &= !((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `CTCIF4`"]
pub type CTCIF4W = CTCIF1W;
#[doc = r" Proxy"]
pub struct _CTCIF4W<'a> {
w: &'a mut W,
}
impl<'a> _CTCIF4W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: CTCIF4W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clears the TCIF flag in the ISR register"]
#[inline]
pub fn clear(self) -> &'a mut W {
self.variant(CTCIF1W::CLEAR)
}
#[doc = r" Sets the field bit"]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r" Clears the field bit"]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r" Writes raw bits to the field"]
#[inline]
pub fn bit(self, value: bool) -> &'a mut W {
const MASK: bool = true;
const OFFSET: u8 = 13;
self.w.bits &= !((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `CHTIF4`"]
pub type CHTIF4W = CHTIF1W;
#[doc = r" Proxy"]
pub struct _CHTIF4W<'a> {
w: &'a mut W,
}
impl<'a> _CHTIF4W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: CHTIF4W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clears the HTIF flag in the ISR register"]
#[inline]
pub fn clear(self) -> &'a mut W {
self.variant(CHTIF1W::CLEAR)
}
#[doc = r" Sets the field bit"]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r" Clears the field bit"]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r" Writes raw bits to the field"]
#[inline]
pub fn bit(self, value: bool) -> &'a mut W {
const MASK: bool = true;
const OFFSET: u8 = 14;
self.w.bits &= !((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `CTEIF4`"]
pub type CTEIF4W = CTEIF1W;
#[doc = r" Proxy"]
pub struct _CTEIF4W<'a> {
w: &'a mut W,
}
impl<'a> _CTEIF4W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: CTEIF4W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clears the TEIF flag in the ISR register"]
#[inline]
pub fn clear(self) -> &'a mut W {
self.variant(CTEIF1W::CLEAR)
}
#[doc = r" Sets the field bit"]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r" Clears the field bit"]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r" Writes raw bits to the field"]
#[inline]
pub fn bit(self, value: bool) -> &'a mut W {
const MASK: bool = true;
const OFFSET: u8 = 15;
self.w.bits &= !((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `CGIF5`"]
pub type CGIF5W = CGIF1W;
#[doc = r" Proxy"]
pub struct _CGIF5W<'a> {
w: &'a mut W,
}
impl<'a> _CGIF5W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: CGIF5W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clears the GIF, TEIF, HTIF, TCIF flags in the ISR register"]
#[inline]
pub fn clear(self) -> &'a mut W {
self.variant(CGIF1W::CLEAR)
}
#[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 = 16;
self.w.bits &= !((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `CTCIF5`"]
pub type CTCIF5W = CTCIF1W;
#[doc = r" Proxy"]
pub struct _CTCIF5W<'a> {
w: &'a mut W,
}
impl<'a> _CTCIF5W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: CTCIF5W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clears the TCIF flag in the ISR register"]
#[inline]
pub fn clear(self) -> &'a mut W {
self.variant(CTCIF1W::CLEAR)
}
#[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 = 17;
self.w.bits &= !((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `CHTIF5`"]
pub type CHTIF5W = CHTIF1W;
#[doc = r" Proxy"]
pub struct _CHTIF5W<'a> {
w: &'a mut W,
}
impl<'a> _CHTIF5W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: CHTIF5W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clears the HTIF flag in the ISR register"]
#[inline]
pub fn clear(self) -> &'a mut W {
self.variant(CHTIF1W::CLEAR)
}
#[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 = 18;
self.w.bits &= !((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `CTEIF5`"]
pub type CTEIF5W = CTEIF1W;
#[doc = r" Proxy"]
pub struct _CTEIF5W<'a> {
w: &'a mut W,
}
impl<'a> _CTEIF5W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: CTEIF5W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clears the TEIF flag in the ISR register"]
#[inline]
pub fn clear(self) -> &'a mut W {
self.variant(CTEIF1W::CLEAR)
}
#[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 = 19;
self.w.bits &= !((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `CGIF6`"]
pub type CGIF6W = CGIF1W;
#[doc = r" Proxy"]
pub struct _CGIF6W<'a> {
w: &'a mut W,
}
impl<'a> _CGIF6W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: CGIF6W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clears the GIF, TEIF, HTIF, TCIF flags in the ISR register"]
#[inline]
pub fn clear(self) -> &'a mut W {
self.variant(CGIF1W::CLEAR)
}
#[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 = 20;
self.w.bits &= !((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `CTCIF6`"]
pub type CTCIF6W = CTCIF1W;
#[doc = r" Proxy"]
pub struct _CTCIF6W<'a> {
w: &'a mut W,
}
impl<'a> _CTCIF6W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: CTCIF6W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clears the TCIF flag in the ISR register"]
#[inline]
pub fn clear(self) -> &'a mut W {
self.variant(CTCIF1W::CLEAR)
}
#[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 = 21;
self.w.bits &= !((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `CHTIF6`"]
pub type CHTIF6W = CHTIF1W;
#[doc = r" Proxy"]
pub struct _CHTIF6W<'a> {
w: &'a mut W,
}
impl<'a> _CHTIF6W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: CHTIF6W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clears the HTIF flag in the ISR register"]
#[inline]
pub fn clear(self) -> &'a mut W {
self.variant(CHTIF1W::CLEAR)
}
#[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 = 22;
self.w.bits &= !((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `CTEIF6`"]
pub type CTEIF6W = CTEIF1W;
#[doc = r" Proxy"]
pub struct _CTEIF6W<'a> {
w: &'a mut W,
}
impl<'a> _CTEIF6W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: CTEIF6W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clears the TEIF flag in the ISR register"]
#[inline]
pub fn clear(self) -> &'a mut W {
self.variant(CTEIF1W::CLEAR)
}
#[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 = 23;
self.w.bits &= !((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `CGIF7`"]
pub type CGIF7W = CGIF1W;
#[doc = r" Proxy"]
pub struct _CGIF7W<'a> {
w: &'a mut W,
}
impl<'a> _CGIF7W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: CGIF7W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clears the GIF, TEIF, HTIF, TCIF flags in the ISR register"]
#[inline]
pub fn clear(self) -> &'a mut W {
self.variant(CGIF1W::CLEAR)
}
#[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 = 24;
self.w.bits &= !((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `CTCIF7`"]
pub type CTCIF7W = CTCIF1W;
#[doc = r" Proxy"]
pub struct _CTCIF7W<'a> {
w: &'a mut W,
}
impl<'a> _CTCIF7W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: CTCIF7W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clears the TCIF flag in the ISR register"]
#[inline]
pub fn clear(self) -> &'a mut W {
self.variant(CTCIF1W::CLEAR)
}
#[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 = 25;
self.w.bits &= !((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `CHTIF7`"]
pub type CHTIF7W = CHTIF1W;
#[doc = r" Proxy"]
pub struct _CHTIF7W<'a> {
w: &'a mut W,
}
impl<'a> _CHTIF7W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: CHTIF7W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clears the HTIF flag in the ISR register"]
#[inline]
pub fn clear(self) -> &'a mut W {
self.variant(CHTIF1W::CLEAR)
}
#[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 = 26;
self.w.bits &= !((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `CTEIF7`"]
pub type CTEIF7W = CTEIF1W;
#[doc = r" Proxy"]
pub struct _CTEIF7W<'a> {
w: &'a mut W,
}
impl<'a> _CTEIF7W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: CTEIF7W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clears the TEIF flag in the ISR register"]
#[inline]
pub fn clear(self) -> &'a mut W {
self.variant(CTEIF1W::CLEAR)
}
#[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 = 27;
self.w.bits &= !((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
impl W {
#[doc = r" Reset value of the register"]
#[inline]
pub fn reset_value() -> W {
W { bits: 0 }
}
#[doc = r" Writes raw bits to the register"]
#[inline]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.bits = bits;
self
}
#[doc = "Bit 0 - Channel 1 Global interrupt clear"]
#[inline]
pub fn cgif1(&mut self) -> _CGIF1W {
_CGIF1W { w: self }
}
#[doc = "Bit 1 - Channel 1 Transfer Complete clear"]
#[inline]
pub fn ctcif1(&mut self) -> _CTCIF1W {
_CTCIF1W { w: self }
}
#[doc = "Bit 2 - Channel 1 Half Transfer clear"]
#[inline]
pub fn chtif1(&mut self) -> _CHTIF1W {
_CHTIF1W { w: self }
}
#[doc = "Bit 3 - Channel 1 Transfer Error clear"]
#[inline]
pub fn cteif1(&mut self) -> _CTEIF1W {
_CTEIF1W { w: self }
}
#[doc = "Bit 4 - Channel 2 Global interrupt clear"]
#[inline]
pub fn cgif2(&mut self) -> _CGIF2W {
_CGIF2W { w: self }
}
#[doc = "Bit 5 - Channel 2 Transfer Complete clear"]
#[inline]
pub fn ctcif2(&mut self) -> _CTCIF2W {
_CTCIF2W { w: self }
}
#[doc = "Bit 6 - Channel 2 Half Transfer clear"]
#[inline]
pub fn chtif2(&mut self) -> _CHTIF2W {
_CHTIF2W { w: self }
}
#[doc = "Bit 7 - Channel 2 Transfer Error clear"]
#[inline]
pub fn cteif2(&mut self) -> _CTEIF2W {
_CTEIF2W { w: self }
}
#[doc = "Bit 8 - Channel 3 Global interrupt clear"]
#[inline]
pub fn cgif3(&mut self) -> _CGIF3W {
_CGIF3W { w: self }
}
#[doc = "Bit 9 - Channel 3 Transfer Complete clear"]
#[inline]
pub fn ctcif3(&mut self) -> _CTCIF3W {
_CTCIF3W { w: self }
}
#[doc = "Bit 10 - Channel 3 Half Transfer clear"]
#[inline]
pub fn chtif3(&mut self) -> _CHTIF3W {
_CHTIF3W { w: self }
}
#[doc = "Bit 11 - Channel 3 Transfer Error clear"]
#[inline]
pub fn cteif3(&mut self) -> _CTEIF3W {
_CTEIF3W { w: self }
}
#[doc = "Bit 12 - Channel 4 Global interrupt clear"]
#[inline]
pub fn cgif4(&mut self) -> _CGIF4W {
_CGIF4W { w: self }
}
#[doc = "Bit 13 - Channel 4 Transfer Complete clear"]
#[inline]
pub fn ctcif4(&mut self) -> _CTCIF4W {
_CTCIF4W { w: self }
}
#[doc = "Bit 14 - Channel 4 Half Transfer clear"]
#[inline]
pub fn chtif4(&mut self) -> _CHTIF4W {
_CHTIF4W { w: self }
}
#[doc = "Bit 15 - Channel 4 Transfer Error clear"]
#[inline]
pub fn cteif4(&mut self) -> _CTEIF4W {
_CTEIF4W { w: self }
}
#[doc = "Bit 16 - Channel 5 Global interrupt clear"]
#[inline]
pub fn cgif5(&mut self) -> _CGIF5W {
_CGIF5W { w: self }
}
#[doc = "Bit 17 - Channel 5 Transfer Complete clear"]
#[inline]
pub fn ctcif5(&mut self) -> _CTCIF5W {
_CTCIF5W { w: self }
}
#[doc = "Bit 18 - Channel 5 Half Transfer clear"]
#[inline]
pub fn chtif5(&mut self) -> _CHTIF5W {
_CHTIF5W { w: self }
}
#[doc = "Bit 19 - Channel 5 Transfer Error clear"]
#[inline]
pub fn cteif5(&mut self) -> _CTEIF5W {
_CTEIF5W { w: self }
}
#[doc = "Bit 20 - Channel 6 Global interrupt clear"]
#[inline]
pub fn cgif6(&mut self) -> _CGIF6W {
_CGIF6W { w: self }
}
#[doc = "Bit 21 - Channel 6 Transfer Complete clear"]
#[inline]
pub fn ctcif6(&mut self) -> _CTCIF6W {
_CTCIF6W { w: self }
}
#[doc = "Bit 22 - Channel 6 Half Transfer clear"]
#[inline]
pub fn chtif6(&mut self) -> _CHTIF6W {
_CHTIF6W { w: self }
}
#[doc = "Bit 23 - Channel 6 Transfer Error clear"]
#[inline]
pub fn cteif6(&mut self) -> _CTEIF6W {
_CTEIF6W { w: self }
}
#[doc = "Bit 24 - Channel 7 Global interrupt clear"]
#[inline]
pub fn cgif7(&mut self) -> _CGIF7W {
_CGIF7W { w: self }
}
#[doc = "Bit 25 - Channel 7 Transfer Complete clear"]
#[inline]
pub fn ctcif7(&mut self) -> _CTCIF7W {
_CTCIF7W { w: self }
}
#[doc = "Bit 26 - Channel 7 Half Transfer clear"]
#[inline]
pub fn chtif7(&mut self) -> _CHTIF7W {
_CHTIF7W { w: self }
}
#[doc = "Bit 27 - Channel 7 Transfer Error clear"]
#[inline]
pub fn cteif7(&mut self) -> _CTEIF7W {
_CTEIF7W { w: self }
}
}