#[doc = "Reader of register EPC"]
pub type R = crate::R<u32, super::EPC>;
#[doc = "Writer for register EPC"]
pub type W = crate::W<u32, super::EPC>;
#[doc = "Register EPC `reset()`'s with value 0"]
impl crate::ResetValue for super::EPC {
type Type = u32;
#[inline(always)]
fn reset_value() -> Self::Type {
0
}
}
#[doc = "External Power Supply Enable Configuration\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(u8)]
pub enum EPEN_A {
#[doc = "0: Power Enable Active Low"]
LOW = 0,
#[doc = "1: Power Enable Active High"]
HIGH = 1,
#[doc = "2: Power Enable High if VBUS Low (OTG only)"]
VBLOW = 2,
#[doc = "3: Power Enable High if VBUS High (OTG only)"]
VBHIGH = 3,
}
impl From<EPEN_A> for u8 {
#[inline(always)]
fn from(variant: EPEN_A) -> Self {
variant as _
}
}
#[doc = "Reader of field `EPEN`"]
pub type EPEN_R = crate::R<u8, EPEN_A>;
impl EPEN_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> EPEN_A {
match self.bits {
0 => EPEN_A::LOW,
1 => EPEN_A::HIGH,
2 => EPEN_A::VBLOW,
3 => EPEN_A::VBHIGH,
_ => unreachable!(),
}
}
#[doc = "Checks if the value of the field is `LOW`"]
#[inline(always)]
pub fn is_low(&self) -> bool {
*self == EPEN_A::LOW
}
#[doc = "Checks if the value of the field is `HIGH`"]
#[inline(always)]
pub fn is_high(&self) -> bool {
*self == EPEN_A::HIGH
}
#[doc = "Checks if the value of the field is `VBLOW`"]
#[inline(always)]
pub fn is_vblow(&self) -> bool {
*self == EPEN_A::VBLOW
}
#[doc = "Checks if the value of the field is `VBHIGH`"]
#[inline(always)]
pub fn is_vbhigh(&self) -> bool {
*self == EPEN_A::VBHIGH
}
}
#[doc = "Write proxy for field `EPEN`"]
pub struct EPEN_W<'a> {
w: &'a mut W,
}
impl<'a> EPEN_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: EPEN_A) -> &'a mut W {
{
self.bits(variant.into())
}
}
#[doc = "Power Enable Active Low"]
#[inline(always)]
pub fn low(self) -> &'a mut W {
self.variant(EPEN_A::LOW)
}
#[doc = "Power Enable Active High"]
#[inline(always)]
pub fn high(self) -> &'a mut W {
self.variant(EPEN_A::HIGH)
}
#[doc = "Power Enable High if VBUS Low (OTG only)"]
#[inline(always)]
pub fn vblow(self) -> &'a mut W {
self.variant(EPEN_A::VBLOW)
}
#[doc = "Power Enable High if VBUS High (OTG only)"]
#[inline(always)]
pub fn vbhigh(self) -> &'a mut W {
self.variant(EPEN_A::VBHIGH)
}
#[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 & !0x03) | ((value as u32) & 0x03);
self.w
}
}
#[doc = "Reader of field `EPENDE`"]
pub type EPENDE_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `EPENDE`"]
pub struct EPENDE_W<'a> {
w: &'a mut W,
}
impl<'a> EPENDE_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 2)) | (((value as u32) & 0x01) << 2);
self.w
}
}
#[doc = "Reader of field `PFLTEN`"]
pub type PFLTEN_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `PFLTEN`"]
pub struct PFLTEN_W<'a> {
w: &'a mut W,
}
impl<'a> PFLTEN_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 4)) | (((value as u32) & 0x01) << 4);
self.w
}
}
#[doc = "Reader of field `PFLTSEN_HIGH`"]
pub type PFLTSEN_HIGH_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `PFLTSEN_HIGH`"]
pub struct PFLTSEN_HIGH_W<'a> {
w: &'a mut W,
}
impl<'a> PFLTSEN_HIGH_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 5)) | (((value as u32) & 0x01) << 5);
self.w
}
}
#[doc = "Reader of field `PFLTAEN`"]
pub type PFLTAEN_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `PFLTAEN`"]
pub struct PFLTAEN_W<'a> {
w: &'a mut W,
}
impl<'a> PFLTAEN_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 6)) | (((value as u32) & 0x01) << 6);
self.w
}
}
#[doc = "Power Fault Action\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(u8)]
pub enum PFLTACT_A {
#[doc = "0: Unchanged"]
UNCHG = 0,
#[doc = "1: Tristate"]
TRIS = 1,
#[doc = "2: Low"]
LOW = 2,
#[doc = "3: High"]
HIGH = 3,
}
impl From<PFLTACT_A> for u8 {
#[inline(always)]
fn from(variant: PFLTACT_A) -> Self {
variant as _
}
}
#[doc = "Reader of field `PFLTACT`"]
pub type PFLTACT_R = crate::R<u8, PFLTACT_A>;
impl PFLTACT_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> PFLTACT_A {
match self.bits {
0 => PFLTACT_A::UNCHG,
1 => PFLTACT_A::TRIS,
2 => PFLTACT_A::LOW,
3 => PFLTACT_A::HIGH,
_ => unreachable!(),
}
}
#[doc = "Checks if the value of the field is `UNCHG`"]
#[inline(always)]
pub fn is_unchg(&self) -> bool {
*self == PFLTACT_A::UNCHG
}
#[doc = "Checks if the value of the field is `TRIS`"]
#[inline(always)]
pub fn is_tris(&self) -> bool {
*self == PFLTACT_A::TRIS
}
#[doc = "Checks if the value of the field is `LOW`"]
#[inline(always)]
pub fn is_low(&self) -> bool {
*self == PFLTACT_A::LOW
}
#[doc = "Checks if the value of the field is `HIGH`"]
#[inline(always)]
pub fn is_high(&self) -> bool {
*self == PFLTACT_A::HIGH
}
}
#[doc = "Write proxy for field `PFLTACT`"]
pub struct PFLTACT_W<'a> {
w: &'a mut W,
}
impl<'a> PFLTACT_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: PFLTACT_A) -> &'a mut W {
{
self.bits(variant.into())
}
}
#[doc = "Unchanged"]
#[inline(always)]
pub fn unchg(self) -> &'a mut W {
self.variant(PFLTACT_A::UNCHG)
}
#[doc = "Tristate"]
#[inline(always)]
pub fn tris(self) -> &'a mut W {
self.variant(PFLTACT_A::TRIS)
}
#[doc = "Low"]
#[inline(always)]
pub fn low(self) -> &'a mut W {
self.variant(PFLTACT_A::LOW)
}
#[doc = "High"]
#[inline(always)]
pub fn high(self) -> &'a mut W {
self.variant(PFLTACT_A::HIGH)
}
#[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 & !(0x03 << 8)) | (((value as u32) & 0x03) << 8);
self.w
}
}
impl R {
#[doc = "Bits 0:1 - External Power Supply Enable Configuration"]
#[inline(always)]
pub fn epen(&self) -> EPEN_R {
EPEN_R::new((self.bits & 0x03) as u8)
}
#[doc = "Bit 2 - EPEN Drive Enable"]
#[inline(always)]
pub fn epende(&self) -> EPENDE_R {
EPENDE_R::new(((self.bits >> 2) & 0x01) != 0)
}
#[doc = "Bit 4 - Power Fault Input Enable"]
#[inline(always)]
pub fn pflten(&self) -> PFLTEN_R {
PFLTEN_R::new(((self.bits >> 4) & 0x01) != 0)
}
#[doc = "Bit 5 - Power Fault Sense"]
#[inline(always)]
pub fn pfltsen_high(&self) -> PFLTSEN_HIGH_R {
PFLTSEN_HIGH_R::new(((self.bits >> 5) & 0x01) != 0)
}
#[doc = "Bit 6 - Power Fault Action Enable"]
#[inline(always)]
pub fn pfltaen(&self) -> PFLTAEN_R {
PFLTAEN_R::new(((self.bits >> 6) & 0x01) != 0)
}
#[doc = "Bits 8:9 - Power Fault Action"]
#[inline(always)]
pub fn pfltact(&self) -> PFLTACT_R {
PFLTACT_R::new(((self.bits >> 8) & 0x03) as u8)
}
}
impl W {
#[doc = "Bits 0:1 - External Power Supply Enable Configuration"]
#[inline(always)]
pub fn epen(&mut self) -> EPEN_W {
EPEN_W { w: self }
}
#[doc = "Bit 2 - EPEN Drive Enable"]
#[inline(always)]
pub fn epende(&mut self) -> EPENDE_W {
EPENDE_W { w: self }
}
#[doc = "Bit 4 - Power Fault Input Enable"]
#[inline(always)]
pub fn pflten(&mut self) -> PFLTEN_W {
PFLTEN_W { w: self }
}
#[doc = "Bit 5 - Power Fault Sense"]
#[inline(always)]
pub fn pfltsen_high(&mut self) -> PFLTSEN_HIGH_W {
PFLTSEN_HIGH_W { w: self }
}
#[doc = "Bit 6 - Power Fault Action Enable"]
#[inline(always)]
pub fn pfltaen(&mut self) -> PFLTAEN_W {
PFLTAEN_W { w: self }
}
#[doc = "Bits 8:9 - Power Fault Action"]
#[inline(always)]
pub fn pfltact(&mut self) -> PFLTACT_W {
PFLTACT_W { w: self }
}
}