#[doc = "Reader of register MR"]
pub type R = crate::R<u32, super::MR>;
#[doc = "Writer for register MR"]
pub type W = crate::W<u32, super::MR>;
#[doc = "Register MR `reset()`'s with value 0"]
impl crate::ResetValue for super::MR {
type Type = u32;
#[inline(always)]
fn reset_value() -> Self::Type {
0
}
}
#[doc = "Trigger Enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TRGEN_A {
#[doc = "0: External trigger mode disabled. DACC in free-running mode."]
DIS = 0,
#[doc = "1: External trigger mode enabled."]
EN = 1,
}
impl From<TRGEN_A> for bool {
#[inline(always)]
fn from(variant: TRGEN_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `TRGEN`"]
pub type TRGEN_R = crate::R<bool, TRGEN_A>;
impl TRGEN_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> TRGEN_A {
match self.bits {
false => TRGEN_A::DIS,
true => TRGEN_A::EN,
}
}
#[doc = "Checks if the value of the field is `DIS`"]
#[inline(always)]
pub fn is_dis(&self) -> bool {
*self == TRGEN_A::DIS
}
#[doc = "Checks if the value of the field is `EN`"]
#[inline(always)]
pub fn is_en(&self) -> bool {
*self == TRGEN_A::EN
}
}
#[doc = "Write proxy for field `TRGEN`"]
pub struct TRGEN_W<'a> {
w: &'a mut W,
}
impl<'a> TRGEN_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: TRGEN_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "External trigger mode disabled. DACC in free-running mode."]
#[inline(always)]
pub fn dis(self) -> &'a mut W {
self.variant(TRGEN_A::DIS)
}
#[doc = "External trigger mode enabled."]
#[inline(always)]
pub fn en(self) -> &'a mut W {
self.variant(TRGEN_A::EN)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !0x01) | ((value as u32) & 0x01);
self.w
}
}
#[doc = "Trigger Selection\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(u8)]
pub enum TRGSEL_A {
#[doc = "0: External trigger"]
TRGSEL0 = 0,
#[doc = "1: TIO Output of the Timer Counter Channel 0"]
TRGSEL1 = 1,
#[doc = "2: TIO Output of the Timer Counter Channel 1"]
TRGSEL2 = 2,
#[doc = "3: TIO Output of the Timer Counter Channel 2"]
TRGSEL3 = 3,
#[doc = "4: PWM Event Line 0"]
TRGSEL4 = 4,
#[doc = "5: PWM Event Line 1"]
TRGSEL5 = 5,
}
impl From<TRGSEL_A> for u8 {
#[inline(always)]
fn from(variant: TRGSEL_A) -> Self {
variant as _
}
}
#[doc = "Reader of field `TRGSEL`"]
pub type TRGSEL_R = crate::R<u8, TRGSEL_A>;
impl TRGSEL_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> crate::Variant<u8, TRGSEL_A> {
use crate::Variant::*;
match self.bits {
0 => Val(TRGSEL_A::TRGSEL0),
1 => Val(TRGSEL_A::TRGSEL1),
2 => Val(TRGSEL_A::TRGSEL2),
3 => Val(TRGSEL_A::TRGSEL3),
4 => Val(TRGSEL_A::TRGSEL4),
5 => Val(TRGSEL_A::TRGSEL5),
i => Res(i),
}
}
#[doc = "Checks if the value of the field is `TRGSEL0`"]
#[inline(always)]
pub fn is_trgsel0(&self) -> bool {
*self == TRGSEL_A::TRGSEL0
}
#[doc = "Checks if the value of the field is `TRGSEL1`"]
#[inline(always)]
pub fn is_trgsel1(&self) -> bool {
*self == TRGSEL_A::TRGSEL1
}
#[doc = "Checks if the value of the field is `TRGSEL2`"]
#[inline(always)]
pub fn is_trgsel2(&self) -> bool {
*self == TRGSEL_A::TRGSEL2
}
#[doc = "Checks if the value of the field is `TRGSEL3`"]
#[inline(always)]
pub fn is_trgsel3(&self) -> bool {
*self == TRGSEL_A::TRGSEL3
}
#[doc = "Checks if the value of the field is `TRGSEL4`"]
#[inline(always)]
pub fn is_trgsel4(&self) -> bool {
*self == TRGSEL_A::TRGSEL4
}
#[doc = "Checks if the value of the field is `TRGSEL5`"]
#[inline(always)]
pub fn is_trgsel5(&self) -> bool {
*self == TRGSEL_A::TRGSEL5
}
}
#[doc = "Write proxy for field `TRGSEL`"]
pub struct TRGSEL_W<'a> {
w: &'a mut W,
}
impl<'a> TRGSEL_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: TRGSEL_A) -> &'a mut W {
unsafe { self.bits(variant.into()) }
}
#[doc = "External trigger"]
#[inline(always)]
pub fn trgsel0(self) -> &'a mut W {
self.variant(TRGSEL_A::TRGSEL0)
}
#[doc = "TIO Output of the Timer Counter Channel 0"]
#[inline(always)]
pub fn trgsel1(self) -> &'a mut W {
self.variant(TRGSEL_A::TRGSEL1)
}
#[doc = "TIO Output of the Timer Counter Channel 1"]
#[inline(always)]
pub fn trgsel2(self) -> &'a mut W {
self.variant(TRGSEL_A::TRGSEL2)
}
#[doc = "TIO Output of the Timer Counter Channel 2"]
#[inline(always)]
pub fn trgsel3(self) -> &'a mut W {
self.variant(TRGSEL_A::TRGSEL3)
}
#[doc = "PWM Event Line 0"]
#[inline(always)]
pub fn trgsel4(self) -> &'a mut W {
self.variant(TRGSEL_A::TRGSEL4)
}
#[doc = "PWM Event Line 1"]
#[inline(always)]
pub fn trgsel5(self) -> &'a mut W {
self.variant(TRGSEL_A::TRGSEL5)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x07 << 1)) | (((value as u32) & 0x07) << 1);
self.w
}
}
#[doc = "Word Transfer\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum WORD_A {
#[doc = "0: Half-word transfer"]
HALF = 0,
#[doc = "1: Word transfer"]
WORD = 1,
}
impl From<WORD_A> for bool {
#[inline(always)]
fn from(variant: WORD_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `WORD`"]
pub type WORD_R = crate::R<bool, WORD_A>;
impl WORD_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> WORD_A {
match self.bits {
false => WORD_A::HALF,
true => WORD_A::WORD,
}
}
#[doc = "Checks if the value of the field is `HALF`"]
#[inline(always)]
pub fn is_half(&self) -> bool {
*self == WORD_A::HALF
}
#[doc = "Checks if the value of the field is `WORD`"]
#[inline(always)]
pub fn is_word(&self) -> bool {
*self == WORD_A::WORD
}
}
#[doc = "Write proxy for field `WORD`"]
pub struct WORD_W<'a> {
w: &'a mut W,
}
impl<'a> WORD_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: WORD_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Half-word transfer"]
#[inline(always)]
pub fn half(self) -> &'a mut W {
self.variant(WORD_A::HALF)
}
#[doc = "Word transfer"]
#[inline(always)]
pub fn word(self) -> &'a mut W {
self.variant(WORD_A::WORD)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 4)) | (((value as u32) & 0x01) << 4);
self.w
}
}
#[doc = "Sleep Mode\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum SLEEP_A {
#[doc = "0: Normal mode: the DAC core and reference voltage circuitry are kept ON between conversions."]
DISABLED = 0,
#[doc = "1: Sleep mode: the DAC core and/or reference voltage circuitry are OFF between conversions."]
ENABLED = 1,
}
impl From<SLEEP_A> for bool {
#[inline(always)]
fn from(variant: SLEEP_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `SLEEP`"]
pub type SLEEP_R = crate::R<bool, SLEEP_A>;
impl SLEEP_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> SLEEP_A {
match self.bits {
false => SLEEP_A::DISABLED,
true => SLEEP_A::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == SLEEP_A::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == SLEEP_A::ENABLED
}
}
#[doc = "Write proxy for field `SLEEP`"]
pub struct SLEEP_W<'a> {
w: &'a mut W,
}
impl<'a> SLEEP_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: SLEEP_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Normal mode: the DAC core and reference voltage circuitry are kept ON between conversions."]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(SLEEP_A::DISABLED)
}
#[doc = "Sleep mode: the DAC core and/or reference voltage circuitry are OFF between conversions."]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(SLEEP_A::ENABLED)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 5)) | (((value as u32) & 0x01) << 5);
self.w
}
}
#[doc = "Fast Wake-up Mode\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum FASTWKUP_A {
#[doc = "0: Normal sleep mode: the sleep mode is defined by the SLEEP bit. Voltage reference is OFF between conversions."]
STAMODE = 0,
#[doc = "1: Fast wake-up after sleep mode: voltage reference is kept ON between conversions; DAC core is OFF"]
FASTWAKEUP = 1,
}
impl From<FASTWKUP_A> for bool {
#[inline(always)]
fn from(variant: FASTWKUP_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `FASTWKUP`"]
pub type FASTWKUP_R = crate::R<bool, FASTWKUP_A>;
impl FASTWKUP_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> FASTWKUP_A {
match self.bits {
false => FASTWKUP_A::STAMODE,
true => FASTWKUP_A::FASTWAKEUP,
}
}
#[doc = "Checks if the value of the field is `STAMODE`"]
#[inline(always)]
pub fn is_stamode(&self) -> bool {
*self == FASTWKUP_A::STAMODE
}
#[doc = "Checks if the value of the field is `FASTWAKEUP`"]
#[inline(always)]
pub fn is_fastwakeup(&self) -> bool {
*self == FASTWKUP_A::FASTWAKEUP
}
}
#[doc = "Write proxy for field `FASTWKUP`"]
pub struct FASTWKUP_W<'a> {
w: &'a mut W,
}
impl<'a> FASTWKUP_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: FASTWKUP_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Normal sleep mode: the sleep mode is defined by the SLEEP bit. Voltage reference is OFF between conversions."]
#[inline(always)]
pub fn stamode(self) -> &'a mut W {
self.variant(FASTWKUP_A::STAMODE)
}
#[doc = "Fast wake-up after sleep mode: voltage reference is kept ON between conversions; DAC core is OFF"]
#[inline(always)]
pub fn fastwakeup(self) -> &'a mut W {
self.variant(FASTWKUP_A::FASTWAKEUP)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 6)) | (((value as u32) & 0x01) << 6);
self.w
}
}
#[doc = "Reader of field `REFRESH`"]
pub type REFRESH_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `REFRESH`"]
pub struct REFRESH_W<'a> {
w: &'a mut W,
}
impl<'a> REFRESH_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0xff << 8)) | (((value as u32) & 0xff) << 8);
self.w
}
}
#[doc = "User Channel Selection\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(u8)]
pub enum USER_SEL_A {
#[doc = "0: Channel 0"]
CHANNEL0 = 0,
#[doc = "1: Channel 1"]
CHANNEL1 = 1,
}
impl From<USER_SEL_A> for u8 {
#[inline(always)]
fn from(variant: USER_SEL_A) -> Self {
variant as _
}
}
#[doc = "Reader of field `USER_SEL`"]
pub type USER_SEL_R = crate::R<u8, USER_SEL_A>;
impl USER_SEL_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> crate::Variant<u8, USER_SEL_A> {
use crate::Variant::*;
match self.bits {
0 => Val(USER_SEL_A::CHANNEL0),
1 => Val(USER_SEL_A::CHANNEL1),
i => Res(i),
}
}
#[doc = "Checks if the value of the field is `CHANNEL0`"]
#[inline(always)]
pub fn is_channel0(&self) -> bool {
*self == USER_SEL_A::CHANNEL0
}
#[doc = "Checks if the value of the field is `CHANNEL1`"]
#[inline(always)]
pub fn is_channel1(&self) -> bool {
*self == USER_SEL_A::CHANNEL1
}
}
#[doc = "Write proxy for field `USER_SEL`"]
pub struct USER_SEL_W<'a> {
w: &'a mut W,
}
impl<'a> USER_SEL_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: USER_SEL_A) -> &'a mut W {
unsafe { self.bits(variant.into()) }
}
#[doc = "Channel 0"]
#[inline(always)]
pub fn channel0(self) -> &'a mut W {
self.variant(USER_SEL_A::CHANNEL0)
}
#[doc = "Channel 1"]
#[inline(always)]
pub fn channel1(self) -> &'a mut W {
self.variant(USER_SEL_A::CHANNEL1)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x03 << 16)) | (((value as u32) & 0x03) << 16);
self.w
}
}
#[doc = "Tag Selection Mode\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TAG_A {
#[doc = "0: Tag selection mode disabled. Using USER_SEL to select the channel for the conversion."]
DIS = 0,
#[doc = "1: Tag selection mode enabled"]
EN = 1,
}
impl From<TAG_A> for bool {
#[inline(always)]
fn from(variant: TAG_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `TAG`"]
pub type TAG_R = crate::R<bool, TAG_A>;
impl TAG_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> TAG_A {
match self.bits {
false => TAG_A::DIS,
true => TAG_A::EN,
}
}
#[doc = "Checks if the value of the field is `DIS`"]
#[inline(always)]
pub fn is_dis(&self) -> bool {
*self == TAG_A::DIS
}
#[doc = "Checks if the value of the field is `EN`"]
#[inline(always)]
pub fn is_en(&self) -> bool {
*self == TAG_A::EN
}
}
#[doc = "Write proxy for field `TAG`"]
pub struct TAG_W<'a> {
w: &'a mut W,
}
impl<'a> TAG_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: TAG_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Tag selection mode disabled. Using USER_SEL to select the channel for the conversion."]
#[inline(always)]
pub fn dis(self) -> &'a mut W {
self.variant(TAG_A::DIS)
}
#[doc = "Tag selection mode enabled"]
#[inline(always)]
pub fn en(self) -> &'a mut W {
self.variant(TAG_A::EN)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 20)) | (((value as u32) & 0x01) << 20);
self.w
}
}
#[doc = "Max Speed Mode\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum MAXS_A {
#[doc = "0: Normal mode"]
NORMAL = 0,
#[doc = "1: Maximum speed mode enabled"]
MAXIMUM = 1,
}
impl From<MAXS_A> for bool {
#[inline(always)]
fn from(variant: MAXS_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `MAXS`"]
pub type MAXS_R = crate::R<bool, MAXS_A>;
impl MAXS_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> MAXS_A {
match self.bits {
false => MAXS_A::NORMAL,
true => MAXS_A::MAXIMUM,
}
}
#[doc = "Checks if the value of the field is `NORMAL`"]
#[inline(always)]
pub fn is_normal(&self) -> bool {
*self == MAXS_A::NORMAL
}
#[doc = "Checks if the value of the field is `MAXIMUM`"]
#[inline(always)]
pub fn is_maximum(&self) -> bool {
*self == MAXS_A::MAXIMUM
}
}
#[doc = "Write proxy for field `MAXS`"]
pub struct MAXS_W<'a> {
w: &'a mut W,
}
impl<'a> MAXS_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: MAXS_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Normal mode"]
#[inline(always)]
pub fn normal(self) -> &'a mut W {
self.variant(MAXS_A::NORMAL)
}
#[doc = "Maximum speed mode enabled"]
#[inline(always)]
pub fn maximum(self) -> &'a mut W {
self.variant(MAXS_A::MAXIMUM)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 21)) | (((value as u32) & 0x01) << 21);
self.w
}
}
#[doc = "Startup Time Selection\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(u8)]
pub enum STARTUP_A {
#[doc = "0: 0 periods of DACClock"]
_0 = 0,
#[doc = "1: 8 periods of DACClock"]
_8 = 1,
#[doc = "2: 16 periods of DACClock"]
_16 = 2,
#[doc = "3: 24 periods of DACClock"]
_24 = 3,
#[doc = "4: 64 periods of DACClock"]
_64 = 4,
#[doc = "5: 80 periods of DACClock"]
_80 = 5,
#[doc = "6: 96 periods of DACClock"]
_96 = 6,
#[doc = "7: 112 periods of DACClock"]
_112 = 7,
#[doc = "8: 512 periods of DACClock"]
_512 = 8,
#[doc = "9: 576 periods of DACClock"]
_576 = 9,
#[doc = "10: 640 periods of DACClock"]
_640 = 10,
#[doc = "11: 704 periods of DACClock"]
_704 = 11,
#[doc = "12: 768 periods of DACClock"]
_768 = 12,
#[doc = "13: 832 periods of DACClock"]
_832 = 13,
#[doc = "14: 896 periods of DACClock"]
_896 = 14,
#[doc = "15: 960 periods of DACClock"]
_960 = 15,
#[doc = "16: 1024 periods of DACClock"]
_1024 = 16,
#[doc = "17: 1088 periods of DACClock"]
_1088 = 17,
#[doc = "18: 1152 periods of DACClock"]
_1152 = 18,
#[doc = "19: 1216 periods of DACClock"]
_1216 = 19,
#[doc = "20: 1280 periods of DACClock"]
_1280 = 20,
#[doc = "21: 1344 periods of DACClock"]
_1344 = 21,
#[doc = "22: 1408 periods of DACClock"]
_1408 = 22,
#[doc = "23: 1472 periods of DACClock"]
_1472 = 23,
#[doc = "24: 1536 periods of DACClock"]
_1536 = 24,
#[doc = "25: 1600 periods of DACClock"]
_1600 = 25,
#[doc = "26: 1664 periods of DACClock"]
_1664 = 26,
#[doc = "27: 1728 periods of DACClock"]
_1728 = 27,
#[doc = "28: 1792 periods of DACClock"]
_1792 = 28,
#[doc = "29: 1856 periods of DACClock"]
_1856 = 29,
#[doc = "30: 1920 periods of DACClock"]
_1920 = 30,
#[doc = "31: 1984 periods of DACClock"]
_1984 = 31,
#[doc = "32: 2048 periods of DACClock"]
_2048 = 32,
#[doc = "33: 2112 periods of DACClock"]
_2112 = 33,
#[doc = "34: 2176 periods of DACClock"]
_2176 = 34,
#[doc = "35: 2240 periods of DACClock"]
_2240 = 35,
#[doc = "36: 2304 periods of DACClock"]
_2304 = 36,
#[doc = "37: 2368 periods of DACClock"]
_2368 = 37,
#[doc = "38: 2432 periods of DACClock"]
_2432 = 38,
#[doc = "39: 2496 periods of DACClock"]
_2496 = 39,
#[doc = "40: 2560 periods of DACClock"]
_2560 = 40,
#[doc = "41: 2624 periods of DACClock"]
_2624 = 41,
#[doc = "42: 2688 periods of DACClock"]
_2688 = 42,
#[doc = "43: 2752 periods of DACClock"]
_2752 = 43,
#[doc = "44: 2816 periods of DACClock"]
_2816 = 44,
#[doc = "45: 2880 periods of DACClock"]
_2880 = 45,
#[doc = "46: 2944 periods of DACClock"]
_2944 = 46,
#[doc = "47: 3008 periods of DACClock"]
_3008 = 47,
#[doc = "48: 3072 periods of DACClock"]
_3072 = 48,
#[doc = "49: 3136 periods of DACClock"]
_3136 = 49,
#[doc = "50: 3200 periods of DACClock"]
_3200 = 50,
#[doc = "51: 3264 periods of DACClock"]
_3264 = 51,
#[doc = "52: 3328 periods of DACClock"]
_3328 = 52,
#[doc = "53: 3392 periods of DACClock"]
_3392 = 53,
#[doc = "54: 3456 periods of DACClock"]
_3456 = 54,
#[doc = "55: 3520 periods of DACClock"]
_3520 = 55,
#[doc = "56: 3584 periods of DACClock"]
_3584 = 56,
#[doc = "57: 3648 periods of DACClock"]
_3648 = 57,
#[doc = "58: 3712 periods of DACClock"]
_3712 = 58,
#[doc = "59: 3776 periods of DACClock"]
_3776 = 59,
#[doc = "60: 3840 periods of DACClock"]
_3840 = 60,
#[doc = "61: 3904 periods of DACClock"]
_3904 = 61,
#[doc = "62: 3968 periods of DACClock"]
_3968 = 62,
#[doc = "63: 4032 periods of DACClock"]
_4032 = 63,
}
impl From<STARTUP_A> for u8 {
#[inline(always)]
fn from(variant: STARTUP_A) -> Self {
variant as _
}
}
#[doc = "Reader of field `STARTUP`"]
pub type STARTUP_R = crate::R<u8, STARTUP_A>;
impl STARTUP_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> STARTUP_A {
match self.bits {
0 => STARTUP_A::_0,
1 => STARTUP_A::_8,
2 => STARTUP_A::_16,
3 => STARTUP_A::_24,
4 => STARTUP_A::_64,
5 => STARTUP_A::_80,
6 => STARTUP_A::_96,
7 => STARTUP_A::_112,
8 => STARTUP_A::_512,
9 => STARTUP_A::_576,
10 => STARTUP_A::_640,
11 => STARTUP_A::_704,
12 => STARTUP_A::_768,
13 => STARTUP_A::_832,
14 => STARTUP_A::_896,
15 => STARTUP_A::_960,
16 => STARTUP_A::_1024,
17 => STARTUP_A::_1088,
18 => STARTUP_A::_1152,
19 => STARTUP_A::_1216,
20 => STARTUP_A::_1280,
21 => STARTUP_A::_1344,
22 => STARTUP_A::_1408,
23 => STARTUP_A::_1472,
24 => STARTUP_A::_1536,
25 => STARTUP_A::_1600,
26 => STARTUP_A::_1664,
27 => STARTUP_A::_1728,
28 => STARTUP_A::_1792,
29 => STARTUP_A::_1856,
30 => STARTUP_A::_1920,
31 => STARTUP_A::_1984,
32 => STARTUP_A::_2048,
33 => STARTUP_A::_2112,
34 => STARTUP_A::_2176,
35 => STARTUP_A::_2240,
36 => STARTUP_A::_2304,
37 => STARTUP_A::_2368,
38 => STARTUP_A::_2432,
39 => STARTUP_A::_2496,
40 => STARTUP_A::_2560,
41 => STARTUP_A::_2624,
42 => STARTUP_A::_2688,
43 => STARTUP_A::_2752,
44 => STARTUP_A::_2816,
45 => STARTUP_A::_2880,
46 => STARTUP_A::_2944,
47 => STARTUP_A::_3008,
48 => STARTUP_A::_3072,
49 => STARTUP_A::_3136,
50 => STARTUP_A::_3200,
51 => STARTUP_A::_3264,
52 => STARTUP_A::_3328,
53 => STARTUP_A::_3392,
54 => STARTUP_A::_3456,
55 => STARTUP_A::_3520,
56 => STARTUP_A::_3584,
57 => STARTUP_A::_3648,
58 => STARTUP_A::_3712,
59 => STARTUP_A::_3776,
60 => STARTUP_A::_3840,
61 => STARTUP_A::_3904,
62 => STARTUP_A::_3968,
63 => STARTUP_A::_4032,
_ => unreachable!(),
}
}
#[doc = "Checks if the value of the field is `_0`"]
#[inline(always)]
pub fn is_0(&self) -> bool {
*self == STARTUP_A::_0
}
#[doc = "Checks if the value of the field is `_8`"]
#[inline(always)]
pub fn is_8(&self) -> bool {
*self == STARTUP_A::_8
}
#[doc = "Checks if the value of the field is `_16`"]
#[inline(always)]
pub fn is_16(&self) -> bool {
*self == STARTUP_A::_16
}
#[doc = "Checks if the value of the field is `_24`"]
#[inline(always)]
pub fn is_24(&self) -> bool {
*self == STARTUP_A::_24
}
#[doc = "Checks if the value of the field is `_64`"]
#[inline(always)]
pub fn is_64(&self) -> bool {
*self == STARTUP_A::_64
}
#[doc = "Checks if the value of the field is `_80`"]
#[inline(always)]
pub fn is_80(&self) -> bool {
*self == STARTUP_A::_80
}
#[doc = "Checks if the value of the field is `_96`"]
#[inline(always)]
pub fn is_96(&self) -> bool {
*self == STARTUP_A::_96
}
#[doc = "Checks if the value of the field is `_112`"]
#[inline(always)]
pub fn is_112(&self) -> bool {
*self == STARTUP_A::_112
}
#[doc = "Checks if the value of the field is `_512`"]
#[inline(always)]
pub fn is_512(&self) -> bool {
*self == STARTUP_A::_512
}
#[doc = "Checks if the value of the field is `_576`"]
#[inline(always)]
pub fn is_576(&self) -> bool {
*self == STARTUP_A::_576
}
#[doc = "Checks if the value of the field is `_640`"]
#[inline(always)]
pub fn is_640(&self) -> bool {
*self == STARTUP_A::_640
}
#[doc = "Checks if the value of the field is `_704`"]
#[inline(always)]
pub fn is_704(&self) -> bool {
*self == STARTUP_A::_704
}
#[doc = "Checks if the value of the field is `_768`"]
#[inline(always)]
pub fn is_768(&self) -> bool {
*self == STARTUP_A::_768
}
#[doc = "Checks if the value of the field is `_832`"]
#[inline(always)]
pub fn is_832(&self) -> bool {
*self == STARTUP_A::_832
}
#[doc = "Checks if the value of the field is `_896`"]
#[inline(always)]
pub fn is_896(&self) -> bool {
*self == STARTUP_A::_896
}
#[doc = "Checks if the value of the field is `_960`"]
#[inline(always)]
pub fn is_960(&self) -> bool {
*self == STARTUP_A::_960
}
#[doc = "Checks if the value of the field is `_1024`"]
#[inline(always)]
pub fn is_1024(&self) -> bool {
*self == STARTUP_A::_1024
}
#[doc = "Checks if the value of the field is `_1088`"]
#[inline(always)]
pub fn is_1088(&self) -> bool {
*self == STARTUP_A::_1088
}
#[doc = "Checks if the value of the field is `_1152`"]
#[inline(always)]
pub fn is_1152(&self) -> bool {
*self == STARTUP_A::_1152
}
#[doc = "Checks if the value of the field is `_1216`"]
#[inline(always)]
pub fn is_1216(&self) -> bool {
*self == STARTUP_A::_1216
}
#[doc = "Checks if the value of the field is `_1280`"]
#[inline(always)]
pub fn is_1280(&self) -> bool {
*self == STARTUP_A::_1280
}
#[doc = "Checks if the value of the field is `_1344`"]
#[inline(always)]
pub fn is_1344(&self) -> bool {
*self == STARTUP_A::_1344
}
#[doc = "Checks if the value of the field is `_1408`"]
#[inline(always)]
pub fn is_1408(&self) -> bool {
*self == STARTUP_A::_1408
}
#[doc = "Checks if the value of the field is `_1472`"]
#[inline(always)]
pub fn is_1472(&self) -> bool {
*self == STARTUP_A::_1472
}
#[doc = "Checks if the value of the field is `_1536`"]
#[inline(always)]
pub fn is_1536(&self) -> bool {
*self == STARTUP_A::_1536
}
#[doc = "Checks if the value of the field is `_1600`"]
#[inline(always)]
pub fn is_1600(&self) -> bool {
*self == STARTUP_A::_1600
}
#[doc = "Checks if the value of the field is `_1664`"]
#[inline(always)]
pub fn is_1664(&self) -> bool {
*self == STARTUP_A::_1664
}
#[doc = "Checks if the value of the field is `_1728`"]
#[inline(always)]
pub fn is_1728(&self) -> bool {
*self == STARTUP_A::_1728
}
#[doc = "Checks if the value of the field is `_1792`"]
#[inline(always)]
pub fn is_1792(&self) -> bool {
*self == STARTUP_A::_1792
}
#[doc = "Checks if the value of the field is `_1856`"]
#[inline(always)]
pub fn is_1856(&self) -> bool {
*self == STARTUP_A::_1856
}
#[doc = "Checks if the value of the field is `_1920`"]
#[inline(always)]
pub fn is_1920(&self) -> bool {
*self == STARTUP_A::_1920
}
#[doc = "Checks if the value of the field is `_1984`"]
#[inline(always)]
pub fn is_1984(&self) -> bool {
*self == STARTUP_A::_1984
}
#[doc = "Checks if the value of the field is `_2048`"]
#[inline(always)]
pub fn is_2048(&self) -> bool {
*self == STARTUP_A::_2048
}
#[doc = "Checks if the value of the field is `_2112`"]
#[inline(always)]
pub fn is_2112(&self) -> bool {
*self == STARTUP_A::_2112
}
#[doc = "Checks if the value of the field is `_2176`"]
#[inline(always)]
pub fn is_2176(&self) -> bool {
*self == STARTUP_A::_2176
}
#[doc = "Checks if the value of the field is `_2240`"]
#[inline(always)]
pub fn is_2240(&self) -> bool {
*self == STARTUP_A::_2240
}
#[doc = "Checks if the value of the field is `_2304`"]
#[inline(always)]
pub fn is_2304(&self) -> bool {
*self == STARTUP_A::_2304
}
#[doc = "Checks if the value of the field is `_2368`"]
#[inline(always)]
pub fn is_2368(&self) -> bool {
*self == STARTUP_A::_2368
}
#[doc = "Checks if the value of the field is `_2432`"]
#[inline(always)]
pub fn is_2432(&self) -> bool {
*self == STARTUP_A::_2432
}
#[doc = "Checks if the value of the field is `_2496`"]
#[inline(always)]
pub fn is_2496(&self) -> bool {
*self == STARTUP_A::_2496
}
#[doc = "Checks if the value of the field is `_2560`"]
#[inline(always)]
pub fn is_2560(&self) -> bool {
*self == STARTUP_A::_2560
}
#[doc = "Checks if the value of the field is `_2624`"]
#[inline(always)]
pub fn is_2624(&self) -> bool {
*self == STARTUP_A::_2624
}
#[doc = "Checks if the value of the field is `_2688`"]
#[inline(always)]
pub fn is_2688(&self) -> bool {
*self == STARTUP_A::_2688
}
#[doc = "Checks if the value of the field is `_2752`"]
#[inline(always)]
pub fn is_2752(&self) -> bool {
*self == STARTUP_A::_2752
}
#[doc = "Checks if the value of the field is `_2816`"]
#[inline(always)]
pub fn is_2816(&self) -> bool {
*self == STARTUP_A::_2816
}
#[doc = "Checks if the value of the field is `_2880`"]
#[inline(always)]
pub fn is_2880(&self) -> bool {
*self == STARTUP_A::_2880
}
#[doc = "Checks if the value of the field is `_2944`"]
#[inline(always)]
pub fn is_2944(&self) -> bool {
*self == STARTUP_A::_2944
}
#[doc = "Checks if the value of the field is `_3008`"]
#[inline(always)]
pub fn is_3008(&self) -> bool {
*self == STARTUP_A::_3008
}
#[doc = "Checks if the value of the field is `_3072`"]
#[inline(always)]
pub fn is_3072(&self) -> bool {
*self == STARTUP_A::_3072
}
#[doc = "Checks if the value of the field is `_3136`"]
#[inline(always)]
pub fn is_3136(&self) -> bool {
*self == STARTUP_A::_3136
}
#[doc = "Checks if the value of the field is `_3200`"]
#[inline(always)]
pub fn is_3200(&self) -> bool {
*self == STARTUP_A::_3200
}
#[doc = "Checks if the value of the field is `_3264`"]
#[inline(always)]
pub fn is_3264(&self) -> bool {
*self == STARTUP_A::_3264
}
#[doc = "Checks if the value of the field is `_3328`"]
#[inline(always)]
pub fn is_3328(&self) -> bool {
*self == STARTUP_A::_3328
}
#[doc = "Checks if the value of the field is `_3392`"]
#[inline(always)]
pub fn is_3392(&self) -> bool {
*self == STARTUP_A::_3392
}
#[doc = "Checks if the value of the field is `_3456`"]
#[inline(always)]
pub fn is_3456(&self) -> bool {
*self == STARTUP_A::_3456
}
#[doc = "Checks if the value of the field is `_3520`"]
#[inline(always)]
pub fn is_3520(&self) -> bool {
*self == STARTUP_A::_3520
}
#[doc = "Checks if the value of the field is `_3584`"]
#[inline(always)]
pub fn is_3584(&self) -> bool {
*self == STARTUP_A::_3584
}
#[doc = "Checks if the value of the field is `_3648`"]
#[inline(always)]
pub fn is_3648(&self) -> bool {
*self == STARTUP_A::_3648
}
#[doc = "Checks if the value of the field is `_3712`"]
#[inline(always)]
pub fn is_3712(&self) -> bool {
*self == STARTUP_A::_3712
}
#[doc = "Checks if the value of the field is `_3776`"]
#[inline(always)]
pub fn is_3776(&self) -> bool {
*self == STARTUP_A::_3776
}
#[doc = "Checks if the value of the field is `_3840`"]
#[inline(always)]
pub fn is_3840(&self) -> bool {
*self == STARTUP_A::_3840
}
#[doc = "Checks if the value of the field is `_3904`"]
#[inline(always)]
pub fn is_3904(&self) -> bool {
*self == STARTUP_A::_3904
}
#[doc = "Checks if the value of the field is `_3968`"]
#[inline(always)]
pub fn is_3968(&self) -> bool {
*self == STARTUP_A::_3968
}
#[doc = "Checks if the value of the field is `_4032`"]
#[inline(always)]
pub fn is_4032(&self) -> bool {
*self == STARTUP_A::_4032
}
}
#[doc = "Write proxy for field `STARTUP`"]
pub struct STARTUP_W<'a> {
w: &'a mut W,
}
impl<'a> STARTUP_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: STARTUP_A) -> &'a mut W {
{
self.bits(variant.into())
}
}
#[doc = "0 periods of DACClock"]
#[inline(always)]
pub fn _0(self) -> &'a mut W {
self.variant(STARTUP_A::_0)
}
#[doc = "8 periods of DACClock"]
#[inline(always)]
pub fn _8(self) -> &'a mut W {
self.variant(STARTUP_A::_8)
}
#[doc = "16 periods of DACClock"]
#[inline(always)]
pub fn _16(self) -> &'a mut W {
self.variant(STARTUP_A::_16)
}
#[doc = "24 periods of DACClock"]
#[inline(always)]
pub fn _24(self) -> &'a mut W {
self.variant(STARTUP_A::_24)
}
#[doc = "64 periods of DACClock"]
#[inline(always)]
pub fn _64(self) -> &'a mut W {
self.variant(STARTUP_A::_64)
}
#[doc = "80 periods of DACClock"]
#[inline(always)]
pub fn _80(self) -> &'a mut W {
self.variant(STARTUP_A::_80)
}
#[doc = "96 periods of DACClock"]
#[inline(always)]
pub fn _96(self) -> &'a mut W {
self.variant(STARTUP_A::_96)
}
#[doc = "112 periods of DACClock"]
#[inline(always)]
pub fn _112(self) -> &'a mut W {
self.variant(STARTUP_A::_112)
}
#[doc = "512 periods of DACClock"]
#[inline(always)]
pub fn _512(self) -> &'a mut W {
self.variant(STARTUP_A::_512)
}
#[doc = "576 periods of DACClock"]
#[inline(always)]
pub fn _576(self) -> &'a mut W {
self.variant(STARTUP_A::_576)
}
#[doc = "640 periods of DACClock"]
#[inline(always)]
pub fn _640(self) -> &'a mut W {
self.variant(STARTUP_A::_640)
}
#[doc = "704 periods of DACClock"]
#[inline(always)]
pub fn _704(self) -> &'a mut W {
self.variant(STARTUP_A::_704)
}
#[doc = "768 periods of DACClock"]
#[inline(always)]
pub fn _768(self) -> &'a mut W {
self.variant(STARTUP_A::_768)
}
#[doc = "832 periods of DACClock"]
#[inline(always)]
pub fn _832(self) -> &'a mut W {
self.variant(STARTUP_A::_832)
}
#[doc = "896 periods of DACClock"]
#[inline(always)]
pub fn _896(self) -> &'a mut W {
self.variant(STARTUP_A::_896)
}
#[doc = "960 periods of DACClock"]
#[inline(always)]
pub fn _960(self) -> &'a mut W {
self.variant(STARTUP_A::_960)
}
#[doc = "1024 periods of DACClock"]
#[inline(always)]
pub fn _1024(self) -> &'a mut W {
self.variant(STARTUP_A::_1024)
}
#[doc = "1088 periods of DACClock"]
#[inline(always)]
pub fn _1088(self) -> &'a mut W {
self.variant(STARTUP_A::_1088)
}
#[doc = "1152 periods of DACClock"]
#[inline(always)]
pub fn _1152(self) -> &'a mut W {
self.variant(STARTUP_A::_1152)
}
#[doc = "1216 periods of DACClock"]
#[inline(always)]
pub fn _1216(self) -> &'a mut W {
self.variant(STARTUP_A::_1216)
}
#[doc = "1280 periods of DACClock"]
#[inline(always)]
pub fn _1280(self) -> &'a mut W {
self.variant(STARTUP_A::_1280)
}
#[doc = "1344 periods of DACClock"]
#[inline(always)]
pub fn _1344(self) -> &'a mut W {
self.variant(STARTUP_A::_1344)
}
#[doc = "1408 periods of DACClock"]
#[inline(always)]
pub fn _1408(self) -> &'a mut W {
self.variant(STARTUP_A::_1408)
}
#[doc = "1472 periods of DACClock"]
#[inline(always)]
pub fn _1472(self) -> &'a mut W {
self.variant(STARTUP_A::_1472)
}
#[doc = "1536 periods of DACClock"]
#[inline(always)]
pub fn _1536(self) -> &'a mut W {
self.variant(STARTUP_A::_1536)
}
#[doc = "1600 periods of DACClock"]
#[inline(always)]
pub fn _1600(self) -> &'a mut W {
self.variant(STARTUP_A::_1600)
}
#[doc = "1664 periods of DACClock"]
#[inline(always)]
pub fn _1664(self) -> &'a mut W {
self.variant(STARTUP_A::_1664)
}
#[doc = "1728 periods of DACClock"]
#[inline(always)]
pub fn _1728(self) -> &'a mut W {
self.variant(STARTUP_A::_1728)
}
#[doc = "1792 periods of DACClock"]
#[inline(always)]
pub fn _1792(self) -> &'a mut W {
self.variant(STARTUP_A::_1792)
}
#[doc = "1856 periods of DACClock"]
#[inline(always)]
pub fn _1856(self) -> &'a mut W {
self.variant(STARTUP_A::_1856)
}
#[doc = "1920 periods of DACClock"]
#[inline(always)]
pub fn _1920(self) -> &'a mut W {
self.variant(STARTUP_A::_1920)
}
#[doc = "1984 periods of DACClock"]
#[inline(always)]
pub fn _1984(self) -> &'a mut W {
self.variant(STARTUP_A::_1984)
}
#[doc = "2048 periods of DACClock"]
#[inline(always)]
pub fn _2048(self) -> &'a mut W {
self.variant(STARTUP_A::_2048)
}
#[doc = "2112 periods of DACClock"]
#[inline(always)]
pub fn _2112(self) -> &'a mut W {
self.variant(STARTUP_A::_2112)
}
#[doc = "2176 periods of DACClock"]
#[inline(always)]
pub fn _2176(self) -> &'a mut W {
self.variant(STARTUP_A::_2176)
}
#[doc = "2240 periods of DACClock"]
#[inline(always)]
pub fn _2240(self) -> &'a mut W {
self.variant(STARTUP_A::_2240)
}
#[doc = "2304 periods of DACClock"]
#[inline(always)]
pub fn _2304(self) -> &'a mut W {
self.variant(STARTUP_A::_2304)
}
#[doc = "2368 periods of DACClock"]
#[inline(always)]
pub fn _2368(self) -> &'a mut W {
self.variant(STARTUP_A::_2368)
}
#[doc = "2432 periods of DACClock"]
#[inline(always)]
pub fn _2432(self) -> &'a mut W {
self.variant(STARTUP_A::_2432)
}
#[doc = "2496 periods of DACClock"]
#[inline(always)]
pub fn _2496(self) -> &'a mut W {
self.variant(STARTUP_A::_2496)
}
#[doc = "2560 periods of DACClock"]
#[inline(always)]
pub fn _2560(self) -> &'a mut W {
self.variant(STARTUP_A::_2560)
}
#[doc = "2624 periods of DACClock"]
#[inline(always)]
pub fn _2624(self) -> &'a mut W {
self.variant(STARTUP_A::_2624)
}
#[doc = "2688 periods of DACClock"]
#[inline(always)]
pub fn _2688(self) -> &'a mut W {
self.variant(STARTUP_A::_2688)
}
#[doc = "2752 periods of DACClock"]
#[inline(always)]
pub fn _2752(self) -> &'a mut W {
self.variant(STARTUP_A::_2752)
}
#[doc = "2816 periods of DACClock"]
#[inline(always)]
pub fn _2816(self) -> &'a mut W {
self.variant(STARTUP_A::_2816)
}
#[doc = "2880 periods of DACClock"]
#[inline(always)]
pub fn _2880(self) -> &'a mut W {
self.variant(STARTUP_A::_2880)
}
#[doc = "2944 periods of DACClock"]
#[inline(always)]
pub fn _2944(self) -> &'a mut W {
self.variant(STARTUP_A::_2944)
}
#[doc = "3008 periods of DACClock"]
#[inline(always)]
pub fn _3008(self) -> &'a mut W {
self.variant(STARTUP_A::_3008)
}
#[doc = "3072 periods of DACClock"]
#[inline(always)]
pub fn _3072(self) -> &'a mut W {
self.variant(STARTUP_A::_3072)
}
#[doc = "3136 periods of DACClock"]
#[inline(always)]
pub fn _3136(self) -> &'a mut W {
self.variant(STARTUP_A::_3136)
}
#[doc = "3200 periods of DACClock"]
#[inline(always)]
pub fn _3200(self) -> &'a mut W {
self.variant(STARTUP_A::_3200)
}
#[doc = "3264 periods of DACClock"]
#[inline(always)]
pub fn _3264(self) -> &'a mut W {
self.variant(STARTUP_A::_3264)
}
#[doc = "3328 periods of DACClock"]
#[inline(always)]
pub fn _3328(self) -> &'a mut W {
self.variant(STARTUP_A::_3328)
}
#[doc = "3392 periods of DACClock"]
#[inline(always)]
pub fn _3392(self) -> &'a mut W {
self.variant(STARTUP_A::_3392)
}
#[doc = "3456 periods of DACClock"]
#[inline(always)]
pub fn _3456(self) -> &'a mut W {
self.variant(STARTUP_A::_3456)
}
#[doc = "3520 periods of DACClock"]
#[inline(always)]
pub fn _3520(self) -> &'a mut W {
self.variant(STARTUP_A::_3520)
}
#[doc = "3584 periods of DACClock"]
#[inline(always)]
pub fn _3584(self) -> &'a mut W {
self.variant(STARTUP_A::_3584)
}
#[doc = "3648 periods of DACClock"]
#[inline(always)]
pub fn _3648(self) -> &'a mut W {
self.variant(STARTUP_A::_3648)
}
#[doc = "3712 periods of DACClock"]
#[inline(always)]
pub fn _3712(self) -> &'a mut W {
self.variant(STARTUP_A::_3712)
}
#[doc = "3776 periods of DACClock"]
#[inline(always)]
pub fn _3776(self) -> &'a mut W {
self.variant(STARTUP_A::_3776)
}
#[doc = "3840 periods of DACClock"]
#[inline(always)]
pub fn _3840(self) -> &'a mut W {
self.variant(STARTUP_A::_3840)
}
#[doc = "3904 periods of DACClock"]
#[inline(always)]
pub fn _3904(self) -> &'a mut W {
self.variant(STARTUP_A::_3904)
}
#[doc = "3968 periods of DACClock"]
#[inline(always)]
pub fn _3968(self) -> &'a mut W {
self.variant(STARTUP_A::_3968)
}
#[doc = "4032 periods of DACClock"]
#[inline(always)]
pub fn _4032(self) -> &'a mut W {
self.variant(STARTUP_A::_4032)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x3f << 24)) | (((value as u32) & 0x3f) << 24);
self.w
}
}
impl R {
#[doc = "Bit 0 - Trigger Enable"]
#[inline(always)]
pub fn trgen(&self) -> TRGEN_R {
TRGEN_R::new((self.bits & 0x01) != 0)
}
#[doc = "Bits 1:3 - Trigger Selection"]
#[inline(always)]
pub fn trgsel(&self) -> TRGSEL_R {
TRGSEL_R::new(((self.bits >> 1) & 0x07) as u8)
}
#[doc = "Bit 4 - Word Transfer"]
#[inline(always)]
pub fn word(&self) -> WORD_R {
WORD_R::new(((self.bits >> 4) & 0x01) != 0)
}
#[doc = "Bit 5 - Sleep Mode"]
#[inline(always)]
pub fn sleep(&self) -> SLEEP_R {
SLEEP_R::new(((self.bits >> 5) & 0x01) != 0)
}
#[doc = "Bit 6 - Fast Wake-up Mode"]
#[inline(always)]
pub fn fastwkup(&self) -> FASTWKUP_R {
FASTWKUP_R::new(((self.bits >> 6) & 0x01) != 0)
}
#[doc = "Bits 8:15 - Automatic Refresh Period"]
#[inline(always)]
pub fn refresh(&self) -> REFRESH_R {
REFRESH_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 16:17 - User Channel Selection"]
#[inline(always)]
pub fn user_sel(&self) -> USER_SEL_R {
USER_SEL_R::new(((self.bits >> 16) & 0x03) as u8)
}
#[doc = "Bit 20 - Tag Selection Mode"]
#[inline(always)]
pub fn tag(&self) -> TAG_R {
TAG_R::new(((self.bits >> 20) & 0x01) != 0)
}
#[doc = "Bit 21 - Max Speed Mode"]
#[inline(always)]
pub fn maxs(&self) -> MAXS_R {
MAXS_R::new(((self.bits >> 21) & 0x01) != 0)
}
#[doc = "Bits 24:29 - Startup Time Selection"]
#[inline(always)]
pub fn startup(&self) -> STARTUP_R {
STARTUP_R::new(((self.bits >> 24) & 0x3f) as u8)
}
}
impl W {
#[doc = "Bit 0 - Trigger Enable"]
#[inline(always)]
pub fn trgen(&mut self) -> TRGEN_W {
TRGEN_W { w: self }
}
#[doc = "Bits 1:3 - Trigger Selection"]
#[inline(always)]
pub fn trgsel(&mut self) -> TRGSEL_W {
TRGSEL_W { w: self }
}
#[doc = "Bit 4 - Word Transfer"]
#[inline(always)]
pub fn word(&mut self) -> WORD_W {
WORD_W { w: self }
}
#[doc = "Bit 5 - Sleep Mode"]
#[inline(always)]
pub fn sleep(&mut self) -> SLEEP_W {
SLEEP_W { w: self }
}
#[doc = "Bit 6 - Fast Wake-up Mode"]
#[inline(always)]
pub fn fastwkup(&mut self) -> FASTWKUP_W {
FASTWKUP_W { w: self }
}
#[doc = "Bits 8:15 - Automatic Refresh Period"]
#[inline(always)]
pub fn refresh(&mut self) -> REFRESH_W {
REFRESH_W { w: self }
}
#[doc = "Bits 16:17 - User Channel Selection"]
#[inline(always)]
pub fn user_sel(&mut self) -> USER_SEL_W {
USER_SEL_W { w: self }
}
#[doc = "Bit 20 - Tag Selection Mode"]
#[inline(always)]
pub fn tag(&mut self) -> TAG_W {
TAG_W { w: self }
}
#[doc = "Bit 21 - Max Speed Mode"]
#[inline(always)]
pub fn maxs(&mut self) -> MAXS_W {
MAXS_W { w: self }
}
#[doc = "Bits 24:29 - Startup Time Selection"]
#[inline(always)]
pub fn startup(&mut self) -> STARTUP_W {
STARTUP_W { w: self }
}
}