3873 lines
102 KiB
Rust
3873 lines
102 KiB
Rust
#[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::ADC14IER0 {
|
|
#[doc = r" Modifies the contents of the register"]
|
|
#[inline]
|
|
pub fn modify<F>(&self, f: F)
|
|
where
|
|
for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
|
|
{
|
|
let bits = self.register.get();
|
|
let r = R { bits: bits };
|
|
let mut w = W { bits: bits };
|
|
f(&r, &mut w);
|
|
self.register.set(w.bits);
|
|
}
|
|
#[doc = r" Reads the contents of the register"]
|
|
#[inline]
|
|
pub fn read(&self) -> R {
|
|
R {
|
|
bits: self.register.get(),
|
|
}
|
|
}
|
|
#[doc = r" Writes to the register"]
|
|
#[inline]
|
|
pub fn write<F>(&self, f: F)
|
|
where
|
|
F: FnOnce(&mut W) -> &mut W,
|
|
{
|
|
let mut w = W::reset_value();
|
|
f(&mut w);
|
|
self.register.set(w.bits);
|
|
}
|
|
#[doc = r" Writes the reset value to the register"]
|
|
#[inline]
|
|
pub fn reset(&self) {
|
|
self.write(|w| w)
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IE0`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IE0R {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE0_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE0_1,
|
|
}
|
|
impl ADC14IE0R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
ADC14IE0R::ADC14IE0_0 => false,
|
|
ADC14IE0R::ADC14IE0_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IE0R {
|
|
match value {
|
|
false => ADC14IE0R::ADC14IE0_0,
|
|
true => ADC14IE0R::ADC14IE0_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE0_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ie0_0(&self) -> bool {
|
|
*self == ADC14IE0R::ADC14IE0_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE0_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ie0_1(&self) -> bool {
|
|
*self == ADC14IE0R::ADC14IE0_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IE1`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IE1R {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE1_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE1_1,
|
|
}
|
|
impl ADC14IE1R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
ADC14IE1R::ADC14IE1_0 => false,
|
|
ADC14IE1R::ADC14IE1_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IE1R {
|
|
match value {
|
|
false => ADC14IE1R::ADC14IE1_0,
|
|
true => ADC14IE1R::ADC14IE1_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE1_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ie1_0(&self) -> bool {
|
|
*self == ADC14IE1R::ADC14IE1_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE1_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ie1_1(&self) -> bool {
|
|
*self == ADC14IE1R::ADC14IE1_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IE2`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IE2R {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE2_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE2_1,
|
|
}
|
|
impl ADC14IE2R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
ADC14IE2R::ADC14IE2_0 => false,
|
|
ADC14IE2R::ADC14IE2_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IE2R {
|
|
match value {
|
|
false => ADC14IE2R::ADC14IE2_0,
|
|
true => ADC14IE2R::ADC14IE2_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE2_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ie2_0(&self) -> bool {
|
|
*self == ADC14IE2R::ADC14IE2_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE2_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ie2_1(&self) -> bool {
|
|
*self == ADC14IE2R::ADC14IE2_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IE3`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IE3R {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE3_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE3_1,
|
|
}
|
|
impl ADC14IE3R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
ADC14IE3R::ADC14IE3_0 => false,
|
|
ADC14IE3R::ADC14IE3_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IE3R {
|
|
match value {
|
|
false => ADC14IE3R::ADC14IE3_0,
|
|
true => ADC14IE3R::ADC14IE3_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE3_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ie3_0(&self) -> bool {
|
|
*self == ADC14IE3R::ADC14IE3_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE3_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ie3_1(&self) -> bool {
|
|
*self == ADC14IE3R::ADC14IE3_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IE4`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IE4R {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE4_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE4_1,
|
|
}
|
|
impl ADC14IE4R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
ADC14IE4R::ADC14IE4_0 => false,
|
|
ADC14IE4R::ADC14IE4_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IE4R {
|
|
match value {
|
|
false => ADC14IE4R::ADC14IE4_0,
|
|
true => ADC14IE4R::ADC14IE4_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE4_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ie4_0(&self) -> bool {
|
|
*self == ADC14IE4R::ADC14IE4_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE4_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ie4_1(&self) -> bool {
|
|
*self == ADC14IE4R::ADC14IE4_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IE5`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IE5R {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE5_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE5_1,
|
|
}
|
|
impl ADC14IE5R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
ADC14IE5R::ADC14IE5_0 => false,
|
|
ADC14IE5R::ADC14IE5_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IE5R {
|
|
match value {
|
|
false => ADC14IE5R::ADC14IE5_0,
|
|
true => ADC14IE5R::ADC14IE5_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE5_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ie5_0(&self) -> bool {
|
|
*self == ADC14IE5R::ADC14IE5_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE5_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ie5_1(&self) -> bool {
|
|
*self == ADC14IE5R::ADC14IE5_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IE6`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IE6R {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE6_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE6_1,
|
|
}
|
|
impl ADC14IE6R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
ADC14IE6R::ADC14IE6_0 => false,
|
|
ADC14IE6R::ADC14IE6_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IE6R {
|
|
match value {
|
|
false => ADC14IE6R::ADC14IE6_0,
|
|
true => ADC14IE6R::ADC14IE6_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE6_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ie6_0(&self) -> bool {
|
|
*self == ADC14IE6R::ADC14IE6_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE6_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ie6_1(&self) -> bool {
|
|
*self == ADC14IE6R::ADC14IE6_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IE7`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IE7R {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE7_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE7_1,
|
|
}
|
|
impl ADC14IE7R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
ADC14IE7R::ADC14IE7_0 => false,
|
|
ADC14IE7R::ADC14IE7_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IE7R {
|
|
match value {
|
|
false => ADC14IE7R::ADC14IE7_0,
|
|
true => ADC14IE7R::ADC14IE7_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE7_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ie7_0(&self) -> bool {
|
|
*self == ADC14IE7R::ADC14IE7_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE7_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ie7_1(&self) -> bool {
|
|
*self == ADC14IE7R::ADC14IE7_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IE8`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IE8R {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE8_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE8_1,
|
|
}
|
|
impl ADC14IE8R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
ADC14IE8R::ADC14IE8_0 => false,
|
|
ADC14IE8R::ADC14IE8_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IE8R {
|
|
match value {
|
|
false => ADC14IE8R::ADC14IE8_0,
|
|
true => ADC14IE8R::ADC14IE8_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE8_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ie8_0(&self) -> bool {
|
|
*self == ADC14IE8R::ADC14IE8_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE8_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ie8_1(&self) -> bool {
|
|
*self == ADC14IE8R::ADC14IE8_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IE9`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IE9R {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE9_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE9_1,
|
|
}
|
|
impl ADC14IE9R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
ADC14IE9R::ADC14IE9_0 => false,
|
|
ADC14IE9R::ADC14IE9_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IE9R {
|
|
match value {
|
|
false => ADC14IE9R::ADC14IE9_0,
|
|
true => ADC14IE9R::ADC14IE9_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE9_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ie9_0(&self) -> bool {
|
|
*self == ADC14IE9R::ADC14IE9_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE9_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ie9_1(&self) -> bool {
|
|
*self == ADC14IE9R::ADC14IE9_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IE10`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IE10R {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE10_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE10_1,
|
|
}
|
|
impl ADC14IE10R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
ADC14IE10R::ADC14IE10_0 => false,
|
|
ADC14IE10R::ADC14IE10_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IE10R {
|
|
match value {
|
|
false => ADC14IE10R::ADC14IE10_0,
|
|
true => ADC14IE10R::ADC14IE10_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE10_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ie10_0(&self) -> bool {
|
|
*self == ADC14IE10R::ADC14IE10_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE10_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ie10_1(&self) -> bool {
|
|
*self == ADC14IE10R::ADC14IE10_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IE11`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IE11R {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE11_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE11_1,
|
|
}
|
|
impl ADC14IE11R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
ADC14IE11R::ADC14IE11_0 => false,
|
|
ADC14IE11R::ADC14IE11_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IE11R {
|
|
match value {
|
|
false => ADC14IE11R::ADC14IE11_0,
|
|
true => ADC14IE11R::ADC14IE11_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE11_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ie11_0(&self) -> bool {
|
|
*self == ADC14IE11R::ADC14IE11_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE11_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ie11_1(&self) -> bool {
|
|
*self == ADC14IE11R::ADC14IE11_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IE12`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IE12R {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE12_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE12_1,
|
|
}
|
|
impl ADC14IE12R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
ADC14IE12R::ADC14IE12_0 => false,
|
|
ADC14IE12R::ADC14IE12_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IE12R {
|
|
match value {
|
|
false => ADC14IE12R::ADC14IE12_0,
|
|
true => ADC14IE12R::ADC14IE12_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE12_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ie12_0(&self) -> bool {
|
|
*self == ADC14IE12R::ADC14IE12_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE12_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ie12_1(&self) -> bool {
|
|
*self == ADC14IE12R::ADC14IE12_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IE13`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IE13R {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE13_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE13_1,
|
|
}
|
|
impl ADC14IE13R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
ADC14IE13R::ADC14IE13_0 => false,
|
|
ADC14IE13R::ADC14IE13_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IE13R {
|
|
match value {
|
|
false => ADC14IE13R::ADC14IE13_0,
|
|
true => ADC14IE13R::ADC14IE13_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE13_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ie13_0(&self) -> bool {
|
|
*self == ADC14IE13R::ADC14IE13_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE13_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ie13_1(&self) -> bool {
|
|
*self == ADC14IE13R::ADC14IE13_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IE14`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IE14R {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE14_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE14_1,
|
|
}
|
|
impl ADC14IE14R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
ADC14IE14R::ADC14IE14_0 => false,
|
|
ADC14IE14R::ADC14IE14_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IE14R {
|
|
match value {
|
|
false => ADC14IE14R::ADC14IE14_0,
|
|
true => ADC14IE14R::ADC14IE14_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE14_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ie14_0(&self) -> bool {
|
|
*self == ADC14IE14R::ADC14IE14_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE14_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ie14_1(&self) -> bool {
|
|
*self == ADC14IE14R::ADC14IE14_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IE15`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IE15R {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE15_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE15_1,
|
|
}
|
|
impl ADC14IE15R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
ADC14IE15R::ADC14IE15_0 => false,
|
|
ADC14IE15R::ADC14IE15_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IE15R {
|
|
match value {
|
|
false => ADC14IE15R::ADC14IE15_0,
|
|
true => ADC14IE15R::ADC14IE15_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE15_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ie15_0(&self) -> bool {
|
|
*self == ADC14IE15R::ADC14IE15_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE15_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ie15_1(&self) -> bool {
|
|
*self == ADC14IE15R::ADC14IE15_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IE16`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IE16R {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE16_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE16_1,
|
|
}
|
|
impl ADC14IE16R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
ADC14IE16R::ADC14IE16_0 => false,
|
|
ADC14IE16R::ADC14IE16_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IE16R {
|
|
match value {
|
|
false => ADC14IE16R::ADC14IE16_0,
|
|
true => ADC14IE16R::ADC14IE16_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE16_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ie16_0(&self) -> bool {
|
|
*self == ADC14IE16R::ADC14IE16_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE16_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ie16_1(&self) -> bool {
|
|
*self == ADC14IE16R::ADC14IE16_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IE17`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IE17R {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE17_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE17_1,
|
|
}
|
|
impl ADC14IE17R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
ADC14IE17R::ADC14IE17_0 => false,
|
|
ADC14IE17R::ADC14IE17_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IE17R {
|
|
match value {
|
|
false => ADC14IE17R::ADC14IE17_0,
|
|
true => ADC14IE17R::ADC14IE17_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE17_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ie17_0(&self) -> bool {
|
|
*self == ADC14IE17R::ADC14IE17_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE17_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ie17_1(&self) -> bool {
|
|
*self == ADC14IE17R::ADC14IE17_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IE19`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IE19R {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE19_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE19_1,
|
|
}
|
|
impl ADC14IE19R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
ADC14IE19R::ADC14IE19_0 => false,
|
|
ADC14IE19R::ADC14IE19_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IE19R {
|
|
match value {
|
|
false => ADC14IE19R::ADC14IE19_0,
|
|
true => ADC14IE19R::ADC14IE19_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE19_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ie19_0(&self) -> bool {
|
|
*self == ADC14IE19R::ADC14IE19_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE19_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ie19_1(&self) -> bool {
|
|
*self == ADC14IE19R::ADC14IE19_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IE18`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IE18R {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE18_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE18_1,
|
|
}
|
|
impl ADC14IE18R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
ADC14IE18R::ADC14IE18_0 => false,
|
|
ADC14IE18R::ADC14IE18_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IE18R {
|
|
match value {
|
|
false => ADC14IE18R::ADC14IE18_0,
|
|
true => ADC14IE18R::ADC14IE18_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE18_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ie18_0(&self) -> bool {
|
|
*self == ADC14IE18R::ADC14IE18_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE18_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ie18_1(&self) -> bool {
|
|
*self == ADC14IE18R::ADC14IE18_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IE20`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IE20R {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE20_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE20_1,
|
|
}
|
|
impl ADC14IE20R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
ADC14IE20R::ADC14IE20_0 => false,
|
|
ADC14IE20R::ADC14IE20_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IE20R {
|
|
match value {
|
|
false => ADC14IE20R::ADC14IE20_0,
|
|
true => ADC14IE20R::ADC14IE20_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE20_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ie20_0(&self) -> bool {
|
|
*self == ADC14IE20R::ADC14IE20_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE20_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ie20_1(&self) -> bool {
|
|
*self == ADC14IE20R::ADC14IE20_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IE21`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IE21R {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE21_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE21_1,
|
|
}
|
|
impl ADC14IE21R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
ADC14IE21R::ADC14IE21_0 => false,
|
|
ADC14IE21R::ADC14IE21_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IE21R {
|
|
match value {
|
|
false => ADC14IE21R::ADC14IE21_0,
|
|
true => ADC14IE21R::ADC14IE21_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE21_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ie21_0(&self) -> bool {
|
|
*self == ADC14IE21R::ADC14IE21_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE21_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ie21_1(&self) -> bool {
|
|
*self == ADC14IE21R::ADC14IE21_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IE22`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IE22R {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE22_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE22_1,
|
|
}
|
|
impl ADC14IE22R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
ADC14IE22R::ADC14IE22_0 => false,
|
|
ADC14IE22R::ADC14IE22_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IE22R {
|
|
match value {
|
|
false => ADC14IE22R::ADC14IE22_0,
|
|
true => ADC14IE22R::ADC14IE22_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE22_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ie22_0(&self) -> bool {
|
|
*self == ADC14IE22R::ADC14IE22_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE22_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ie22_1(&self) -> bool {
|
|
*self == ADC14IE22R::ADC14IE22_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IE23`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IE23R {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE23_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE23_1,
|
|
}
|
|
impl ADC14IE23R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
ADC14IE23R::ADC14IE23_0 => false,
|
|
ADC14IE23R::ADC14IE23_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IE23R {
|
|
match value {
|
|
false => ADC14IE23R::ADC14IE23_0,
|
|
true => ADC14IE23R::ADC14IE23_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE23_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ie23_0(&self) -> bool {
|
|
*self == ADC14IE23R::ADC14IE23_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE23_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ie23_1(&self) -> bool {
|
|
*self == ADC14IE23R::ADC14IE23_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IE24`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IE24R {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE24_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE24_1,
|
|
}
|
|
impl ADC14IE24R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
ADC14IE24R::ADC14IE24_0 => false,
|
|
ADC14IE24R::ADC14IE24_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IE24R {
|
|
match value {
|
|
false => ADC14IE24R::ADC14IE24_0,
|
|
true => ADC14IE24R::ADC14IE24_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE24_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ie24_0(&self) -> bool {
|
|
*self == ADC14IE24R::ADC14IE24_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE24_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ie24_1(&self) -> bool {
|
|
*self == ADC14IE24R::ADC14IE24_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IE25`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IE25R {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE25_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE25_1,
|
|
}
|
|
impl ADC14IE25R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
ADC14IE25R::ADC14IE25_0 => false,
|
|
ADC14IE25R::ADC14IE25_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IE25R {
|
|
match value {
|
|
false => ADC14IE25R::ADC14IE25_0,
|
|
true => ADC14IE25R::ADC14IE25_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE25_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ie25_0(&self) -> bool {
|
|
*self == ADC14IE25R::ADC14IE25_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE25_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ie25_1(&self) -> bool {
|
|
*self == ADC14IE25R::ADC14IE25_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IE26`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IE26R {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE26_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE26_1,
|
|
}
|
|
impl ADC14IE26R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
ADC14IE26R::ADC14IE26_0 => false,
|
|
ADC14IE26R::ADC14IE26_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IE26R {
|
|
match value {
|
|
false => ADC14IE26R::ADC14IE26_0,
|
|
true => ADC14IE26R::ADC14IE26_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE26_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ie26_0(&self) -> bool {
|
|
*self == ADC14IE26R::ADC14IE26_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE26_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ie26_1(&self) -> bool {
|
|
*self == ADC14IE26R::ADC14IE26_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IE27`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IE27R {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE27_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE27_1,
|
|
}
|
|
impl ADC14IE27R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
ADC14IE27R::ADC14IE27_0 => false,
|
|
ADC14IE27R::ADC14IE27_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IE27R {
|
|
match value {
|
|
false => ADC14IE27R::ADC14IE27_0,
|
|
true => ADC14IE27R::ADC14IE27_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE27_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ie27_0(&self) -> bool {
|
|
*self == ADC14IE27R::ADC14IE27_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE27_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ie27_1(&self) -> bool {
|
|
*self == ADC14IE27R::ADC14IE27_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IE28`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IE28R {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE28_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE28_1,
|
|
}
|
|
impl ADC14IE28R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
ADC14IE28R::ADC14IE28_0 => false,
|
|
ADC14IE28R::ADC14IE28_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IE28R {
|
|
match value {
|
|
false => ADC14IE28R::ADC14IE28_0,
|
|
true => ADC14IE28R::ADC14IE28_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE28_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ie28_0(&self) -> bool {
|
|
*self == ADC14IE28R::ADC14IE28_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE28_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ie28_1(&self) -> bool {
|
|
*self == ADC14IE28R::ADC14IE28_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IE29`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IE29R {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE29_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE29_1,
|
|
}
|
|
impl ADC14IE29R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
ADC14IE29R::ADC14IE29_0 => false,
|
|
ADC14IE29R::ADC14IE29_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IE29R {
|
|
match value {
|
|
false => ADC14IE29R::ADC14IE29_0,
|
|
true => ADC14IE29R::ADC14IE29_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE29_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ie29_0(&self) -> bool {
|
|
*self == ADC14IE29R::ADC14IE29_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE29_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ie29_1(&self) -> bool {
|
|
*self == ADC14IE29R::ADC14IE29_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IE30`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IE30R {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE30_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE30_1,
|
|
}
|
|
impl ADC14IE30R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
ADC14IE30R::ADC14IE30_0 => false,
|
|
ADC14IE30R::ADC14IE30_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IE30R {
|
|
match value {
|
|
false => ADC14IE30R::ADC14IE30_0,
|
|
true => ADC14IE30R::ADC14IE30_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE30_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ie30_0(&self) -> bool {
|
|
*self == ADC14IE30R::ADC14IE30_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE30_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ie30_1(&self) -> bool {
|
|
*self == ADC14IE30R::ADC14IE30_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `ADC14IE31`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADC14IE31R {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE31_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE31_1,
|
|
}
|
|
impl ADC14IE31R {
|
|
#[doc = r" Returns `true` if the bit is clear (0)"]
|
|
#[inline]
|
|
pub fn bit_is_clear(&self) -> bool {
|
|
!self.bit()
|
|
}
|
|
#[doc = r" Returns `true` if the bit is set (1)"]
|
|
#[inline]
|
|
pub fn bit_is_set(&self) -> bool {
|
|
self.bit()
|
|
}
|
|
#[doc = r" Value of the field as raw bits"]
|
|
#[inline]
|
|
pub fn bit(&self) -> bool {
|
|
match *self {
|
|
ADC14IE31R::ADC14IE31_0 => false,
|
|
ADC14IE31R::ADC14IE31_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> ADC14IE31R {
|
|
match value {
|
|
false => ADC14IE31R::ADC14IE31_0,
|
|
true => ADC14IE31R::ADC14IE31_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE31_0`"]
|
|
#[inline]
|
|
pub fn is_adc14ie31_0(&self) -> bool {
|
|
*self == ADC14IE31R::ADC14IE31_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `ADC14IE31_1`"]
|
|
#[inline]
|
|
pub fn is_adc14ie31_1(&self) -> bool {
|
|
*self == ADC14IE31R::ADC14IE31_1
|
|
}
|
|
}
|
|
#[doc = "Values that can be written to the field `ADC14IE0`"]
|
|
pub enum ADC14IE0W {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE0_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE0_1,
|
|
}
|
|
impl ADC14IE0W {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
ADC14IE0W::ADC14IE0_0 => false,
|
|
ADC14IE0W::ADC14IE0_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _ADC14IE0W<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _ADC14IE0W<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: ADC14IE0W) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn adc14ie0_0(self) -> &'a mut W {
|
|
self.variant(ADC14IE0W::ADC14IE0_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn adc14ie0_1(self) -> &'a mut W {
|
|
self.variant(ADC14IE0W::ADC14IE0_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 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 `ADC14IE1`"]
|
|
pub enum ADC14IE1W {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE1_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE1_1,
|
|
}
|
|
impl ADC14IE1W {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
ADC14IE1W::ADC14IE1_0 => false,
|
|
ADC14IE1W::ADC14IE1_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _ADC14IE1W<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _ADC14IE1W<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: ADC14IE1W) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn adc14ie1_0(self) -> &'a mut W {
|
|
self.variant(ADC14IE1W::ADC14IE1_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn adc14ie1_1(self) -> &'a mut W {
|
|
self.variant(ADC14IE1W::ADC14IE1_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 1;
|
|
self.w.bits &= !((MASK as u32) << OFFSET);
|
|
self.w.bits |= ((value & MASK) as u32) << OFFSET;
|
|
self.w
|
|
}
|
|
}
|
|
#[doc = "Values that can be written to the field `ADC14IE2`"]
|
|
pub enum ADC14IE2W {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE2_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE2_1,
|
|
}
|
|
impl ADC14IE2W {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
ADC14IE2W::ADC14IE2_0 => false,
|
|
ADC14IE2W::ADC14IE2_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _ADC14IE2W<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _ADC14IE2W<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: ADC14IE2W) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn adc14ie2_0(self) -> &'a mut W {
|
|
self.variant(ADC14IE2W::ADC14IE2_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn adc14ie2_1(self) -> &'a mut W {
|
|
self.variant(ADC14IE2W::ADC14IE2_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 2;
|
|
self.w.bits &= !((MASK as u32) << OFFSET);
|
|
self.w.bits |= ((value & MASK) as u32) << OFFSET;
|
|
self.w
|
|
}
|
|
}
|
|
#[doc = "Values that can be written to the field `ADC14IE3`"]
|
|
pub enum ADC14IE3W {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE3_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE3_1,
|
|
}
|
|
impl ADC14IE3W {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
ADC14IE3W::ADC14IE3_0 => false,
|
|
ADC14IE3W::ADC14IE3_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _ADC14IE3W<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _ADC14IE3W<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: ADC14IE3W) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn adc14ie3_0(self) -> &'a mut W {
|
|
self.variant(ADC14IE3W::ADC14IE3_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn adc14ie3_1(self) -> &'a mut W {
|
|
self.variant(ADC14IE3W::ADC14IE3_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 3;
|
|
self.w.bits &= !((MASK as u32) << OFFSET);
|
|
self.w.bits |= ((value & MASK) as u32) << OFFSET;
|
|
self.w
|
|
}
|
|
}
|
|
#[doc = "Values that can be written to the field `ADC14IE4`"]
|
|
pub enum ADC14IE4W {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE4_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE4_1,
|
|
}
|
|
impl ADC14IE4W {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
ADC14IE4W::ADC14IE4_0 => false,
|
|
ADC14IE4W::ADC14IE4_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _ADC14IE4W<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _ADC14IE4W<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: ADC14IE4W) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn adc14ie4_0(self) -> &'a mut W {
|
|
self.variant(ADC14IE4W::ADC14IE4_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn adc14ie4_1(self) -> &'a mut W {
|
|
self.variant(ADC14IE4W::ADC14IE4_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 4;
|
|
self.w.bits &= !((MASK as u32) << OFFSET);
|
|
self.w.bits |= ((value & MASK) as u32) << OFFSET;
|
|
self.w
|
|
}
|
|
}
|
|
#[doc = "Values that can be written to the field `ADC14IE5`"]
|
|
pub enum ADC14IE5W {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE5_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE5_1,
|
|
}
|
|
impl ADC14IE5W {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
ADC14IE5W::ADC14IE5_0 => false,
|
|
ADC14IE5W::ADC14IE5_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _ADC14IE5W<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _ADC14IE5W<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: ADC14IE5W) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn adc14ie5_0(self) -> &'a mut W {
|
|
self.variant(ADC14IE5W::ADC14IE5_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn adc14ie5_1(self) -> &'a mut W {
|
|
self.variant(ADC14IE5W::ADC14IE5_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 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 `ADC14IE6`"]
|
|
pub enum ADC14IE6W {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE6_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE6_1,
|
|
}
|
|
impl ADC14IE6W {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
ADC14IE6W::ADC14IE6_0 => false,
|
|
ADC14IE6W::ADC14IE6_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _ADC14IE6W<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _ADC14IE6W<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: ADC14IE6W) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn adc14ie6_0(self) -> &'a mut W {
|
|
self.variant(ADC14IE6W::ADC14IE6_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn adc14ie6_1(self) -> &'a mut W {
|
|
self.variant(ADC14IE6W::ADC14IE6_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 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 `ADC14IE7`"]
|
|
pub enum ADC14IE7W {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE7_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE7_1,
|
|
}
|
|
impl ADC14IE7W {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
ADC14IE7W::ADC14IE7_0 => false,
|
|
ADC14IE7W::ADC14IE7_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _ADC14IE7W<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _ADC14IE7W<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: ADC14IE7W) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn adc14ie7_0(self) -> &'a mut W {
|
|
self.variant(ADC14IE7W::ADC14IE7_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn adc14ie7_1(self) -> &'a mut W {
|
|
self.variant(ADC14IE7W::ADC14IE7_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 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 `ADC14IE8`"]
|
|
pub enum ADC14IE8W {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE8_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE8_1,
|
|
}
|
|
impl ADC14IE8W {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
ADC14IE8W::ADC14IE8_0 => false,
|
|
ADC14IE8W::ADC14IE8_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _ADC14IE8W<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _ADC14IE8W<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: ADC14IE8W) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn adc14ie8_0(self) -> &'a mut W {
|
|
self.variant(ADC14IE8W::ADC14IE8_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn adc14ie8_1(self) -> &'a mut W {
|
|
self.variant(ADC14IE8W::ADC14IE8_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 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 `ADC14IE9`"]
|
|
pub enum ADC14IE9W {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE9_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE9_1,
|
|
}
|
|
impl ADC14IE9W {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
ADC14IE9W::ADC14IE9_0 => false,
|
|
ADC14IE9W::ADC14IE9_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _ADC14IE9W<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _ADC14IE9W<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: ADC14IE9W) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn adc14ie9_0(self) -> &'a mut W {
|
|
self.variant(ADC14IE9W::ADC14IE9_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn adc14ie9_1(self) -> &'a mut W {
|
|
self.variant(ADC14IE9W::ADC14IE9_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 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 `ADC14IE10`"]
|
|
pub enum ADC14IE10W {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE10_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE10_1,
|
|
}
|
|
impl ADC14IE10W {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
ADC14IE10W::ADC14IE10_0 => false,
|
|
ADC14IE10W::ADC14IE10_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _ADC14IE10W<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _ADC14IE10W<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: ADC14IE10W) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn adc14ie10_0(self) -> &'a mut W {
|
|
self.variant(ADC14IE10W::ADC14IE10_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn adc14ie10_1(self) -> &'a mut W {
|
|
self.variant(ADC14IE10W::ADC14IE10_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 10;
|
|
self.w.bits &= !((MASK as u32) << OFFSET);
|
|
self.w.bits |= ((value & MASK) as u32) << OFFSET;
|
|
self.w
|
|
}
|
|
}
|
|
#[doc = "Values that can be written to the field `ADC14IE11`"]
|
|
pub enum ADC14IE11W {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE11_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE11_1,
|
|
}
|
|
impl ADC14IE11W {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
ADC14IE11W::ADC14IE11_0 => false,
|
|
ADC14IE11W::ADC14IE11_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _ADC14IE11W<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _ADC14IE11W<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: ADC14IE11W) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn adc14ie11_0(self) -> &'a mut W {
|
|
self.variant(ADC14IE11W::ADC14IE11_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn adc14ie11_1(self) -> &'a mut W {
|
|
self.variant(ADC14IE11W::ADC14IE11_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 11;
|
|
self.w.bits &= !((MASK as u32) << OFFSET);
|
|
self.w.bits |= ((value & MASK) as u32) << OFFSET;
|
|
self.w
|
|
}
|
|
}
|
|
#[doc = "Values that can be written to the field `ADC14IE12`"]
|
|
pub enum ADC14IE12W {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE12_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE12_1,
|
|
}
|
|
impl ADC14IE12W {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
ADC14IE12W::ADC14IE12_0 => false,
|
|
ADC14IE12W::ADC14IE12_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _ADC14IE12W<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _ADC14IE12W<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: ADC14IE12W) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn adc14ie12_0(self) -> &'a mut W {
|
|
self.variant(ADC14IE12W::ADC14IE12_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn adc14ie12_1(self) -> &'a mut W {
|
|
self.variant(ADC14IE12W::ADC14IE12_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 12;
|
|
self.w.bits &= !((MASK as u32) << OFFSET);
|
|
self.w.bits |= ((value & MASK) as u32) << OFFSET;
|
|
self.w
|
|
}
|
|
}
|
|
#[doc = "Values that can be written to the field `ADC14IE13`"]
|
|
pub enum ADC14IE13W {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE13_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE13_1,
|
|
}
|
|
impl ADC14IE13W {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
ADC14IE13W::ADC14IE13_0 => false,
|
|
ADC14IE13W::ADC14IE13_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _ADC14IE13W<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _ADC14IE13W<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: ADC14IE13W) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn adc14ie13_0(self) -> &'a mut W {
|
|
self.variant(ADC14IE13W::ADC14IE13_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn adc14ie13_1(self) -> &'a mut W {
|
|
self.variant(ADC14IE13W::ADC14IE13_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 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 `ADC14IE14`"]
|
|
pub enum ADC14IE14W {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE14_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE14_1,
|
|
}
|
|
impl ADC14IE14W {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
ADC14IE14W::ADC14IE14_0 => false,
|
|
ADC14IE14W::ADC14IE14_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _ADC14IE14W<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _ADC14IE14W<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: ADC14IE14W) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn adc14ie14_0(self) -> &'a mut W {
|
|
self.variant(ADC14IE14W::ADC14IE14_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn adc14ie14_1(self) -> &'a mut W {
|
|
self.variant(ADC14IE14W::ADC14IE14_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 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 `ADC14IE15`"]
|
|
pub enum ADC14IE15W {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE15_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE15_1,
|
|
}
|
|
impl ADC14IE15W {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
ADC14IE15W::ADC14IE15_0 => false,
|
|
ADC14IE15W::ADC14IE15_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _ADC14IE15W<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _ADC14IE15W<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: ADC14IE15W) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn adc14ie15_0(self) -> &'a mut W {
|
|
self.variant(ADC14IE15W::ADC14IE15_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn adc14ie15_1(self) -> &'a mut W {
|
|
self.variant(ADC14IE15W::ADC14IE15_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 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 `ADC14IE16`"]
|
|
pub enum ADC14IE16W {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE16_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE16_1,
|
|
}
|
|
impl ADC14IE16W {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
ADC14IE16W::ADC14IE16_0 => false,
|
|
ADC14IE16W::ADC14IE16_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _ADC14IE16W<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _ADC14IE16W<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: ADC14IE16W) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn adc14ie16_0(self) -> &'a mut W {
|
|
self.variant(ADC14IE16W::ADC14IE16_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn adc14ie16_1(self) -> &'a mut W {
|
|
self.variant(ADC14IE16W::ADC14IE16_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 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 `ADC14IE17`"]
|
|
pub enum ADC14IE17W {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE17_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE17_1,
|
|
}
|
|
impl ADC14IE17W {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
ADC14IE17W::ADC14IE17_0 => false,
|
|
ADC14IE17W::ADC14IE17_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _ADC14IE17W<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _ADC14IE17W<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: ADC14IE17W) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn adc14ie17_0(self) -> &'a mut W {
|
|
self.variant(ADC14IE17W::ADC14IE17_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn adc14ie17_1(self) -> &'a mut W {
|
|
self.variant(ADC14IE17W::ADC14IE17_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 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 `ADC14IE19`"]
|
|
pub enum ADC14IE19W {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE19_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE19_1,
|
|
}
|
|
impl ADC14IE19W {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
ADC14IE19W::ADC14IE19_0 => false,
|
|
ADC14IE19W::ADC14IE19_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _ADC14IE19W<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _ADC14IE19W<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: ADC14IE19W) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn adc14ie19_0(self) -> &'a mut W {
|
|
self.variant(ADC14IE19W::ADC14IE19_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn adc14ie19_1(self) -> &'a mut W {
|
|
self.variant(ADC14IE19W::ADC14IE19_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 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 `ADC14IE18`"]
|
|
pub enum ADC14IE18W {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE18_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE18_1,
|
|
}
|
|
impl ADC14IE18W {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
ADC14IE18W::ADC14IE18_0 => false,
|
|
ADC14IE18W::ADC14IE18_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _ADC14IE18W<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _ADC14IE18W<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: ADC14IE18W) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn adc14ie18_0(self) -> &'a mut W {
|
|
self.variant(ADC14IE18W::ADC14IE18_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn adc14ie18_1(self) -> &'a mut W {
|
|
self.variant(ADC14IE18W::ADC14IE18_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 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 `ADC14IE20`"]
|
|
pub enum ADC14IE20W {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE20_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE20_1,
|
|
}
|
|
impl ADC14IE20W {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
ADC14IE20W::ADC14IE20_0 => false,
|
|
ADC14IE20W::ADC14IE20_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _ADC14IE20W<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _ADC14IE20W<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: ADC14IE20W) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn adc14ie20_0(self) -> &'a mut W {
|
|
self.variant(ADC14IE20W::ADC14IE20_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn adc14ie20_1(self) -> &'a mut W {
|
|
self.variant(ADC14IE20W::ADC14IE20_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 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 `ADC14IE21`"]
|
|
pub enum ADC14IE21W {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE21_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE21_1,
|
|
}
|
|
impl ADC14IE21W {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
ADC14IE21W::ADC14IE21_0 => false,
|
|
ADC14IE21W::ADC14IE21_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _ADC14IE21W<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _ADC14IE21W<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: ADC14IE21W) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn adc14ie21_0(self) -> &'a mut W {
|
|
self.variant(ADC14IE21W::ADC14IE21_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn adc14ie21_1(self) -> &'a mut W {
|
|
self.variant(ADC14IE21W::ADC14IE21_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 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 `ADC14IE22`"]
|
|
pub enum ADC14IE22W {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE22_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE22_1,
|
|
}
|
|
impl ADC14IE22W {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
ADC14IE22W::ADC14IE22_0 => false,
|
|
ADC14IE22W::ADC14IE22_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _ADC14IE22W<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _ADC14IE22W<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: ADC14IE22W) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn adc14ie22_0(self) -> &'a mut W {
|
|
self.variant(ADC14IE22W::ADC14IE22_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn adc14ie22_1(self) -> &'a mut W {
|
|
self.variant(ADC14IE22W::ADC14IE22_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 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 `ADC14IE23`"]
|
|
pub enum ADC14IE23W {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE23_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE23_1,
|
|
}
|
|
impl ADC14IE23W {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
ADC14IE23W::ADC14IE23_0 => false,
|
|
ADC14IE23W::ADC14IE23_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _ADC14IE23W<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _ADC14IE23W<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: ADC14IE23W) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn adc14ie23_0(self) -> &'a mut W {
|
|
self.variant(ADC14IE23W::ADC14IE23_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn adc14ie23_1(self) -> &'a mut W {
|
|
self.variant(ADC14IE23W::ADC14IE23_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 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 `ADC14IE24`"]
|
|
pub enum ADC14IE24W {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE24_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE24_1,
|
|
}
|
|
impl ADC14IE24W {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
ADC14IE24W::ADC14IE24_0 => false,
|
|
ADC14IE24W::ADC14IE24_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _ADC14IE24W<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _ADC14IE24W<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: ADC14IE24W) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn adc14ie24_0(self) -> &'a mut W {
|
|
self.variant(ADC14IE24W::ADC14IE24_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn adc14ie24_1(self) -> &'a mut W {
|
|
self.variant(ADC14IE24W::ADC14IE24_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 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 `ADC14IE25`"]
|
|
pub enum ADC14IE25W {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE25_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE25_1,
|
|
}
|
|
impl ADC14IE25W {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
ADC14IE25W::ADC14IE25_0 => false,
|
|
ADC14IE25W::ADC14IE25_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _ADC14IE25W<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _ADC14IE25W<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: ADC14IE25W) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn adc14ie25_0(self) -> &'a mut W {
|
|
self.variant(ADC14IE25W::ADC14IE25_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn adc14ie25_1(self) -> &'a mut W {
|
|
self.variant(ADC14IE25W::ADC14IE25_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 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 `ADC14IE26`"]
|
|
pub enum ADC14IE26W {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE26_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE26_1,
|
|
}
|
|
impl ADC14IE26W {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
ADC14IE26W::ADC14IE26_0 => false,
|
|
ADC14IE26W::ADC14IE26_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _ADC14IE26W<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _ADC14IE26W<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: ADC14IE26W) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn adc14ie26_0(self) -> &'a mut W {
|
|
self.variant(ADC14IE26W::ADC14IE26_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn adc14ie26_1(self) -> &'a mut W {
|
|
self.variant(ADC14IE26W::ADC14IE26_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 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 `ADC14IE27`"]
|
|
pub enum ADC14IE27W {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE27_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE27_1,
|
|
}
|
|
impl ADC14IE27W {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
ADC14IE27W::ADC14IE27_0 => false,
|
|
ADC14IE27W::ADC14IE27_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _ADC14IE27W<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _ADC14IE27W<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: ADC14IE27W) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn adc14ie27_0(self) -> &'a mut W {
|
|
self.variant(ADC14IE27W::ADC14IE27_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn adc14ie27_1(self) -> &'a mut W {
|
|
self.variant(ADC14IE27W::ADC14IE27_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 27;
|
|
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 `ADC14IE28`"]
|
|
pub enum ADC14IE28W {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE28_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE28_1,
|
|
}
|
|
impl ADC14IE28W {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
ADC14IE28W::ADC14IE28_0 => false,
|
|
ADC14IE28W::ADC14IE28_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _ADC14IE28W<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _ADC14IE28W<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: ADC14IE28W) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn adc14ie28_0(self) -> &'a mut W {
|
|
self.variant(ADC14IE28W::ADC14IE28_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn adc14ie28_1(self) -> &'a mut W {
|
|
self.variant(ADC14IE28W::ADC14IE28_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 28;
|
|
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 `ADC14IE29`"]
|
|
pub enum ADC14IE29W {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE29_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE29_1,
|
|
}
|
|
impl ADC14IE29W {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
ADC14IE29W::ADC14IE29_0 => false,
|
|
ADC14IE29W::ADC14IE29_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _ADC14IE29W<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _ADC14IE29W<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: ADC14IE29W) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn adc14ie29_0(self) -> &'a mut W {
|
|
self.variant(ADC14IE29W::ADC14IE29_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn adc14ie29_1(self) -> &'a mut W {
|
|
self.variant(ADC14IE29W::ADC14IE29_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 29;
|
|
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 `ADC14IE30`"]
|
|
pub enum ADC14IE30W {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE30_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE30_1,
|
|
}
|
|
impl ADC14IE30W {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
ADC14IE30W::ADC14IE30_0 => false,
|
|
ADC14IE30W::ADC14IE30_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _ADC14IE30W<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _ADC14IE30W<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: ADC14IE30W) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn adc14ie30_0(self) -> &'a mut W {
|
|
self.variant(ADC14IE30W::ADC14IE30_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn adc14ie30_1(self) -> &'a mut W {
|
|
self.variant(ADC14IE30W::ADC14IE30_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 30;
|
|
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 `ADC14IE31`"]
|
|
pub enum ADC14IE31W {
|
|
#[doc = "Interrupt disabled"]
|
|
ADC14IE31_0,
|
|
#[doc = "Interrupt enabled"]
|
|
ADC14IE31_1,
|
|
}
|
|
impl ADC14IE31W {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
ADC14IE31W::ADC14IE31_0 => false,
|
|
ADC14IE31W::ADC14IE31_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _ADC14IE31W<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _ADC14IE31W<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: ADC14IE31W) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn adc14ie31_0(self) -> &'a mut W {
|
|
self.variant(ADC14IE31W::ADC14IE31_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn adc14ie31_1(self) -> &'a mut W {
|
|
self.variant(ADC14IE31W::ADC14IE31_1)
|
|
}
|
|
#[doc = r" Sets the field bit"]
|
|
pub fn set_bit(self) -> &'a mut W {
|
|
self.bit(true)
|
|
}
|
|
#[doc = r" Clears the field bit"]
|
|
pub fn clear_bit(self) -> &'a mut W {
|
|
self.bit(false)
|
|
}
|
|
#[doc = r" Writes raw bits to the field"]
|
|
#[inline]
|
|
pub fn bit(self, value: bool) -> &'a mut W {
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 31;
|
|
self.w.bits &= !((MASK as u32) << OFFSET);
|
|
self.w.bits |= ((value & MASK) as u32) << OFFSET;
|
|
self.w
|
|
}
|
|
}
|
|
impl R {
|
|
#[doc = r" Value of the register as raw bits"]
|
|
#[inline]
|
|
pub fn bits(&self) -> u32 {
|
|
self.bits
|
|
}
|
|
#[doc = "Bit 0 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie0(&self) -> ADC14IE0R {
|
|
ADC14IE0R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 0;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 1 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie1(&self) -> ADC14IE1R {
|
|
ADC14IE1R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 1;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 2 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie2(&self) -> ADC14IE2R {
|
|
ADC14IE2R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 2;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 3 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie3(&self) -> ADC14IE3R {
|
|
ADC14IE3R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 3;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 4 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie4(&self) -> ADC14IE4R {
|
|
ADC14IE4R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 4;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 5 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie5(&self) -> ADC14IE5R {
|
|
ADC14IE5R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 5;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 6 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie6(&self) -> ADC14IE6R {
|
|
ADC14IE6R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 6;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 7 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie7(&self) -> ADC14IE7R {
|
|
ADC14IE7R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 7;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 8 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie8(&self) -> ADC14IE8R {
|
|
ADC14IE8R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 8;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 9 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie9(&self) -> ADC14IE9R {
|
|
ADC14IE9R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 9;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 10 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie10(&self) -> ADC14IE10R {
|
|
ADC14IE10R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 10;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 11 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie11(&self) -> ADC14IE11R {
|
|
ADC14IE11R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 11;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 12 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie12(&self) -> ADC14IE12R {
|
|
ADC14IE12R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 12;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 13 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie13(&self) -> ADC14IE13R {
|
|
ADC14IE13R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 13;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 14 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie14(&self) -> ADC14IE14R {
|
|
ADC14IE14R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 14;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 15 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie15(&self) -> ADC14IE15R {
|
|
ADC14IE15R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 15;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 16 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie16(&self) -> ADC14IE16R {
|
|
ADC14IE16R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 16;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 17 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie17(&self) -> ADC14IE17R {
|
|
ADC14IE17R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 17;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 19 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie19(&self) -> ADC14IE19R {
|
|
ADC14IE19R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 19;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 18 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie18(&self) -> ADC14IE18R {
|
|
ADC14IE18R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 18;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 20 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie20(&self) -> ADC14IE20R {
|
|
ADC14IE20R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 20;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 21 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie21(&self) -> ADC14IE21R {
|
|
ADC14IE21R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 21;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 22 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie22(&self) -> ADC14IE22R {
|
|
ADC14IE22R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 22;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 23 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie23(&self) -> ADC14IE23R {
|
|
ADC14IE23R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 23;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 24 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie24(&self) -> ADC14IE24R {
|
|
ADC14IE24R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 24;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 25 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie25(&self) -> ADC14IE25R {
|
|
ADC14IE25R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 25;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 26 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie26(&self) -> ADC14IE26R {
|
|
ADC14IE26R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 26;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 27 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie27(&self) -> ADC14IE27R {
|
|
ADC14IE27R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 27;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 28 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie28(&self) -> ADC14IE28R {
|
|
ADC14IE28R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 28;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 29 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie29(&self) -> ADC14IE29R {
|
|
ADC14IE29R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 29;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 30 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie30(&self) -> ADC14IE30R {
|
|
ADC14IE30R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 30;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 31 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie31(&self) -> ADC14IE31R {
|
|
ADC14IE31R::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 31;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
}
|
|
impl W {
|
|
#[doc = r" Reset value of the register"]
|
|
#[inline]
|
|
pub fn reset_value() -> W {
|
|
W { bits: 0 }
|
|
}
|
|
#[doc = r" Writes raw bits to the register"]
|
|
#[inline]
|
|
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
|
self.bits = bits;
|
|
self
|
|
}
|
|
#[doc = "Bit 0 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie0(&mut self) -> _ADC14IE0W {
|
|
_ADC14IE0W { w: self }
|
|
}
|
|
#[doc = "Bit 1 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie1(&mut self) -> _ADC14IE1W {
|
|
_ADC14IE1W { w: self }
|
|
}
|
|
#[doc = "Bit 2 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie2(&mut self) -> _ADC14IE2W {
|
|
_ADC14IE2W { w: self }
|
|
}
|
|
#[doc = "Bit 3 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie3(&mut self) -> _ADC14IE3W {
|
|
_ADC14IE3W { w: self }
|
|
}
|
|
#[doc = "Bit 4 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie4(&mut self) -> _ADC14IE4W {
|
|
_ADC14IE4W { w: self }
|
|
}
|
|
#[doc = "Bit 5 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie5(&mut self) -> _ADC14IE5W {
|
|
_ADC14IE5W { w: self }
|
|
}
|
|
#[doc = "Bit 6 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie6(&mut self) -> _ADC14IE6W {
|
|
_ADC14IE6W { w: self }
|
|
}
|
|
#[doc = "Bit 7 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie7(&mut self) -> _ADC14IE7W {
|
|
_ADC14IE7W { w: self }
|
|
}
|
|
#[doc = "Bit 8 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie8(&mut self) -> _ADC14IE8W {
|
|
_ADC14IE8W { w: self }
|
|
}
|
|
#[doc = "Bit 9 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie9(&mut self) -> _ADC14IE9W {
|
|
_ADC14IE9W { w: self }
|
|
}
|
|
#[doc = "Bit 10 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie10(&mut self) -> _ADC14IE10W {
|
|
_ADC14IE10W { w: self }
|
|
}
|
|
#[doc = "Bit 11 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie11(&mut self) -> _ADC14IE11W {
|
|
_ADC14IE11W { w: self }
|
|
}
|
|
#[doc = "Bit 12 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie12(&mut self) -> _ADC14IE12W {
|
|
_ADC14IE12W { w: self }
|
|
}
|
|
#[doc = "Bit 13 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie13(&mut self) -> _ADC14IE13W {
|
|
_ADC14IE13W { w: self }
|
|
}
|
|
#[doc = "Bit 14 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie14(&mut self) -> _ADC14IE14W {
|
|
_ADC14IE14W { w: self }
|
|
}
|
|
#[doc = "Bit 15 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie15(&mut self) -> _ADC14IE15W {
|
|
_ADC14IE15W { w: self }
|
|
}
|
|
#[doc = "Bit 16 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie16(&mut self) -> _ADC14IE16W {
|
|
_ADC14IE16W { w: self }
|
|
}
|
|
#[doc = "Bit 17 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie17(&mut self) -> _ADC14IE17W {
|
|
_ADC14IE17W { w: self }
|
|
}
|
|
#[doc = "Bit 19 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie19(&mut self) -> _ADC14IE19W {
|
|
_ADC14IE19W { w: self }
|
|
}
|
|
#[doc = "Bit 18 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie18(&mut self) -> _ADC14IE18W {
|
|
_ADC14IE18W { w: self }
|
|
}
|
|
#[doc = "Bit 20 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie20(&mut self) -> _ADC14IE20W {
|
|
_ADC14IE20W { w: self }
|
|
}
|
|
#[doc = "Bit 21 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie21(&mut self) -> _ADC14IE21W {
|
|
_ADC14IE21W { w: self }
|
|
}
|
|
#[doc = "Bit 22 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie22(&mut self) -> _ADC14IE22W {
|
|
_ADC14IE22W { w: self }
|
|
}
|
|
#[doc = "Bit 23 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie23(&mut self) -> _ADC14IE23W {
|
|
_ADC14IE23W { w: self }
|
|
}
|
|
#[doc = "Bit 24 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie24(&mut self) -> _ADC14IE24W {
|
|
_ADC14IE24W { w: self }
|
|
}
|
|
#[doc = "Bit 25 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie25(&mut self) -> _ADC14IE25W {
|
|
_ADC14IE25W { w: self }
|
|
}
|
|
#[doc = "Bit 26 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie26(&mut self) -> _ADC14IE26W {
|
|
_ADC14IE26W { w: self }
|
|
}
|
|
#[doc = "Bit 27 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie27(&mut self) -> _ADC14IE27W {
|
|
_ADC14IE27W { w: self }
|
|
}
|
|
#[doc = "Bit 28 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie28(&mut self) -> _ADC14IE28W {
|
|
_ADC14IE28W { w: self }
|
|
}
|
|
#[doc = "Bit 29 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie29(&mut self) -> _ADC14IE29W {
|
|
_ADC14IE29W { w: self }
|
|
}
|
|
#[doc = "Bit 30 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie30(&mut self) -> _ADC14IE30W {
|
|
_ADC14IE30W { w: self }
|
|
}
|
|
#[doc = "Bit 31 - Interrupt enable"]
|
|
#[inline]
|
|
pub fn adc14ie31(&mut self) -> _ADC14IE31W {
|
|
_ADC14IE31W { w: self }
|
|
}
|
|
}
|