#[doc = "ACR"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Acr(pub u32);
impl Acr {
#[doc = "Latency"]
#[must_use]
#[inline(always)]
pub const fn latency(&self) -> u8 {
let val = (self.0 >> 0usize) & 0x07;
val as u8
}
#[doc = "Latency"]
#[inline(always)]
pub const fn set_latency(&mut self, val: u8) {
self.0 = (self.0 & !(0x07 << 0usize)) | (((val as u32) & 0x07) << 0usize);
}
}
impl Default for Acr {
#[inline(always)]
fn default() -> Acr {
Acr(0)
}
}
impl core::fmt::Debug for Acr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Acr")
.field("latency", &self.latency())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Acr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Acr {{ latency: {=u8:?} }}", self.latency())
}
}
#[doc = "AR"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ar(pub u32);
impl Ar {
#[doc = "Flash address"]
#[must_use]
#[inline(always)]
pub const fn far(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Flash address"]
#[inline(always)]
pub const fn set_far(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Ar {
#[inline(always)]
fn default() -> Ar {
Ar(0)
}
}
impl core::fmt::Debug for Ar {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ar").field("far", &self.far()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ar {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Ar {{ far: {=u32:?} }}", self.far())
}
}
#[doc = "CR"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cr(pub u32);
impl Cr {
#[doc = "Half Word programming"]
#[must_use]
#[inline(always)]
pub const fn pg(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Half Word programming"]
#[inline(always)]
pub const fn set_pg(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Page erase"]
#[must_use]
#[inline(always)]
pub const fn per(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Page erase"]
#[inline(always)]
pub const fn set_per(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Mass erase"]
#[must_use]
#[inline(always)]
pub const fn mer(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Mass erase"]
#[inline(always)]
pub const fn set_mer(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "Option byte programming"]
#[must_use]
#[inline(always)]
pub const fn optpg(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "Option byte programming"]
#[inline(always)]
pub const fn set_optpg(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "Option byte erase"]
#[must_use]
#[inline(always)]
pub const fn opter(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "Option byte erase"]
#[inline(always)]
pub const fn set_opter(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "Start"]
#[must_use]
#[inline(always)]
pub const fn strt(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "Start"]
#[inline(always)]
pub const fn set_strt(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "Lock"]
#[must_use]
#[inline(always)]
pub const fn lock(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "Lock"]
#[inline(always)]
pub const fn set_lock(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
#[doc = "Option byte write enable"]
#[must_use]
#[inline(always)]
pub const fn optwre(&self) -> bool {
let val = (self.0 >> 9usize) & 0x01;
val != 0
}
#[doc = "Option byte write enable"]
#[inline(always)]
pub const fn set_optwre(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
}
#[doc = "Error interrupt enable"]
#[must_use]
#[inline(always)]
pub const fn errie(&self) -> bool {
let val = (self.0 >> 10usize) & 0x01;
val != 0
}
#[doc = "Error interrupt enable"]
#[inline(always)]
pub const fn set_errie(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
}
#[doc = "End of operation interrupt enable"]
#[must_use]
#[inline(always)]
pub const fn eopie(&self) -> bool {
let val = (self.0 >> 12usize) & 0x01;
val != 0
}
#[doc = "End of operation interrupt enable"]
#[inline(always)]
pub const fn set_eopie(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
}
}
impl Default for Cr {
#[inline(always)]
fn default() -> Cr {
Cr(0)
}
}
impl core::fmt::Debug for Cr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Cr")
.field("pg", &self.pg())
.field("per", &self.per())
.field("mer", &self.mer())
.field("optpg", &self.optpg())
.field("opter", &self.opter())
.field("strt", &self.strt())
.field("lock", &self.lock())
.field("optwre", &self.optwre())
.field("errie", &self.errie())
.field("eopie", &self.eopie())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Cr {
fn format(&self, f: defmt::Formatter) {
defmt :: write ! (f , "Cr {{ pg: {=bool:?}, per: {=bool:?}, mer: {=bool:?}, optpg: {=bool:?}, opter: {=bool:?}, strt: {=bool:?}, lock: {=bool:?}, optwre: {=bool:?}, errie: {=bool:?}, eopie: {=bool:?} }}" , self . pg () , self . per () , self . mer () , self . optpg () , self . opter () , self . strt () , self . lock () , self . optwre () , self . errie () , self . eopie ())
}
}
#[doc = "ECR"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ecr(pub u32);
impl Ecr {
#[doc = "Word programming for main Flash"]
#[must_use]
#[inline(always)]
pub const fn wpg(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Word programming for main Flash"]
#[inline(always)]
pub const fn set_wpg(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
}
impl Default for Ecr {
#[inline(always)]
fn default() -> Ecr {
Ecr(0)
}
}
impl core::fmt::Debug for Ecr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ecr").field("wpg", &self.wpg()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ecr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Ecr {{ wpg: {=bool:?} }}", self.wpg())
}
}
#[doc = "INT_VEC_OFFSET"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct IntVecOffset(pub u32);
impl IntVecOffset {
#[doc = "Interrupts vector offset"]
#[must_use]
#[inline(always)]
pub const fn int_vec_offset(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[doc = "Interrupts vector offset"]
#[inline(always)]
pub const fn set_int_vec_offset(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
}
impl Default for IntVecOffset {
#[inline(always)]
fn default() -> IntVecOffset {
IntVecOffset(0)
}
}
impl core::fmt::Debug for IntVecOffset {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("IntVecOffset")
.field("int_vec_offset", &self.int_vec_offset())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for IntVecOffset {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"IntVecOffset {{ int_vec_offset: {=u16:?} }}",
self.int_vec_offset()
)
}
}
#[doc = "KEYR"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Keyr(pub u32);
impl Keyr {
#[doc = "Flash key"]
#[must_use]
#[inline(always)]
pub const fn fkey(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Flash key"]
#[inline(always)]
pub const fn set_fkey(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Keyr {
#[inline(always)]
fn default() -> Keyr {
Keyr(0)
}
}
impl core::fmt::Debug for Keyr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Keyr").field("fkey", &self.fkey()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Keyr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Keyr {{ fkey: {=u32:?} }}", self.fkey())
}
}
#[doc = "OBR"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Obr(pub u32);
impl Obr {
#[doc = "Option byte error"]
#[must_use]
#[inline(always)]
pub const fn opterr(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Option byte error"]
#[inline(always)]
pub const fn set_opterr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Read protection level status"]
#[must_use]
#[inline(always)]
pub const fn rdprt(&self) -> u8 {
let val = (self.0 >> 1usize) & 0x03;
val as u8
}
#[doc = "Read protection level status"]
#[inline(always)]
pub const fn set_rdprt(&mut self, val: u8) {
self.0 = (self.0 & !(0x03 << 1usize)) | (((val as u32) & 0x03) << 1usize);
}
#[doc = "Hardware or software watchdog selection"]
#[must_use]
#[inline(always)]
pub const fn wdg_sw(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "Hardware or software watchdog selection"]
#[inline(always)]
pub const fn set_wdg_sw(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
}
impl Default for Obr {
#[inline(always)]
fn default() -> Obr {
Obr(0)
}
}
impl core::fmt::Debug for Obr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Obr")
.field("opterr", &self.opterr())
.field("rdprt", &self.rdprt())
.field("wdg_sw", &self.wdg_sw())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Obr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Obr {{ opterr: {=bool:?}, rdprt: {=u8:?}, wdg_sw: {=bool:?} }}",
self.opterr(),
self.rdprt(),
self.wdg_sw()
)
}
}
#[doc = "OPTKEYR"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Optkeyr(pub u32);
impl Optkeyr {
#[doc = "Option byte key"]
#[must_use]
#[inline(always)]
pub const fn optkeyr(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Option byte key"]
#[inline(always)]
pub const fn set_optkeyr(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Optkeyr {
#[inline(always)]
fn default() -> Optkeyr {
Optkeyr(0)
}
}
impl core::fmt::Debug for Optkeyr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Optkeyr")
.field("optkeyr", &self.optkeyr())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Optkeyr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Optkeyr {{ optkeyr: {=u32:?} }}", self.optkeyr())
}
}
#[doc = "SR"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Sr(pub u32);
impl Sr {
#[doc = "Busy"]
#[must_use]
#[inline(always)]
pub const fn bsy(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Busy"]
#[inline(always)]
pub const fn set_bsy(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Programming error"]
#[must_use]
#[inline(always)]
pub const fn pgerr(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Programming error"]
#[inline(always)]
pub const fn set_pgerr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "Write protection error"]
#[must_use]
#[inline(always)]
pub const fn wrprterr(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "Write protection error"]
#[inline(always)]
pub const fn set_wrprterr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "End of operation"]
#[must_use]
#[inline(always)]
pub const fn eop(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "End of operation"]
#[inline(always)]
pub const fn set_eop(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "Flash power on error"]
#[must_use]
#[inline(always)]
pub const fn fspoerr(&self) -> bool {
let val = (self.0 >> 31usize) & 0x01;
val != 0
}
#[doc = "Flash power on error"]
#[inline(always)]
pub const fn set_fspoerr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 31usize)) | (((val as u32) & 0x01) << 31usize);
}
}
impl Default for Sr {
#[inline(always)]
fn default() -> Sr {
Sr(0)
}
}
impl core::fmt::Debug for Sr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Sr")
.field("bsy", &self.bsy())
.field("pgerr", &self.pgerr())
.field("wrprterr", &self.wrprterr())
.field("eop", &self.eop())
.field("fspoerr", &self.fspoerr())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Sr {
fn format(&self, f: defmt::Formatter) {
defmt :: write ! (f , "Sr {{ bsy: {=bool:?}, pgerr: {=bool:?}, wrprterr: {=bool:?}, eop: {=bool:?}, fspoerr: {=bool:?} }}" , self . bsy () , self . pgerr () , self . wrprterr () , self . eop () , self . fspoerr ())
}
}
#[doc = "WRPR"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Wrpr(pub u32);
impl Wrpr {
#[doc = "Write protection"]
#[must_use]
#[inline(always)]
pub const fn wrp(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[doc = "Write protection"]
#[inline(always)]
pub const fn set_wrp(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
}
impl Default for Wrpr {
#[inline(always)]
fn default() -> Wrpr {
Wrpr(0)
}
}
impl core::fmt::Debug for Wrpr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Wrpr").field("wrp", &self.wrp()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Wrpr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Wrpr {{ wrp: {=u16:?} }}", self.wrp())
}
}