#[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 = r"Value of the field"]
pub struct ISEM0R {
bits: bool,
}
impl ISEM0R {
#[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 _ISEM0W<'a> {
w: &'a mut W,
}
impl<'a> _ISEM0W<'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
}
}
#[doc = r"Value of the field"]
pub struct ISEM1R {
bits: bool,
}
impl ISEM1R {
#[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 _ISEM1W<'a> {
w: &'a mut W,
}
impl<'a> _ISEM1W<'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 ISEM2R {
bits: bool,
}
impl ISEM2R {
#[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 _ISEM2W<'a> {
w: &'a mut W,
}
impl<'a> _ISEM2W<'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 ISEM3R {
bits: bool,
}
impl ISEM3R {
#[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 _ISEM3W<'a> {
w: &'a mut W,
}
impl<'a> _ISEM3W<'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 ISEM4R {
bits: bool,
}
impl ISEM4R {
#[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 _ISEM4W<'a> {
w: &'a mut W,
}
impl<'a> _ISEM4W<'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 ISEM5R {
bits: bool,
}
impl ISEM5R {
#[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 _ISEM5W<'a> {
w: &'a mut W,
}
impl<'a> _ISEM5W<'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 ISEM6R {
bits: bool,
}
impl ISEM6R {
#[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 _ISEM6W<'a> {
w: &'a mut W,
}
impl<'a> _ISEM6W<'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 ISEM7R {
bits: bool,
}
impl ISEM7R {
#[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 _ISEM7W<'a> {
w: &'a mut W,
}
impl<'a> _ISEM7W<'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 ISEM8R {
bits: bool,
}
impl ISEM8R {
#[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 _ISEM8W<'a> {
w: &'a mut W,
}
impl<'a> _ISEM8W<'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 ISEM9R {
bits: bool,
}
impl ISEM9R {
#[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 _ISEM9W<'a> {
w: &'a mut W,
}
impl<'a> _ISEM9W<'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 ISEM10R {
bits: bool,
}
impl ISEM10R {
#[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 _ISEM10W<'a> {
w: &'a mut W,
}
impl<'a> _ISEM10W<'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 ISEM11R {
bits: bool,
}
impl ISEM11R {
#[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 _ISEM11W<'a> {
w: &'a mut W,
}
impl<'a> _ISEM11W<'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 ISEM12R {
bits: bool,
}
impl ISEM12R {
#[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 _ISEM12W<'a> {
w: &'a mut W,
}
impl<'a> _ISEM12W<'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 ISEM13R {
bits: bool,
}
impl ISEM13R {
#[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 _ISEM13W<'a> {
w: &'a mut W,
}
impl<'a> _ISEM13W<'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 ISEM14R {
bits: bool,
}
impl ISEM14R {
#[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 _ISEM14W<'a> {
w: &'a mut W,
}
impl<'a> _ISEM14W<'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 ISEM15R {
bits: bool,
}
impl ISEM15R {
#[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 _ISEM15W<'a> {
w: &'a mut W,
}
impl<'a> _ISEM15W<'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 ISEM16R {
bits: bool,
}
impl ISEM16R {
#[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 _ISEM16W<'a> {
w: &'a mut W,
}
impl<'a> _ISEM16W<'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 ISEM17R {
bits: bool,
}
impl ISEM17R {
#[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 _ISEM17W<'a> {
w: &'a mut W,
}
impl<'a> _ISEM17W<'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 ISEM18R {
bits: bool,
}
impl ISEM18R {
#[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 _ISEM18W<'a> {
w: &'a mut W,
}
impl<'a> _ISEM18W<'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 ISEM19R {
bits: bool,
}
impl ISEM19R {
#[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 _ISEM19W<'a> {
w: &'a mut W,
}
impl<'a> _ISEM19W<'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 ISEM20R {
bits: bool,
}
impl ISEM20R {
#[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 _ISEM20W<'a> {
w: &'a mut W,
}
impl<'a> _ISEM20W<'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 << 20);
self.w.bits |= ((value as u32) & 0x01) << 20;
self.w
}
}
#[doc = r"Value of the field"]
pub struct ISEM21R {
bits: bool,
}
impl ISEM21R {
#[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 _ISEM21W<'a> {
w: &'a mut W,
}
impl<'a> _ISEM21W<'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 << 21);
self.w.bits |= ((value as u32) & 0x01) << 21;
self.w
}
}
#[doc = r"Value of the field"]
pub struct ISEM22R {
bits: bool,
}
impl ISEM22R {
#[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 _ISEM22W<'a> {
w: &'a mut W,
}
impl<'a> _ISEM22W<'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 << 22);
self.w.bits |= ((value as u32) & 0x01) << 22;
self.w
}
}
#[doc = r"Value of the field"]
pub struct ISEM23R {
bits: bool,
}
impl ISEM23R {
#[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 _ISEM23W<'a> {
w: &'a mut W,
}
impl<'a> _ISEM23W<'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 << 23);
self.w.bits |= ((value as u32) & 0x01) << 23;
self.w
}
}
#[doc = r"Value of the field"]
pub struct ISEM24R {
bits: bool,
}
impl ISEM24R {
#[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 _ISEM24W<'a> {
w: &'a mut W,
}
impl<'a> _ISEM24W<'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 ISEM25R {
bits: bool,
}
impl ISEM25R {
#[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 _ISEM25W<'a> {
w: &'a mut W,
}
impl<'a> _ISEM25W<'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 ISEM26R {
bits: bool,
}
impl ISEM26R {
#[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 _ISEM26W<'a> {
w: &'a mut W,
}
impl<'a> _ISEM26W<'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 ISEM27R {
bits: bool,
}
impl ISEM27R {
#[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 _ISEM27W<'a> {
w: &'a mut W,
}
impl<'a> _ISEM27W<'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 ISEM28R {
bits: bool,
}
impl ISEM28R {
#[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 _ISEM28W<'a> {
w: &'a mut W,
}
impl<'a> _ISEM28W<'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 ISEM29R {
bits: bool,
}
impl ISEM29R {
#[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 _ISEM29W<'a> {
w: &'a mut W,
}
impl<'a> _ISEM29W<'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 ISEM30R {
bits: bool,
}
impl ISEM30R {
#[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 _ISEM30W<'a> {
w: &'a mut W,
}
impl<'a> _ISEM30W<'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 ISEM31R {
bits: bool,
}
impl ISEM31R {
#[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 _ISEM31W<'a> {
w: &'a mut W,
}
impl<'a> _ISEM31W<'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
}
}
impl R {
#[doc = r"Value of the register as raw bits"]
#[inline(always)]
pub fn bits(&self) -> u32 {
self.bits
}
#[doc = "Bit 0 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem0(&self) -> ISEM0R {
let bits = ((self.bits >> 0) & 0x01) != 0;
ISEM0R { bits }
}
#[doc = "Bit 1 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem1(&self) -> ISEM1R {
let bits = ((self.bits >> 1) & 0x01) != 0;
ISEM1R { bits }
}
#[doc = "Bit 2 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem2(&self) -> ISEM2R {
let bits = ((self.bits >> 2) & 0x01) != 0;
ISEM2R { bits }
}
#[doc = "Bit 3 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem3(&self) -> ISEM3R {
let bits = ((self.bits >> 3) & 0x01) != 0;
ISEM3R { bits }
}
#[doc = "Bit 4 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem4(&self) -> ISEM4R {
let bits = ((self.bits >> 4) & 0x01) != 0;
ISEM4R { bits }
}
#[doc = "Bit 5 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem5(&self) -> ISEM5R {
let bits = ((self.bits >> 5) & 0x01) != 0;
ISEM5R { bits }
}
#[doc = "Bit 6 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem6(&self) -> ISEM6R {
let bits = ((self.bits >> 6) & 0x01) != 0;
ISEM6R { bits }
}
#[doc = "Bit 7 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem7(&self) -> ISEM7R {
let bits = ((self.bits >> 7) & 0x01) != 0;
ISEM7R { bits }
}
#[doc = "Bit 8 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem8(&self) -> ISEM8R {
let bits = ((self.bits >> 8) & 0x01) != 0;
ISEM8R { bits }
}
#[doc = "Bit 9 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem9(&self) -> ISEM9R {
let bits = ((self.bits >> 9) & 0x01) != 0;
ISEM9R { bits }
}
#[doc = "Bit 10 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem10(&self) -> ISEM10R {
let bits = ((self.bits >> 10) & 0x01) != 0;
ISEM10R { bits }
}
#[doc = "Bit 11 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem11(&self) -> ISEM11R {
let bits = ((self.bits >> 11) & 0x01) != 0;
ISEM11R { bits }
}
#[doc = "Bit 12 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem12(&self) -> ISEM12R {
let bits = ((self.bits >> 12) & 0x01) != 0;
ISEM12R { bits }
}
#[doc = "Bit 13 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem13(&self) -> ISEM13R {
let bits = ((self.bits >> 13) & 0x01) != 0;
ISEM13R { bits }
}
#[doc = "Bit 14 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem14(&self) -> ISEM14R {
let bits = ((self.bits >> 14) & 0x01) != 0;
ISEM14R { bits }
}
#[doc = "Bit 15 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem15(&self) -> ISEM15R {
let bits = ((self.bits >> 15) & 0x01) != 0;
ISEM15R { bits }
}
#[doc = "Bit 16 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem16(&self) -> ISEM16R {
let bits = ((self.bits >> 16) & 0x01) != 0;
ISEM16R { bits }
}
#[doc = "Bit 17 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem17(&self) -> ISEM17R {
let bits = ((self.bits >> 17) & 0x01) != 0;
ISEM17R { bits }
}
#[doc = "Bit 18 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem18(&self) -> ISEM18R {
let bits = ((self.bits >> 18) & 0x01) != 0;
ISEM18R { bits }
}
#[doc = "Bit 19 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem19(&self) -> ISEM19R {
let bits = ((self.bits >> 19) & 0x01) != 0;
ISEM19R { bits }
}
#[doc = "Bit 20 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem20(&self) -> ISEM20R {
let bits = ((self.bits >> 20) & 0x01) != 0;
ISEM20R { bits }
}
#[doc = "Bit 21 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem21(&self) -> ISEM21R {
let bits = ((self.bits >> 21) & 0x01) != 0;
ISEM21R { bits }
}
#[doc = "Bit 22 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem22(&self) -> ISEM22R {
let bits = ((self.bits >> 22) & 0x01) != 0;
ISEM22R { bits }
}
#[doc = "Bit 23 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem23(&self) -> ISEM23R {
let bits = ((self.bits >> 23) & 0x01) != 0;
ISEM23R { bits }
}
#[doc = "Bit 24 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem24(&self) -> ISEM24R {
let bits = ((self.bits >> 24) & 0x01) != 0;
ISEM24R { bits }
}
#[doc = "Bit 25 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem25(&self) -> ISEM25R {
let bits = ((self.bits >> 25) & 0x01) != 0;
ISEM25R { bits }
}
#[doc = "Bit 26 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem26(&self) -> ISEM26R {
let bits = ((self.bits >> 26) & 0x01) != 0;
ISEM26R { bits }
}
#[doc = "Bit 27 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem27(&self) -> ISEM27R {
let bits = ((self.bits >> 27) & 0x01) != 0;
ISEM27R { bits }
}
#[doc = "Bit 28 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem28(&self) -> ISEM28R {
let bits = ((self.bits >> 28) & 0x01) != 0;
ISEM28R { bits }
}
#[doc = "Bit 29 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem29(&self) -> ISEM29R {
let bits = ((self.bits >> 29) & 0x01) != 0;
ISEM29R { bits }
}
#[doc = "Bit 30 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem30(&self) -> ISEM30R {
let bits = ((self.bits >> 30) & 0x01) != 0;
ISEM30R { bits }
}
#[doc = "Bit 31 - Interrupt(N) semaphore n enable bit."]
#[inline(always)]
pub fn isem31(&self) -> ISEM31R {
let bits = ((self.bits >> 31) & 0x01) != 0;
ISEM31R { 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 0 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem0(&mut self) -> _ISEM0W {
_ISEM0W { w: self }
}
#[doc = "Bit 1 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem1(&mut self) -> _ISEM1W {
_ISEM1W { w: self }
}
#[doc = "Bit 2 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem2(&mut self) -> _ISEM2W {
_ISEM2W { w: self }
}
#[doc = "Bit 3 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem3(&mut self) -> _ISEM3W {
_ISEM3W { w: self }
}
#[doc = "Bit 4 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem4(&mut self) -> _ISEM4W {
_ISEM4W { w: self }
}
#[doc = "Bit 5 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem5(&mut self) -> _ISEM5W {
_ISEM5W { w: self }
}
#[doc = "Bit 6 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem6(&mut self) -> _ISEM6W {
_ISEM6W { w: self }
}
#[doc = "Bit 7 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem7(&mut self) -> _ISEM7W {
_ISEM7W { w: self }
}
#[doc = "Bit 8 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem8(&mut self) -> _ISEM8W {
_ISEM8W { w: self }
}
#[doc = "Bit 9 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem9(&mut self) -> _ISEM9W {
_ISEM9W { w: self }
}
#[doc = "Bit 10 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem10(&mut self) -> _ISEM10W {
_ISEM10W { w: self }
}
#[doc = "Bit 11 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem11(&mut self) -> _ISEM11W {
_ISEM11W { w: self }
}
#[doc = "Bit 12 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem12(&mut self) -> _ISEM12W {
_ISEM12W { w: self }
}
#[doc = "Bit 13 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem13(&mut self) -> _ISEM13W {
_ISEM13W { w: self }
}
#[doc = "Bit 14 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem14(&mut self) -> _ISEM14W {
_ISEM14W { w: self }
}
#[doc = "Bit 15 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem15(&mut self) -> _ISEM15W {
_ISEM15W { w: self }
}
#[doc = "Bit 16 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem16(&mut self) -> _ISEM16W {
_ISEM16W { w: self }
}
#[doc = "Bit 17 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem17(&mut self) -> _ISEM17W {
_ISEM17W { w: self }
}
#[doc = "Bit 18 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem18(&mut self) -> _ISEM18W {
_ISEM18W { w: self }
}
#[doc = "Bit 19 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem19(&mut self) -> _ISEM19W {
_ISEM19W { w: self }
}
#[doc = "Bit 20 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem20(&mut self) -> _ISEM20W {
_ISEM20W { w: self }
}
#[doc = "Bit 21 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem21(&mut self) -> _ISEM21W {
_ISEM21W { w: self }
}
#[doc = "Bit 22 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem22(&mut self) -> _ISEM22W {
_ISEM22W { w: self }
}
#[doc = "Bit 23 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem23(&mut self) -> _ISEM23W {
_ISEM23W { w: self }
}
#[doc = "Bit 24 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem24(&mut self) -> _ISEM24W {
_ISEM24W { w: self }
}
#[doc = "Bit 25 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem25(&mut self) -> _ISEM25W {
_ISEM25W { w: self }
}
#[doc = "Bit 26 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem26(&mut self) -> _ISEM26W {
_ISEM26W { w: self }
}
#[doc = "Bit 27 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem27(&mut self) -> _ISEM27W {
_ISEM27W { w: self }
}
#[doc = "Bit 28 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem28(&mut self) -> _ISEM28W {
_ISEM28W { w: self }
}
#[doc = "Bit 29 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem29(&mut self) -> _ISEM29W {
_ISEM29W { w: self }
}
#[doc = "Bit 30 - Interrupt semaphore n enable bit"]
#[inline(always)]
pub fn isem30(&mut self) -> _ISEM30W {
_ISEM30W { w: self }
}
#[doc = "Bit 31 - Interrupt(N) semaphore n enable bit."]
#[inline(always)]
pub fn isem31(&mut self) -> _ISEM31W {
_ISEM31W { w: self }
}
}