#[doc = "Reader of register CR"]
pub type R = crate::R<u32, super::CR>;
#[doc = "Writer for register CR"]
pub type W = crate::W<u32, super::CR>;
#[doc = "Register CR `reset()`'s with value 0x80"]
impl crate::ResetValue for super::CR {
type Type = u32;
#[inline(always)]
fn reset_value() -> Self::Type {
0x80
}
}
#[doc = "Force option byte loading\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum OBL_LAUNCH_A {
#[doc = "0: Force option byte loading inactive"]
INACTIVE = 0,
#[doc = "1: Force option byte loading active"]
ACTIVE = 1,
}
impl From<OBL_LAUNCH_A> for bool {
#[inline(always)]
fn from(variant: OBL_LAUNCH_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `OBL_LAUNCH`"]
pub type OBL_LAUNCH_R = crate::R<bool, OBL_LAUNCH_A>;
impl OBL_LAUNCH_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> OBL_LAUNCH_A {
match self.bits {
false => OBL_LAUNCH_A::INACTIVE,
true => OBL_LAUNCH_A::ACTIVE,
}
}
#[doc = "Checks if the value of the field is `INACTIVE`"]
#[inline(always)]
pub fn is_inactive(&self) -> bool {
*self == OBL_LAUNCH_A::INACTIVE
}
#[doc = "Checks if the value of the field is `ACTIVE`"]
#[inline(always)]
pub fn is_active(&self) -> bool {
*self == OBL_LAUNCH_A::ACTIVE
}
}
#[doc = "Write proxy for field `OBL_LAUNCH`"]
pub struct OBL_LAUNCH_W<'a> {
w: &'a mut W,
}
impl<'a> OBL_LAUNCH_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: OBL_LAUNCH_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Force option byte loading inactive"]
#[inline(always)]
pub fn inactive(self) -> &'a mut W {
self.variant(OBL_LAUNCH_A::INACTIVE)
}
#[doc = "Force option byte loading active"]
#[inline(always)]
pub fn active(self) -> &'a mut W {
self.variant(OBL_LAUNCH_A::ACTIVE)
}
#[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 << 13)) | (((value as u32) & 0x01) << 13);
self.w
}
}
#[doc = "End of operation interrupt enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum EOPIE_A {
#[doc = "0: End of operation interrupt disabled"]
DISABLED = 0,
#[doc = "1: End of operation interrupt enabled"]
ENABLED = 1,
}
impl From<EOPIE_A> for bool {
#[inline(always)]
fn from(variant: EOPIE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `EOPIE`"]
pub type EOPIE_R = crate::R<bool, EOPIE_A>;
impl EOPIE_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> EOPIE_A {
match self.bits {
false => EOPIE_A::DISABLED,
true => EOPIE_A::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == EOPIE_A::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == EOPIE_A::ENABLED
}
}
#[doc = "Write proxy for field `EOPIE`"]
pub struct EOPIE_W<'a> {
w: &'a mut W,
}
impl<'a> EOPIE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: EOPIE_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "End of operation interrupt disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(EOPIE_A::DISABLED)
}
#[doc = "End of operation interrupt enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(EOPIE_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 << 12)) | (((value as u32) & 0x01) << 12);
self.w
}
}
#[doc = "Error interrupt enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ERRIE_A {
#[doc = "0: Error interrupt generation disabled"]
DISABLED = 0,
#[doc = "1: Error interrupt generation enabled"]
ENABLED = 1,
}
impl From<ERRIE_A> for bool {
#[inline(always)]
fn from(variant: ERRIE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `ERRIE`"]
pub type ERRIE_R = crate::R<bool, ERRIE_A>;
impl ERRIE_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> ERRIE_A {
match self.bits {
false => ERRIE_A::DISABLED,
true => ERRIE_A::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == ERRIE_A::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == ERRIE_A::ENABLED
}
}
#[doc = "Write proxy for field `ERRIE`"]
pub struct ERRIE_W<'a> {
w: &'a mut W,
}
impl<'a> ERRIE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: ERRIE_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Error interrupt generation disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(ERRIE_A::DISABLED)
}
#[doc = "Error interrupt generation enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(ERRIE_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 << 10)) | (((value as u32) & 0x01) << 10);
self.w
}
}
#[doc = "Option bytes write enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum OPTWRE_A {
#[doc = "0: Option byte write enabled"]
DISABLED = 0,
#[doc = "1: Option byte write disabled"]
ENABLED = 1,
}
impl From<OPTWRE_A> for bool {
#[inline(always)]
fn from(variant: OPTWRE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `OPTWRE`"]
pub type OPTWRE_R = crate::R<bool, OPTWRE_A>;
impl OPTWRE_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> OPTWRE_A {
match self.bits {
false => OPTWRE_A::DISABLED,
true => OPTWRE_A::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == OPTWRE_A::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == OPTWRE_A::ENABLED
}
}
#[doc = "Write proxy for field `OPTWRE`"]
pub struct OPTWRE_W<'a> {
w: &'a mut W,
}
impl<'a> OPTWRE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: OPTWRE_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Option byte write enabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(OPTWRE_A::DISABLED)
}
#[doc = "Option byte write disabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(OPTWRE_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 << 9)) | (((value as u32) & 0x01) << 9);
self.w
}
}
#[doc = "Lock\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum LOCK_A {
#[doc = "0: FLASH_CR register is unlocked"]
UNLOCKED = 0,
#[doc = "1: FLASH_CR register is locked"]
LOCKED = 1,
}
impl From<LOCK_A> for bool {
#[inline(always)]
fn from(variant: LOCK_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `LOCK`"]
pub type LOCK_R = crate::R<bool, LOCK_A>;
impl LOCK_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> LOCK_A {
match self.bits {
false => LOCK_A::UNLOCKED,
true => LOCK_A::LOCKED,
}
}
#[doc = "Checks if the value of the field is `UNLOCKED`"]
#[inline(always)]
pub fn is_unlocked(&self) -> bool {
*self == LOCK_A::UNLOCKED
}
#[doc = "Checks if the value of the field is `LOCKED`"]
#[inline(always)]
pub fn is_locked(&self) -> bool {
*self == LOCK_A::LOCKED
}
}
#[doc = "Lock\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum LOCK_AW {
#[doc = "1: Lock the FLASH_CR register"]
LOCK = 1,
}
impl From<LOCK_AW> for bool {
#[inline(always)]
fn from(variant: LOCK_AW) -> Self {
variant as u8 != 0
}
}
#[doc = "Write proxy for field `LOCK`"]
pub struct LOCK_W<'a> {
w: &'a mut W,
}
impl<'a> LOCK_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: LOCK_AW) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Lock the FLASH_CR register"]
#[inline(always)]
pub fn lock(self) -> &'a mut W {
self.variant(LOCK_AW::LOCK)
}
#[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 = "Start\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum STRT_A {
#[doc = "1: Trigger an erase operation"]
START = 1,
}
impl From<STRT_A> for bool {
#[inline(always)]
fn from(variant: STRT_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `STRT`"]
pub type STRT_R = crate::R<bool, STRT_A>;
impl STRT_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> crate::Variant<bool, STRT_A> {
use crate::Variant::*;
match self.bits {
true => Val(STRT_A::START),
i => Res(i),
}
}
#[doc = "Checks if the value of the field is `START`"]
#[inline(always)]
pub fn is_start(&self) -> bool {
*self == STRT_A::START
}
}
#[doc = "Write proxy for field `STRT`"]
pub struct STRT_W<'a> {
w: &'a mut W,
}
impl<'a> STRT_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: STRT_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Trigger an erase operation"]
#[inline(always)]
pub fn start(self) -> &'a mut W {
self.variant(STRT_A::START)
}
#[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 = "Option byte erase\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum OPTER_A {
#[doc = "1: Erase option byte activated"]
OPTIONBYTEERASE = 1,
}
impl From<OPTER_A> for bool {
#[inline(always)]
fn from(variant: OPTER_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `OPTER`"]
pub type OPTER_R = crate::R<bool, OPTER_A>;
impl OPTER_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> crate::Variant<bool, OPTER_A> {
use crate::Variant::*;
match self.bits {
true => Val(OPTER_A::OPTIONBYTEERASE),
i => Res(i),
}
}
#[doc = "Checks if the value of the field is `OPTIONBYTEERASE`"]
#[inline(always)]
pub fn is_option_byte_erase(&self) -> bool {
*self == OPTER_A::OPTIONBYTEERASE
}
}
#[doc = "Write proxy for field `OPTER`"]
pub struct OPTER_W<'a> {
w: &'a mut W,
}
impl<'a> OPTER_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: OPTER_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Erase option byte activated"]
#[inline(always)]
pub fn option_byte_erase(self) -> &'a mut W {
self.variant(OPTER_A::OPTIONBYTEERASE)
}
#[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 = "Option byte programming\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum OPTPG_A {
#[doc = "1: Program option byte activated"]
OPTIONBYTEPROGRAMMING = 1,
}
impl From<OPTPG_A> for bool {
#[inline(always)]
fn from(variant: OPTPG_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `OPTPG`"]
pub type OPTPG_R = crate::R<bool, OPTPG_A>;
impl OPTPG_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> crate::Variant<bool, OPTPG_A> {
use crate::Variant::*;
match self.bits {
true => Val(OPTPG_A::OPTIONBYTEPROGRAMMING),
i => Res(i),
}
}
#[doc = "Checks if the value of the field is `OPTIONBYTEPROGRAMMING`"]
#[inline(always)]
pub fn is_option_byte_programming(&self) -> bool {
*self == OPTPG_A::OPTIONBYTEPROGRAMMING
}
}
#[doc = "Write proxy for field `OPTPG`"]
pub struct OPTPG_W<'a> {
w: &'a mut W,
}
impl<'a> OPTPG_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: OPTPG_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Program option byte activated"]
#[inline(always)]
pub fn option_byte_programming(self) -> &'a mut W {
self.variant(OPTPG_A::OPTIONBYTEPROGRAMMING)
}
#[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 = "Mass erase\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum MER_A {
#[doc = "1: Erase activated for all user sectors"]
MASSERASE = 1,
}
impl From<MER_A> for bool {
#[inline(always)]
fn from(variant: MER_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `MER`"]
pub type MER_R = crate::R<bool, MER_A>;
impl MER_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> crate::Variant<bool, MER_A> {
use crate::Variant::*;
match self.bits {
true => Val(MER_A::MASSERASE),
i => Res(i),
}
}
#[doc = "Checks if the value of the field is `MASSERASE`"]
#[inline(always)]
pub fn is_mass_erase(&self) -> bool {
*self == MER_A::MASSERASE
}
}
#[doc = "Write proxy for field `MER`"]
pub struct MER_W<'a> {
w: &'a mut W,
}
impl<'a> MER_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: MER_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Erase activated for all user sectors"]
#[inline(always)]
pub fn mass_erase(self) -> &'a mut W {
self.variant(MER_A::MASSERASE)
}
#[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 = "Page erase\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum PER_A {
#[doc = "1: Erase activated for selected page"]
PAGEERASE = 1,
}
impl From<PER_A> for bool {
#[inline(always)]
fn from(variant: PER_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `PER`"]
pub type PER_R = crate::R<bool, PER_A>;
impl PER_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> crate::Variant<bool, PER_A> {
use crate::Variant::*;
match self.bits {
true => Val(PER_A::PAGEERASE),
i => Res(i),
}
}
#[doc = "Checks if the value of the field is `PAGEERASE`"]
#[inline(always)]
pub fn is_page_erase(&self) -> bool {
*self == PER_A::PAGEERASE
}
}
#[doc = "Write proxy for field `PER`"]
pub struct PER_W<'a> {
w: &'a mut W,
}
impl<'a> PER_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: PER_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Erase activated for selected page"]
#[inline(always)]
pub fn page_erase(self) -> &'a mut W {
self.variant(PER_A::PAGEERASE)
}
#[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 = "Programming\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum PG_A {
#[doc = "1: Flash programming activated"]
PROGRAM = 1,
}
impl From<PG_A> for bool {
#[inline(always)]
fn from(variant: PG_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `PG`"]
pub type PG_R = crate::R<bool, PG_A>;
impl PG_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> crate::Variant<bool, PG_A> {
use crate::Variant::*;
match self.bits {
true => Val(PG_A::PROGRAM),
i => Res(i),
}
}
#[doc = "Checks if the value of the field is `PROGRAM`"]
#[inline(always)]
pub fn is_program(&self) -> bool {
*self == PG_A::PROGRAM
}
}
#[doc = "Write proxy for field `PG`"]
pub struct PG_W<'a> {
w: &'a mut W,
}
impl<'a> PG_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: PG_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Flash programming activated"]
#[inline(always)]
pub fn program(self) -> &'a mut W {
self.variant(PG_A::PROGRAM)
}
#[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
}
}
impl R {
#[doc = "Bit 13 - Force option byte loading"]
#[inline(always)]
pub fn obl_launch(&self) -> OBL_LAUNCH_R {
OBL_LAUNCH_R::new(((self.bits >> 13) & 0x01) != 0)
}
#[doc = "Bit 12 - End of operation interrupt enable"]
#[inline(always)]
pub fn eopie(&self) -> EOPIE_R {
EOPIE_R::new(((self.bits >> 12) & 0x01) != 0)
}
#[doc = "Bit 10 - Error interrupt enable"]
#[inline(always)]
pub fn errie(&self) -> ERRIE_R {
ERRIE_R::new(((self.bits >> 10) & 0x01) != 0)
}
#[doc = "Bit 9 - Option bytes write enable"]
#[inline(always)]
pub fn optwre(&self) -> OPTWRE_R {
OPTWRE_R::new(((self.bits >> 9) & 0x01) != 0)
}
#[doc = "Bit 7 - Lock"]
#[inline(always)]
pub fn lock(&self) -> LOCK_R {
LOCK_R::new(((self.bits >> 7) & 0x01) != 0)
}
#[doc = "Bit 6 - Start"]
#[inline(always)]
pub fn strt(&self) -> STRT_R {
STRT_R::new(((self.bits >> 6) & 0x01) != 0)
}
#[doc = "Bit 5 - Option byte erase"]
#[inline(always)]
pub fn opter(&self) -> OPTER_R {
OPTER_R::new(((self.bits >> 5) & 0x01) != 0)
}
#[doc = "Bit 4 - Option byte programming"]
#[inline(always)]
pub fn optpg(&self) -> OPTPG_R {
OPTPG_R::new(((self.bits >> 4) & 0x01) != 0)
}
#[doc = "Bit 2 - Mass erase"]
#[inline(always)]
pub fn mer(&self) -> MER_R {
MER_R::new(((self.bits >> 2) & 0x01) != 0)
}
#[doc = "Bit 1 - Page erase"]
#[inline(always)]
pub fn per(&self) -> PER_R {
PER_R::new(((self.bits >> 1) & 0x01) != 0)
}
#[doc = "Bit 0 - Programming"]
#[inline(always)]
pub fn pg(&self) -> PG_R {
PG_R::new((self.bits & 0x01) != 0)
}
}
impl W {
#[doc = "Bit 13 - Force option byte loading"]
#[inline(always)]
pub fn obl_launch(&mut self) -> OBL_LAUNCH_W {
OBL_LAUNCH_W { w: self }
}
#[doc = "Bit 12 - End of operation interrupt enable"]
#[inline(always)]
pub fn eopie(&mut self) -> EOPIE_W {
EOPIE_W { w: self }
}
#[doc = "Bit 10 - Error interrupt enable"]
#[inline(always)]
pub fn errie(&mut self) -> ERRIE_W {
ERRIE_W { w: self }
}
#[doc = "Bit 9 - Option bytes write enable"]
#[inline(always)]
pub fn optwre(&mut self) -> OPTWRE_W {
OPTWRE_W { w: self }
}
#[doc = "Bit 7 - Lock"]
#[inline(always)]
pub fn lock(&mut self) -> LOCK_W {
LOCK_W { w: self }
}
#[doc = "Bit 6 - Start"]
#[inline(always)]
pub fn strt(&mut self) -> STRT_W {
STRT_W { w: self }
}
#[doc = "Bit 5 - Option byte erase"]
#[inline(always)]
pub fn opter(&mut self) -> OPTER_W {
OPTER_W { w: self }
}
#[doc = "Bit 4 - Option byte programming"]
#[inline(always)]
pub fn optpg(&mut self) -> OPTPG_W {
OPTPG_W { w: self }
}
#[doc = "Bit 2 - Mass erase"]
#[inline(always)]
pub fn mer(&mut self) -> MER_W {
MER_W { w: self }
}
#[doc = "Bit 1 - Page erase"]
#[inline(always)]
pub fn per(&mut self) -> PER_W {
PER_W { w: self }
}
#[doc = "Bit 0 - Programming"]
#[inline(always)]
pub fn pg(&mut self) -> PG_W {
PG_W { w: self }
}
}