#[doc = "ARR"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Arr(pub u32);
impl Arr {
#[doc = "Auto-reload value"]
#[must_use]
#[inline(always)]
pub const fn arr(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[doc = "Auto-reload value"]
#[inline(always)]
pub const fn set_arr(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
}
impl Default for Arr {
#[inline(always)]
fn default() -> Arr {
Arr(0)
}
}
impl core::fmt::Debug for Arr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Arr").field("arr", &self.arr()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Arr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Arr {{ arr: {=u16:?} }}", self.arr())
}
}
#[doc = "CNT"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cnt(pub u32);
impl Cnt {
#[doc = "Counter value"]
#[must_use]
#[inline(always)]
pub const fn cnt(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[doc = "Counter value"]
#[inline(always)]
pub const fn set_cnt(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
}
impl Default for Cnt {
#[inline(always)]
fn default() -> Cnt {
Cnt(0)
}
}
impl core::fmt::Debug for Cnt {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Cnt").field("cnt", &self.cnt()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Cnt {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Cnt {{ cnt: {=u16:?} }}", self.cnt())
}
}
#[doc = "CR1"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cr1(pub u32);
impl Cr1 {
#[doc = "Counter enable"]
#[must_use]
#[inline(always)]
pub const fn cen(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Counter enable"]
#[inline(always)]
pub const fn set_cen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Update disable"]
#[must_use]
#[inline(always)]
pub const fn udis(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Update disable"]
#[inline(always)]
pub const fn set_udis(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Update request source"]
#[must_use]
#[inline(always)]
pub const fn urs(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Update request source"]
#[inline(always)]
pub const fn set_urs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "One pulse mode"]
#[must_use]
#[inline(always)]
pub const fn opm(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "One pulse mode"]
#[inline(always)]
pub const fn set_opm(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "Auto-reload preload enable"]
#[must_use]
#[inline(always)]
pub const fn arpe(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "Auto-reload preload enable"]
#[inline(always)]
pub const fn set_arpe(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
}
impl Default for Cr1 {
#[inline(always)]
fn default() -> Cr1 {
Cr1(0)
}
}
impl core::fmt::Debug for Cr1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Cr1")
.field("cen", &self.cen())
.field("udis", &self.udis())
.field("urs", &self.urs())
.field("opm", &self.opm())
.field("arpe", &self.arpe())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Cr1 {
fn format(&self, f: defmt::Formatter) {
defmt :: write ! (f , "Cr1 {{ cen: {=bool:?}, udis: {=bool:?}, urs: {=bool:?}, opm: {=bool:?}, arpe: {=bool:?} }}" , self . cen () , self . udis () , self . urs () , self . opm () , self . arpe ())
}
}
#[doc = "CR2"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cr2(pub u32);
impl Cr2 {
#[doc = "Master mode selection"]
#[must_use]
#[inline(always)]
pub const fn mms(&self) -> u8 {
let val = (self.0 >> 4usize) & 0x07;
val as u8
}
#[doc = "Master mode selection"]
#[inline(always)]
pub const fn set_mms(&mut self, val: u8) {
self.0 = (self.0 & !(0x07 << 4usize)) | (((val as u32) & 0x07) << 4usize);
}
}
impl Default for Cr2 {
#[inline(always)]
fn default() -> Cr2 {
Cr2(0)
}
}
impl core::fmt::Debug for Cr2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Cr2").field("mms", &self.mms()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Cr2 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Cr2 {{ mms: {=u8:?} }}", self.mms())
}
}
#[doc = "DIER"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Dier(pub u32);
impl Dier {
#[doc = "Update interrupt enable"]
#[must_use]
#[inline(always)]
pub const fn uie(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Update interrupt enable"]
#[inline(always)]
pub const fn set_uie(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
}
impl Default for Dier {
#[inline(always)]
fn default() -> Dier {
Dier(0)
}
}
impl core::fmt::Debug for Dier {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Dier").field("uie", &self.uie()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Dier {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Dier {{ uie: {=bool:?} }}", self.uie())
}
}
#[doc = "EGR"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Egr(pub u32);
impl Egr {
#[doc = "Update generation"]
#[must_use]
#[inline(always)]
pub const fn ug(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Update generation"]
#[inline(always)]
pub const fn set_ug(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
}
impl Default for Egr {
#[inline(always)]
fn default() -> Egr {
Egr(0)
}
}
impl core::fmt::Debug for Egr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Egr").field("ug", &self.ug()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Egr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Egr {{ ug: {=bool:?} }}", self.ug())
}
}
#[doc = "PSC"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Psc(pub u32);
impl Psc {
#[doc = "Prescaler value"]
#[must_use]
#[inline(always)]
pub const fn psc(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[doc = "Prescaler value"]
#[inline(always)]
pub const fn set_psc(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
}
impl Default for Psc {
#[inline(always)]
fn default() -> Psc {
Psc(0)
}
}
impl core::fmt::Debug for Psc {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Psc").field("psc", &self.psc()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Psc {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Psc {{ psc: {=u16:?} }}", self.psc())
}
}
#[doc = "SR"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Sr(pub u32);
impl Sr {
#[doc = "Update interrupt flag"]
#[must_use]
#[inline(always)]
pub const fn uif(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Update interrupt flag"]
#[inline(always)]
pub const fn set_uif(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
}
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("uif", &self.uif()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Sr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Sr {{ uif: {=bool:?} }}", self.uif())
}
}