#[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::CSR {
#[doc = r"Modifies the contents of the register"]
#[inline(always)]
pub fn modify<F>(&self, f: F)
where
for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
{
let bits = self.register.get();
self.register.set(f(&R { bits }, &mut W { bits }).bits);
}
#[doc = r"Reads the contents of the register"]
#[inline(always)]
pub fn read(&self) -> R {
R {
bits: self.register.get(),
}
}
#[doc = r"Writes to the register"]
#[inline(always)]
pub fn write<F>(&self, f: F)
where
F: FnOnce(&mut W) -> &mut W,
{
self.register.set(
f(&mut W {
bits: Self::reset_value(),
})
.bits,
);
}
#[doc = r"Reset value of the register"]
#[inline(always)]
pub const fn reset_value() -> u32 {
0x0c00_0000
}
#[doc = r"Writes the reset value to the register"]
#[inline(always)]
pub fn reset(&self) {
self.register.set(Self::reset_value())
}
}
#[doc = "Possible values of the field `LSION`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum LSIONR {
#[doc = "LSI oscillator Off"]
OFF,
#[doc = "LSI oscillator On"]
ON,
}
impl LSIONR {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
LSIONR::OFF => false,
LSIONR::ON => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> LSIONR {
match value {
false => LSIONR::OFF,
true => LSIONR::ON,
}
}
#[doc = "Checks if the value of the field is `OFF`"]
#[inline(always)]
pub fn is_off(&self) -> bool {
*self == LSIONR::OFF
}
#[doc = "Checks if the value of the field is `ON`"]
#[inline(always)]
pub fn is_on(&self) -> bool {
*self == LSIONR::ON
}
}
#[doc = "Values that can be written to the field `LSION`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum LSIONW {
#[doc = "LSI oscillator Off"]
OFF,
#[doc = "LSI oscillator On"]
ON,
}
impl LSIONW {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _bits(&self) -> bool {
match *self {
LSIONW::OFF => false,
LSIONW::ON => true,
}
}
}
#[doc = r"Proxy"]
pub struct _LSIONW<'a> {
w: &'a mut W,
}
impl<'a> _LSIONW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: LSIONW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "LSI oscillator Off"]
#[inline(always)]
pub fn off(self) -> &'a mut W {
self.variant(LSIONW::OFF)
}
#[doc = "LSI oscillator On"]
#[inline(always)]
pub fn on(self) -> &'a mut W {
self.variant(LSIONW::ON)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 0);
self.w.bits |= ((value as u32) & 0x01) << 0;
self.w
}
}
#[doc = "Possible values of the field `LSIRDY`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum LSIRDYR {
#[doc = "LSI oscillator not ready"]
NOTREADY,
#[doc = "LSI oscillator ready"]
READY,
}
impl LSIRDYR {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
LSIRDYR::NOTREADY => false,
LSIRDYR::READY => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> LSIRDYR {
match value {
false => LSIRDYR::NOTREADY,
true => LSIRDYR::READY,
}
}
#[doc = "Checks if the value of the field is `NOTREADY`"]
#[inline(always)]
pub fn is_not_ready(&self) -> bool {
*self == LSIRDYR::NOTREADY
}
#[doc = "Checks if the value of the field is `READY`"]
#[inline(always)]
pub fn is_ready(&self) -> bool {
*self == LSIRDYR::READY
}
}
#[doc = "Possible values of the field `RMVF`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum RMVFR {
#[doc = "Clears the reset flag"]
CLEAR,
#[doc = r"Reserved"]
_Reserved(bool),
}
impl RMVFR {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
RMVFR::CLEAR => true,
RMVFR::_Reserved(bits) => bits,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> RMVFR {
match value {
true => RMVFR::CLEAR,
i => RMVFR::_Reserved(i),
}
}
#[doc = "Checks if the value of the field is `CLEAR`"]
#[inline(always)]
pub fn is_clear(&self) -> bool {
*self == RMVFR::CLEAR
}
}
#[doc = "Values that can be written to the field `RMVF`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum RMVFW {
#[doc = "Clears the reset flag"]
CLEAR,
}
impl RMVFW {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _bits(&self) -> bool {
match *self {
RMVFW::CLEAR => true,
}
}
}
#[doc = r"Proxy"]
pub struct _RMVFW<'a> {
w: &'a mut W,
}
impl<'a> _RMVFW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: RMVFW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clears the reset flag"]
#[inline(always)]
pub fn clear(self) -> &'a mut W {
self.variant(RMVFW::CLEAR)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 24);
self.w.bits |= ((value as u32) & 0x01) << 24;
self.w
}
}
#[doc = "Possible values of the field `OBLRSTF`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum OBLRSTFR {
#[doc = "No reset has occured"]
NORESET,
#[doc = "A reset has occured"]
RESET,
}
impl OBLRSTFR {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
OBLRSTFR::NORESET => false,
OBLRSTFR::RESET => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> OBLRSTFR {
match value {
false => OBLRSTFR::NORESET,
true => OBLRSTFR::RESET,
}
}
#[doc = "Checks if the value of the field is `NORESET`"]
#[inline(always)]
pub fn is_no_reset(&self) -> bool {
*self == OBLRSTFR::NORESET
}
#[doc = "Checks if the value of the field is `RESET`"]
#[inline(always)]
pub fn is_reset(&self) -> bool {
*self == OBLRSTFR::RESET
}
}
#[doc = "Values that can be written to the field `OBLRSTF`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum OBLRSTFW {
#[doc = "No reset has occured"]
NORESET,
#[doc = "A reset has occured"]
RESET,
}
impl OBLRSTFW {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _bits(&self) -> bool {
match *self {
OBLRSTFW::NORESET => false,
OBLRSTFW::RESET => true,
}
}
}
#[doc = r"Proxy"]
pub struct _OBLRSTFW<'a> {
w: &'a mut W,
}
impl<'a> _OBLRSTFW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: OBLRSTFW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "No reset has occured"]
#[inline(always)]
pub fn no_reset(self) -> &'a mut W {
self.variant(OBLRSTFW::NORESET)
}
#[doc = "A reset has occured"]
#[inline(always)]
pub fn reset(self) -> &'a mut W {
self.variant(OBLRSTFW::RESET)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 25);
self.w.bits |= ((value as u32) & 0x01) << 25;
self.w
}
}
#[doc = "Possible values of the field `PINRSTF`"]
pub type PINRSTFR = OBLRSTFR;
#[doc = "Values that can be written to the field `PINRSTF`"]
pub type PINRSTFW = OBLRSTFW;
#[doc = r"Proxy"]
pub struct _PINRSTFW<'a> {
w: &'a mut W,
}
impl<'a> _PINRSTFW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: PINRSTFW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "No reset has occured"]
#[inline(always)]
pub fn no_reset(self) -> &'a mut W {
self.variant(OBLRSTFW::NORESET)
}
#[doc = "A reset has occured"]
#[inline(always)]
pub fn reset(self) -> &'a mut W {
self.variant(OBLRSTFW::RESET)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 26);
self.w.bits |= ((value as u32) & 0x01) << 26;
self.w
}
}
#[doc = "Possible values of the field `PORRSTF`"]
pub type PORRSTFR = OBLRSTFR;
#[doc = "Values that can be written to the field `PORRSTF`"]
pub type PORRSTFW = OBLRSTFW;
#[doc = r"Proxy"]
pub struct _PORRSTFW<'a> {
w: &'a mut W,
}
impl<'a> _PORRSTFW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: PORRSTFW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "No reset has occured"]
#[inline(always)]
pub fn no_reset(self) -> &'a mut W {
self.variant(OBLRSTFW::NORESET)
}
#[doc = "A reset has occured"]
#[inline(always)]
pub fn reset(self) -> &'a mut W {
self.variant(OBLRSTFW::RESET)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 27);
self.w.bits |= ((value as u32) & 0x01) << 27;
self.w
}
}
#[doc = "Possible values of the field `SFTRSTF`"]
pub type SFTRSTFR = OBLRSTFR;
#[doc = "Values that can be written to the field `SFTRSTF`"]
pub type SFTRSTFW = OBLRSTFW;
#[doc = r"Proxy"]
pub struct _SFTRSTFW<'a> {
w: &'a mut W,
}
impl<'a> _SFTRSTFW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: SFTRSTFW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "No reset has occured"]
#[inline(always)]
pub fn no_reset(self) -> &'a mut W {
self.variant(OBLRSTFW::NORESET)
}
#[doc = "A reset has occured"]
#[inline(always)]
pub fn reset(self) -> &'a mut W {
self.variant(OBLRSTFW::RESET)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 28);
self.w.bits |= ((value as u32) & 0x01) << 28;
self.w
}
}
#[doc = "Possible values of the field `IWDGRSTF`"]
pub type IWDGRSTFR = OBLRSTFR;
#[doc = "Values that can be written to the field `IWDGRSTF`"]
pub type IWDGRSTFW = OBLRSTFW;
#[doc = r"Proxy"]
pub struct _IWDGRSTFW<'a> {
w: &'a mut W,
}
impl<'a> _IWDGRSTFW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: IWDGRSTFW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "No reset has occured"]
#[inline(always)]
pub fn no_reset(self) -> &'a mut W {
self.variant(OBLRSTFW::NORESET)
}
#[doc = "A reset has occured"]
#[inline(always)]
pub fn reset(self) -> &'a mut W {
self.variant(OBLRSTFW::RESET)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 29);
self.w.bits |= ((value as u32) & 0x01) << 29;
self.w
}
}
#[doc = "Possible values of the field `WWDGRSTF`"]
pub type WWDGRSTFR = OBLRSTFR;
#[doc = "Values that can be written to the field `WWDGRSTF`"]
pub type WWDGRSTFW = OBLRSTFW;
#[doc = r"Proxy"]
pub struct _WWDGRSTFW<'a> {
w: &'a mut W,
}
impl<'a> _WWDGRSTFW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: WWDGRSTFW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "No reset has occured"]
#[inline(always)]
pub fn no_reset(self) -> &'a mut W {
self.variant(OBLRSTFW::NORESET)
}
#[doc = "A reset has occured"]
#[inline(always)]
pub fn reset(self) -> &'a mut W {
self.variant(OBLRSTFW::RESET)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 30);
self.w.bits |= ((value as u32) & 0x01) << 30;
self.w
}
}
#[doc = "Possible values of the field `LPWRRSTF`"]
pub type LPWRRSTFR = OBLRSTFR;
#[doc = "Values that can be written to the field `LPWRRSTF`"]
pub type LPWRRSTFW = OBLRSTFW;
#[doc = r"Proxy"]
pub struct _LPWRRSTFW<'a> {
w: &'a mut W,
}
impl<'a> _LPWRRSTFW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: LPWRRSTFW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "No reset has occured"]
#[inline(always)]
pub fn no_reset(self) -> &'a mut W {
self.variant(OBLRSTFW::NORESET)
}
#[doc = "A reset has occured"]
#[inline(always)]
pub fn reset(self) -> &'a mut W {
self.variant(OBLRSTFW::RESET)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 31);
self.w.bits |= ((value as u32) & 0x01) << 31;
self.w
}
}
#[doc = "Possible values of the field `V18PWRRSTF`"]
pub type V18PWRRSTFR = OBLRSTFR;
#[doc = "Values that can be written to the field `V18PWRRSTF`"]
pub type V18PWRRSTFW = OBLRSTFW;
#[doc = r"Proxy"]
pub struct _V18PWRRSTFW<'a> {
w: &'a mut W,
}
impl<'a> _V18PWRRSTFW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: V18PWRRSTFW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "No reset has occured"]
#[inline(always)]
pub fn no_reset(self) -> &'a mut W {
self.variant(OBLRSTFW::NORESET)
}
#[doc = "A reset has occured"]
#[inline(always)]
pub fn reset(self) -> &'a mut W {
self.variant(OBLRSTFW::RESET)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 23);
self.w.bits |= ((value as u32) & 0x01) << 23;
self.w
}
}
impl R {
#[doc = r"Value of the register as raw bits"]
#[inline(always)]
pub fn bits(&self) -> u32 {
self.bits
}
#[doc = "Bit 0 - Internal low speed oscillator enable"]
#[inline(always)]
pub fn lsion(&self) -> LSIONR {
LSIONR::_from(((self.bits >> 0) & 0x01) != 0)
}
#[doc = "Bit 1 - Internal low speed oscillator ready"]
#[inline(always)]
pub fn lsirdy(&self) -> LSIRDYR {
LSIRDYR::_from(((self.bits >> 1) & 0x01) != 0)
}
#[doc = "Bit 24 - Remove reset flag"]
#[inline(always)]
pub fn rmvf(&self) -> RMVFR {
RMVFR::_from(((self.bits >> 24) & 0x01) != 0)
}
#[doc = "Bit 25 - Option byte loader reset flag"]
#[inline(always)]
pub fn oblrstf(&self) -> OBLRSTFR {
OBLRSTFR::_from(((self.bits >> 25) & 0x01) != 0)
}
#[doc = "Bit 26 - PIN reset flag"]
#[inline(always)]
pub fn pinrstf(&self) -> PINRSTFR {
PINRSTFR::_from(((self.bits >> 26) & 0x01) != 0)
}
#[doc = "Bit 27 - POR/PDR reset flag"]
#[inline(always)]
pub fn porrstf(&self) -> PORRSTFR {
PORRSTFR::_from(((self.bits >> 27) & 0x01) != 0)
}
#[doc = "Bit 28 - Software reset flag"]
#[inline(always)]
pub fn sftrstf(&self) -> SFTRSTFR {
SFTRSTFR::_from(((self.bits >> 28) & 0x01) != 0)
}
#[doc = "Bit 29 - Independent watchdog reset flag"]
#[inline(always)]
pub fn iwdgrstf(&self) -> IWDGRSTFR {
IWDGRSTFR::_from(((self.bits >> 29) & 0x01) != 0)
}
#[doc = "Bit 30 - Window watchdog reset flag"]
#[inline(always)]
pub fn wwdgrstf(&self) -> WWDGRSTFR {
WWDGRSTFR::_from(((self.bits >> 30) & 0x01) != 0)
}
#[doc = "Bit 31 - Low-power reset flag"]
#[inline(always)]
pub fn lpwrrstf(&self) -> LPWRRSTFR {
LPWRRSTFR::_from(((self.bits >> 31) & 0x01) != 0)
}
#[doc = "Bit 23 - Reset flag of the 1.8 V domain"]
#[inline(always)]
pub fn v18pwrrstf(&self) -> V18PWRRSTFR {
V18PWRRSTFR::_from(((self.bits >> 23) & 0x01) != 0)
}
}
impl W {
#[doc = r"Writes raw bits to the register"]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.bits = bits;
self
}
#[doc = "Bit 0 - Internal low speed oscillator enable"]
#[inline(always)]
pub fn lsion(&mut self) -> _LSIONW {
_LSIONW { w: self }
}
#[doc = "Bit 24 - Remove reset flag"]
#[inline(always)]
pub fn rmvf(&mut self) -> _RMVFW {
_RMVFW { w: self }
}
#[doc = "Bit 25 - Option byte loader reset flag"]
#[inline(always)]
pub fn oblrstf(&mut self) -> _OBLRSTFW {
_OBLRSTFW { w: self }
}
#[doc = "Bit 26 - PIN reset flag"]
#[inline(always)]
pub fn pinrstf(&mut self) -> _PINRSTFW {
_PINRSTFW { w: self }
}
#[doc = "Bit 27 - POR/PDR reset flag"]
#[inline(always)]
pub fn porrstf(&mut self) -> _PORRSTFW {
_PORRSTFW { w: self }
}
#[doc = "Bit 28 - Software reset flag"]
#[inline(always)]
pub fn sftrstf(&mut self) -> _SFTRSTFW {
_SFTRSTFW { w: self }
}
#[doc = "Bit 29 - Independent watchdog reset flag"]
#[inline(always)]
pub fn iwdgrstf(&mut self) -> _IWDGRSTFW {
_IWDGRSTFW { w: self }
}
#[doc = "Bit 30 - Window watchdog reset flag"]
#[inline(always)]
pub fn wwdgrstf(&mut self) -> _WWDGRSTFW {
_WWDGRSTFW { w: self }
}
#[doc = "Bit 31 - Low-power reset flag"]
#[inline(always)]
pub fn lpwrrstf(&mut self) -> _LPWRRSTFW {
_LPWRRSTFW { w: self }
}
#[doc = "Bit 23 - Reset flag of the 1.8 V domain"]
#[inline(always)]
pub fn v18pwrrstf(&mut self) -> _V18PWRRSTFW {
_V18PWRRSTFW { w: self }
}
}