#[doc = "Reader of register OPTCR"]
pub type R = crate::R<u32, super::OPTCR>;
#[doc = "Writer for register OPTCR"]
pub type W = crate::W<u32, super::OPTCR>;
#[doc = "Register OPTCR `reset()`'s with value 0x14"]
impl crate::ResetValue for super::OPTCR {
type Type = u32;
#[inline(always)]
fn reset_value() -> Self::Type {
0x14
}
}
#[doc = "Reader of field `OPTLOCK`"]
pub type OPTLOCK_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `OPTLOCK`"]
pub struct OPTLOCK_W<'a> {
w: &'a mut W,
}
impl<'a> OPTLOCK_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) | ((value as u32) & 0x01);
self.w
}
}
#[doc = "Reader of field `OPTSTRT`"]
pub type OPTSTRT_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `OPTSTRT`"]
pub struct OPTSTRT_W<'a> {
w: &'a mut W,
}
impl<'a> OPTSTRT_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 << 1)) | (((value as u32) & 0x01) << 1);
self.w
}
}
#[doc = "Reader of field `BOR_LEV`"]
pub type BOR_LEV_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `BOR_LEV`"]
pub struct BOR_LEV_W<'a> {
w: &'a mut W,
}
impl<'a> BOR_LEV_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 & !(0x03 << 2)) | (((value as u32) & 0x03) << 2);
self.w
}
}
#[doc = "Reader of field `WDG_SW`"]
pub type WDG_SW_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `WDG_SW`"]
pub struct WDG_SW_W<'a> {
w: &'a mut W,
}
impl<'a> WDG_SW_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 `nRST_STOP`"]
pub type NRST_STOP_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `nRST_STOP`"]
pub struct NRST_STOP_W<'a> {
w: &'a mut W,
}
impl<'a> NRST_STOP_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 = "Reader of field `nRST_STDBY`"]
pub type NRST_STDBY_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `nRST_STDBY`"]
pub struct NRST_STDBY_W<'a> {
w: &'a mut W,
}
impl<'a> NRST_STDBY_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 << 7)) | (((value as u32) & 0x01) << 7);
self.w
}
}
#[doc = "Reader of field `RDP`"]
pub type RDP_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `RDP`"]
pub struct RDP_W<'a> {
w: &'a mut W,
}
impl<'a> RDP_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 = "Reader of field `nWRP`"]
pub type NWRP_R = crate::R<u16, u16>;
#[doc = "Write proxy for field `nWRP`"]
pub struct NWRP_W<'a> {
w: &'a mut W,
}
impl<'a> NWRP_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u16) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0fff << 16)) | (((value as u32) & 0x0fff) << 16);
self.w
}
}
impl R {
#[doc = "Bit 0 - Option lock"]
#[inline(always)]
pub fn optlock(&self) -> OPTLOCK_R {
OPTLOCK_R::new((self.bits & 0x01) != 0)
}
#[doc = "Bit 1 - Option start"]
#[inline(always)]
pub fn optstrt(&self) -> OPTSTRT_R {
OPTSTRT_R::new(((self.bits >> 1) & 0x01) != 0)
}
#[doc = "Bits 2:3 - BOR reset Level"]
#[inline(always)]
pub fn bor_lev(&self) -> BOR_LEV_R {
BOR_LEV_R::new(((self.bits >> 2) & 0x03) as u8)
}
#[doc = "Bit 5 - WDG_SW User option bytes"]
#[inline(always)]
pub fn wdg_sw(&self) -> WDG_SW_R {
WDG_SW_R::new(((self.bits >> 5) & 0x01) != 0)
}
#[doc = "Bit 6 - nRST_STOP User option bytes"]
#[inline(always)]
pub fn n_rst_stop(&self) -> NRST_STOP_R {
NRST_STOP_R::new(((self.bits >> 6) & 0x01) != 0)
}
#[doc = "Bit 7 - nRST_STDBY User option bytes"]
#[inline(always)]
pub fn n_rst_stdby(&self) -> NRST_STDBY_R {
NRST_STDBY_R::new(((self.bits >> 7) & 0x01) != 0)
}
#[doc = "Bits 8:15 - Read protect"]
#[inline(always)]
pub fn rdp(&self) -> RDP_R {
RDP_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 16:27 - Not write protect"]
#[inline(always)]
pub fn n_wrp(&self) -> NWRP_R {
NWRP_R::new(((self.bits >> 16) & 0x0fff) as u16)
}
}
impl W {
#[doc = "Bit 0 - Option lock"]
#[inline(always)]
pub fn optlock(&mut self) -> OPTLOCK_W {
OPTLOCK_W { w: self }
}
#[doc = "Bit 1 - Option start"]
#[inline(always)]
pub fn optstrt(&mut self) -> OPTSTRT_W {
OPTSTRT_W { w: self }
}
#[doc = "Bits 2:3 - BOR reset Level"]
#[inline(always)]
pub fn bor_lev(&mut self) -> BOR_LEV_W {
BOR_LEV_W { w: self }
}
#[doc = "Bit 5 - WDG_SW User option bytes"]
#[inline(always)]
pub fn wdg_sw(&mut self) -> WDG_SW_W {
WDG_SW_W { w: self }
}
#[doc = "Bit 6 - nRST_STOP User option bytes"]
#[inline(always)]
pub fn n_rst_stop(&mut self) -> NRST_STOP_W {
NRST_STOP_W { w: self }
}
#[doc = "Bit 7 - nRST_STDBY User option bytes"]
#[inline(always)]
pub fn n_rst_stdby(&mut self) -> NRST_STDBY_W {
NRST_STDBY_W { w: self }
}
#[doc = "Bits 8:15 - Read protect"]
#[inline(always)]
pub fn rdp(&mut self) -> RDP_W {
RDP_W { w: self }
}
#[doc = "Bits 16:27 - Not write protect"]
#[inline(always)]
pub fn n_wrp(&mut self) -> NWRP_W {
NWRP_W { w: self }
}
}