#![allow(clippy::missing_safety_doc)]
#![allow(clippy::identity_op)]
#![allow(clippy::unnecessary_cast)]
#![allow(clippy::erasing_op)]
#[doc = "Real-time clock"]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Rtc {
ptr: *mut u8,
}
unsafe impl Send for Rtc {}
unsafe impl Sync for Rtc {}
impl Rtc {
#[inline(always)]
pub const unsafe fn from_ptr(ptr: *mut ()) -> Self {
Self { ptr: ptr as _ }
}
#[inline(always)]
pub const fn as_ptr(&self) -> *mut () {
self.ptr as _
}
#[doc = "Time register"]
#[inline(always)]
pub const fn tr(self) -> crate::common::Reg<regs::Tr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0usize) as _) }
}
#[doc = "Date register"]
#[inline(always)]
pub const fn dr(self) -> crate::common::Reg<regs::Dr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x04usize) as _) }
}
#[doc = "Control register"]
#[inline(always)]
pub const fn cr(self) -> crate::common::Reg<regs::Cr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x08usize) as _) }
}
#[doc = "Initialization and status register"]
#[inline(always)]
pub const fn isr(self) -> crate::common::Reg<regs::Isr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0cusize) as _) }
}
#[doc = "Prescaler register"]
#[inline(always)]
pub const fn prer(self) -> crate::common::Reg<regs::Prer, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x10usize) as _) }
}
#[doc = "Wakeup timer register"]
#[inline(always)]
pub const fn wutr(self) -> crate::common::Reg<regs::Wutr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x14usize) as _) }
}
#[doc = "Calibration register"]
#[inline(always)]
pub const fn calibr(self) -> crate::common::Reg<regs::Calibr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x18usize) as _) }
}
#[doc = "Alarm register"]
#[inline(always)]
pub const fn alrmr(self, n: usize) -> crate::common::Reg<regs::Alrmr, crate::common::RW> {
assert!(n < 2usize);
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x1cusize + n * 4usize) as _) }
}
#[doc = "Write protection register"]
#[inline(always)]
pub const fn wpr(self) -> crate::common::Reg<regs::Wpr, crate::common::W> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x24usize) as _) }
}
#[doc = "Timestamp time register"]
#[inline(always)]
pub const fn tstr(self) -> crate::common::Reg<regs::Tstr, crate::common::R> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x30usize) as _) }
}
#[doc = "Timestamp date register"]
#[inline(always)]
pub const fn tsdr(self) -> crate::common::Reg<regs::Tsdr, crate::common::R> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x34usize) as _) }
}
#[doc = "Tamper and alternate function configuration register"]
#[inline(always)]
pub const fn tafcr(self) -> crate::common::Reg<regs::Tafcr, crate::common::RW> {
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x40usize) as _) }
}
#[doc = "Backup register"]
#[inline(always)]
pub const fn bkpr(self, n: usize) -> crate::common::Reg<regs::Bkpr, crate::common::RW> {
assert!(n < 20usize);
unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x50usize + n * 4usize) as _) }
}
}
pub mod regs {
#[doc = "Alarm register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Alrmr(pub u32);
impl Alrmr {
#[doc = "Second units in BCD format"]
#[inline(always)]
pub const fn su(&self) -> u8 {
let val = (self.0 >> 0usize) & 0x0f;
val as u8
}
#[doc = "Second units in BCD format"]
#[inline(always)]
pub fn set_su(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 0usize)) | (((val as u32) & 0x0f) << 0usize);
}
#[doc = "Second tens in BCD format"]
#[inline(always)]
pub const fn st(&self) -> u8 {
let val = (self.0 >> 4usize) & 0x07;
val as u8
}
#[doc = "Second tens in BCD format"]
#[inline(always)]
pub fn set_st(&mut self, val: u8) {
self.0 = (self.0 & !(0x07 << 4usize)) | (((val as u32) & 0x07) << 4usize);
}
#[doc = "Alarm seconds mask"]
#[inline(always)]
pub const fn msk1(&self) -> super::vals::AlrmrMsk {
let val = (self.0 >> 7usize) & 0x01;
super::vals::AlrmrMsk::from_bits(val as u8)
}
#[doc = "Alarm seconds mask"]
#[inline(always)]
pub fn set_msk1(&mut self, val: super::vals::AlrmrMsk) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val.to_bits() as u32) & 0x01) << 7usize);
}
#[doc = "Minute units in BCD format"]
#[inline(always)]
pub const fn mnu(&self) -> u8 {
let val = (self.0 >> 8usize) & 0x0f;
val as u8
}
#[doc = "Minute units in BCD format"]
#[inline(always)]
pub fn set_mnu(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 8usize)) | (((val as u32) & 0x0f) << 8usize);
}
#[doc = "Minute tens in BCD format"]
#[inline(always)]
pub const fn mnt(&self) -> u8 {
let val = (self.0 >> 12usize) & 0x07;
val as u8
}
#[doc = "Minute tens in BCD format"]
#[inline(always)]
pub fn set_mnt(&mut self, val: u8) {
self.0 = (self.0 & !(0x07 << 12usize)) | (((val as u32) & 0x07) << 12usize);
}
#[doc = "Alarm minutes mask"]
#[inline(always)]
pub const fn msk2(&self) -> super::vals::AlrmrMsk {
let val = (self.0 >> 15usize) & 0x01;
super::vals::AlrmrMsk::from_bits(val as u8)
}
#[doc = "Alarm minutes mask"]
#[inline(always)]
pub fn set_msk2(&mut self, val: super::vals::AlrmrMsk) {
self.0 = (self.0 & !(0x01 << 15usize)) | (((val.to_bits() as u32) & 0x01) << 15usize);
}
#[doc = "Hour units in BCD format"]
#[inline(always)]
pub const fn hu(&self) -> u8 {
let val = (self.0 >> 16usize) & 0x0f;
val as u8
}
#[doc = "Hour units in BCD format"]
#[inline(always)]
pub fn set_hu(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 16usize)) | (((val as u32) & 0x0f) << 16usize);
}
#[doc = "Hour tens in BCD format"]
#[inline(always)]
pub const fn ht(&self) -> u8 {
let val = (self.0 >> 20usize) & 0x03;
val as u8
}
#[doc = "Hour tens in BCD format"]
#[inline(always)]
pub fn set_ht(&mut self, val: u8) {
self.0 = (self.0 & !(0x03 << 20usize)) | (((val as u32) & 0x03) << 20usize);
}
#[doc = "AM/PM notation"]
#[inline(always)]
pub const fn pm(&self) -> super::vals::AlrmrPm {
let val = (self.0 >> 22usize) & 0x01;
super::vals::AlrmrPm::from_bits(val as u8)
}
#[doc = "AM/PM notation"]
#[inline(always)]
pub fn set_pm(&mut self, val: super::vals::AlrmrPm) {
self.0 = (self.0 & !(0x01 << 22usize)) | (((val.to_bits() as u32) & 0x01) << 22usize);
}
#[doc = "Alarm hours mask"]
#[inline(always)]
pub const fn msk3(&self) -> super::vals::AlrmrMsk {
let val = (self.0 >> 23usize) & 0x01;
super::vals::AlrmrMsk::from_bits(val as u8)
}
#[doc = "Alarm hours mask"]
#[inline(always)]
pub fn set_msk3(&mut self, val: super::vals::AlrmrMsk) {
self.0 = (self.0 & !(0x01 << 23usize)) | (((val.to_bits() as u32) & 0x01) << 23usize);
}
#[doc = "Date units or day in BCD format"]
#[inline(always)]
pub const fn du(&self) -> u8 {
let val = (self.0 >> 24usize) & 0x0f;
val as u8
}
#[doc = "Date units or day in BCD format"]
#[inline(always)]
pub fn set_du(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 24usize)) | (((val as u32) & 0x0f) << 24usize);
}
#[doc = "Date tens in BCD format"]
#[inline(always)]
pub const fn dt(&self) -> u8 {
let val = (self.0 >> 28usize) & 0x03;
val as u8
}
#[doc = "Date tens in BCD format"]
#[inline(always)]
pub fn set_dt(&mut self, val: u8) {
self.0 = (self.0 & !(0x03 << 28usize)) | (((val as u32) & 0x03) << 28usize);
}
#[doc = "Week day selection"]
#[inline(always)]
pub const fn wdsel(&self) -> super::vals::AlrmrWdsel {
let val = (self.0 >> 30usize) & 0x01;
super::vals::AlrmrWdsel::from_bits(val as u8)
}
#[doc = "Week day selection"]
#[inline(always)]
pub fn set_wdsel(&mut self, val: super::vals::AlrmrWdsel) {
self.0 = (self.0 & !(0x01 << 30usize)) | (((val.to_bits() as u32) & 0x01) << 30usize);
}
#[doc = "Alarm date mask"]
#[inline(always)]
pub const fn msk4(&self) -> super::vals::AlrmrMsk {
let val = (self.0 >> 31usize) & 0x01;
super::vals::AlrmrMsk::from_bits(val as u8)
}
#[doc = "Alarm date mask"]
#[inline(always)]
pub fn set_msk4(&mut self, val: super::vals::AlrmrMsk) {
self.0 = (self.0 & !(0x01 << 31usize)) | (((val.to_bits() as u32) & 0x01) << 31usize);
}
}
impl Default for Alrmr {
#[inline(always)]
fn default() -> Alrmr {
Alrmr(0)
}
}
impl core::fmt::Debug for Alrmr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Alrmr")
.field("su", &self.su())
.field("st", &self.st())
.field("msk1", &self.msk1())
.field("mnu", &self.mnu())
.field("mnt", &self.mnt())
.field("msk2", &self.msk2())
.field("hu", &self.hu())
.field("ht", &self.ht())
.field("pm", &self.pm())
.field("msk3", &self.msk3())
.field("du", &self.du())
.field("dt", &self.dt())
.field("wdsel", &self.wdsel())
.field("msk4", &self.msk4())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Alrmr {
fn format(&self, f: defmt::Formatter) {
defmt :: write ! (f , "Alrmr {{ su: {=u8:?}, st: {=u8:?}, msk1: {:?}, mnu: {=u8:?}, mnt: {=u8:?}, msk2: {:?}, hu: {=u8:?}, ht: {=u8:?}, pm: {:?}, msk3: {:?}, du: {=u8:?}, dt: {=u8:?}, wdsel: {:?}, msk4: {:?} }}" , self . su () , self . st () , self . msk1 () , self . mnu () , self . mnt () , self . msk2 () , self . hu () , self . ht () , self . pm () , self . msk3 () , self . du () , self . dt () , self . wdsel () , self . msk4 ())
}
}
#[doc = "Backup register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Bkpr(pub u32);
impl Bkpr {
#[doc = "BKP"]
#[inline(always)]
pub const fn bkp(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "BKP"]
#[inline(always)]
pub fn set_bkp(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Bkpr {
#[inline(always)]
fn default() -> Bkpr {
Bkpr(0)
}
}
impl core::fmt::Debug for Bkpr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Bkpr").field("bkp", &self.bkp()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Bkpr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Bkpr {{ bkp: {=u32:?} }}", self.bkp())
}
}
#[doc = "Calibration register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Calibr(pub u32);
impl Calibr {
#[doc = "Digital calibration"]
#[inline(always)]
pub const fn dc(&self) -> u8 {
let val = (self.0 >> 0usize) & 0x1f;
val as u8
}
#[doc = "Digital calibration"]
#[inline(always)]
pub fn set_dc(&mut self, val: u8) {
self.0 = (self.0 & !(0x1f << 0usize)) | (((val as u32) & 0x1f) << 0usize);
}
#[doc = "Digital calibration sign"]
#[inline(always)]
pub const fn dcs(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "Digital calibration sign"]
#[inline(always)]
pub fn set_dcs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
}
impl Default for Calibr {
#[inline(always)]
fn default() -> Calibr {
Calibr(0)
}
}
impl core::fmt::Debug for Calibr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Calibr")
.field("dc", &self.dc())
.field("dcs", &self.dcs())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Calibr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Calibr {{ dc: {=u8:?}, dcs: {=bool:?} }}", self.dc(), self.dcs())
}
}
#[doc = "Control register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cr(pub u32);
impl Cr {
#[doc = "Wakeup clock selection"]
#[inline(always)]
pub const fn wucksel(&self) -> super::vals::Wucksel {
let val = (self.0 >> 0usize) & 0x07;
super::vals::Wucksel::from_bits(val as u8)
}
#[doc = "Wakeup clock selection"]
#[inline(always)]
pub fn set_wucksel(&mut self, val: super::vals::Wucksel) {
self.0 = (self.0 & !(0x07 << 0usize)) | (((val.to_bits() as u32) & 0x07) << 0usize);
}
#[doc = "Timestamp event active edge"]
#[inline(always)]
pub const fn tsedge(&self) -> super::vals::Tsedge {
let val = (self.0 >> 3usize) & 0x01;
super::vals::Tsedge::from_bits(val as u8)
}
#[doc = "Timestamp event active edge"]
#[inline(always)]
pub fn set_tsedge(&mut self, val: super::vals::Tsedge) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val.to_bits() as u32) & 0x01) << 3usize);
}
#[doc = "Reference clock detection enable (50 or 60 Hz)"]
#[inline(always)]
pub const fn refckon(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "Reference clock detection enable (50 or 60 Hz)"]
#[inline(always)]
pub fn set_refckon(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "Hour format"]
#[inline(always)]
pub const fn fmt(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "Hour format"]
#[inline(always)]
pub fn set_fmt(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "Coarse digital calibration enable"]
#[inline(always)]
pub const fn dce(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "Coarse digital calibration enable"]
#[inline(always)]
pub fn set_dce(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
#[doc = "Alarm enable"]
#[inline(always)]
pub const fn alre(&self, n: usize) -> bool {
assert!(n < 2usize);
let offs = 8usize + n * 1usize;
let val = (self.0 >> offs) & 0x01;
val != 0
}
#[doc = "Alarm enable"]
#[inline(always)]
pub fn set_alre(&mut self, n: usize, val: bool) {
assert!(n < 2usize);
let offs = 8usize + n * 1usize;
self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
}
#[doc = "Wakeup timer enable"]
#[inline(always)]
pub const fn wute(&self) -> bool {
let val = (self.0 >> 10usize) & 0x01;
val != 0
}
#[doc = "Wakeup timer enable"]
#[inline(always)]
pub fn set_wute(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
}
#[doc = "Timestamp enable"]
#[inline(always)]
pub const fn tse(&self) -> bool {
let val = (self.0 >> 11usize) & 0x01;
val != 0
}
#[doc = "Timestamp enable"]
#[inline(always)]
pub fn set_tse(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
}
#[doc = "Alarm interrupt enable"]
#[inline(always)]
pub const fn alrie(&self, n: usize) -> bool {
assert!(n < 2usize);
let offs = 12usize + n * 1usize;
let val = (self.0 >> offs) & 0x01;
val != 0
}
#[doc = "Alarm interrupt enable"]
#[inline(always)]
pub fn set_alrie(&mut self, n: usize, val: bool) {
assert!(n < 2usize);
let offs = 12usize + n * 1usize;
self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
}
#[doc = "Wakeup timer interrupt enable"]
#[inline(always)]
pub const fn wutie(&self) -> bool {
let val = (self.0 >> 14usize) & 0x01;
val != 0
}
#[doc = "Wakeup timer interrupt enable"]
#[inline(always)]
pub fn set_wutie(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 14usize)) | (((val as u32) & 0x01) << 14usize);
}
#[doc = "Timestamp interrupt enable"]
#[inline(always)]
pub const fn tsie(&self) -> bool {
let val = (self.0 >> 15usize) & 0x01;
val != 0
}
#[doc = "Timestamp interrupt enable"]
#[inline(always)]
pub fn set_tsie(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 15usize)) | (((val as u32) & 0x01) << 15usize);
}
#[doc = "Add 1 hour (summer time change)"]
#[inline(always)]
pub const fn add1h(&self) -> bool {
let val = (self.0 >> 16usize) & 0x01;
val != 0
}
#[doc = "Add 1 hour (summer time change)"]
#[inline(always)]
pub fn set_add1h(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
}
#[doc = "Subtract 1 hour (winter time change)"]
#[inline(always)]
pub const fn sub1h(&self) -> bool {
let val = (self.0 >> 17usize) & 0x01;
val != 0
}
#[doc = "Subtract 1 hour (winter time change)"]
#[inline(always)]
pub fn set_sub1h(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
}
#[doc = "Backup"]
#[inline(always)]
pub const fn bkp(&self) -> bool {
let val = (self.0 >> 18usize) & 0x01;
val != 0
}
#[doc = "Backup"]
#[inline(always)]
pub fn set_bkp(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
}
#[doc = "Output polarity"]
#[inline(always)]
pub const fn pol(&self) -> super::vals::Pol {
let val = (self.0 >> 20usize) & 0x01;
super::vals::Pol::from_bits(val as u8)
}
#[doc = "Output polarity"]
#[inline(always)]
pub fn set_pol(&mut self, val: super::vals::Pol) {
self.0 = (self.0 & !(0x01 << 20usize)) | (((val.to_bits() as u32) & 0x01) << 20usize);
}
#[doc = "Output selection"]
#[inline(always)]
pub const fn osel(&self) -> super::vals::Osel {
let val = (self.0 >> 21usize) & 0x03;
super::vals::Osel::from_bits(val as u8)
}
#[doc = "Output selection"]
#[inline(always)]
pub fn set_osel(&mut self, val: super::vals::Osel) {
self.0 = (self.0 & !(0x03 << 21usize)) | (((val.to_bits() as u32) & 0x03) << 21usize);
}
#[doc = "Calibration output enable"]
#[inline(always)]
pub const fn coe(&self) -> bool {
let val = (self.0 >> 23usize) & 0x01;
val != 0
}
#[doc = "Calibration output enable"]
#[inline(always)]
pub fn set_coe(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 23usize)) | (((val as u32) & 0x01) << 23usize);
}
}
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("wucksel", &self.wucksel())
.field("tsedge", &self.tsedge())
.field("refckon", &self.refckon())
.field("fmt", &self.fmt())
.field("dce", &self.dce())
.field("alre[0]", &self.alre(0usize))
.field("alre[1]", &self.alre(1usize))
.field("wute", &self.wute())
.field("tse", &self.tse())
.field("alrie[0]", &self.alrie(0usize))
.field("alrie[1]", &self.alrie(1usize))
.field("wutie", &self.wutie())
.field("tsie", &self.tsie())
.field("add1h", &self.add1h())
.field("sub1h", &self.sub1h())
.field("bkp", &self.bkp())
.field("pol", &self.pol())
.field("osel", &self.osel())
.field("coe", &self.coe())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Cr {
fn format(&self, f: defmt::Formatter) {
defmt :: write ! (f , "Cr {{ wucksel: {:?}, tsedge: {:?}, refckon: {=bool:?}, fmt: {=bool:?}, dce: {=bool:?}, alre[0]: {=bool:?}, alre[1]: {=bool:?}, wute: {=bool:?}, tse: {=bool:?}, alrie[0]: {=bool:?}, alrie[1]: {=bool:?}, wutie: {=bool:?}, tsie: {=bool:?}, add1h: {=bool:?}, sub1h: {=bool:?}, bkp: {=bool:?}, pol: {:?}, osel: {:?}, coe: {=bool:?} }}" , self . wucksel () , self . tsedge () , self . refckon () , self . fmt () , self . dce () , self . alre (0usize) , self . alre (1usize) , self . wute () , self . tse () , self . alrie (0usize) , self . alrie (1usize) , self . wutie () , self . tsie () , self . add1h () , self . sub1h () , self . bkp () , self . pol () , self . osel () , self . coe ())
}
}
#[doc = "Date register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Dr(pub u32);
impl Dr {
#[doc = "Date units in BCD format"]
#[inline(always)]
pub const fn du(&self) -> u8 {
let val = (self.0 >> 0usize) & 0x0f;
val as u8
}
#[doc = "Date units in BCD format"]
#[inline(always)]
pub fn set_du(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 0usize)) | (((val as u32) & 0x0f) << 0usize);
}
#[doc = "Date tens in BCD format"]
#[inline(always)]
pub const fn dt(&self) -> u8 {
let val = (self.0 >> 4usize) & 0x03;
val as u8
}
#[doc = "Date tens in BCD format"]
#[inline(always)]
pub fn set_dt(&mut self, val: u8) {
self.0 = (self.0 & !(0x03 << 4usize)) | (((val as u32) & 0x03) << 4usize);
}
#[doc = "Month units in BCD format"]
#[inline(always)]
pub const fn mu(&self) -> u8 {
let val = (self.0 >> 8usize) & 0x0f;
val as u8
}
#[doc = "Month units in BCD format"]
#[inline(always)]
pub fn set_mu(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 8usize)) | (((val as u32) & 0x0f) << 8usize);
}
#[doc = "Month tens in BCD format"]
#[inline(always)]
pub const fn mt(&self) -> bool {
let val = (self.0 >> 12usize) & 0x01;
val != 0
}
#[doc = "Month tens in BCD format"]
#[inline(always)]
pub fn set_mt(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
}
#[doc = "Week day units"]
#[inline(always)]
pub const fn wdu(&self) -> u8 {
let val = (self.0 >> 13usize) & 0x07;
val as u8
}
#[doc = "Week day units"]
#[inline(always)]
pub fn set_wdu(&mut self, val: u8) {
self.0 = (self.0 & !(0x07 << 13usize)) | (((val as u32) & 0x07) << 13usize);
}
#[doc = "Year units in BCD format"]
#[inline(always)]
pub const fn yu(&self) -> u8 {
let val = (self.0 >> 16usize) & 0x0f;
val as u8
}
#[doc = "Year units in BCD format"]
#[inline(always)]
pub fn set_yu(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 16usize)) | (((val as u32) & 0x0f) << 16usize);
}
#[doc = "Year tens in BCD format"]
#[inline(always)]
pub const fn yt(&self) -> u8 {
let val = (self.0 >> 20usize) & 0x0f;
val as u8
}
#[doc = "Year tens in BCD format"]
#[inline(always)]
pub fn set_yt(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 20usize)) | (((val as u32) & 0x0f) << 20usize);
}
}
impl Default for Dr {
#[inline(always)]
fn default() -> Dr {
Dr(0)
}
}
impl core::fmt::Debug for Dr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Dr")
.field("du", &self.du())
.field("dt", &self.dt())
.field("mu", &self.mu())
.field("mt", &self.mt())
.field("wdu", &self.wdu())
.field("yu", &self.yu())
.field("yt", &self.yt())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Dr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Dr {{ du: {=u8:?}, dt: {=u8:?}, mu: {=u8:?}, mt: {=bool:?}, wdu: {=u8:?}, yu: {=u8:?}, yt: {=u8:?} }}",
self.du(),
self.dt(),
self.mu(),
self.mt(),
self.wdu(),
self.yu(),
self.yt()
)
}
}
#[doc = "Initialization and status register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Isr(pub u32);
impl Isr {
#[doc = "Alarm write enabled"]
#[inline(always)]
pub const fn alrwf(&self, n: usize) -> bool {
assert!(n < 2usize);
let offs = 0usize + n * 1usize;
let val = (self.0 >> offs) & 0x01;
val != 0
}
#[doc = "Alarm write enabled"]
#[inline(always)]
pub fn set_alrwf(&mut self, n: usize, val: bool) {
assert!(n < 2usize);
let offs = 0usize + n * 1usize;
self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
}
#[doc = "Wakeup timer write enabled"]
#[inline(always)]
pub const fn wutwf(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Wakeup timer write enabled"]
#[inline(always)]
pub fn set_wutwf(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "Initialization status flag"]
#[inline(always)]
pub const fn inits(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "Initialization status flag"]
#[inline(always)]
pub fn set_inits(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "Registers synchronization flag"]
#[inline(always)]
pub const fn rsf(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "Registers synchronization flag"]
#[inline(always)]
pub fn set_rsf(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "Initialization flag"]
#[inline(always)]
pub const fn initf(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "Initialization flag"]
#[inline(always)]
pub fn set_initf(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "Enter Initialization mode"]
#[inline(always)]
pub const fn init(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "Enter Initialization mode"]
#[inline(always)]
pub fn set_init(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
#[doc = "Alarm flag"]
#[inline(always)]
pub const fn alrf(&self, n: usize) -> bool {
assert!(n < 2usize);
let offs = 8usize + n * 1usize;
let val = (self.0 >> offs) & 0x01;
val != 0
}
#[doc = "Alarm flag"]
#[inline(always)]
pub fn set_alrf(&mut self, n: usize, val: bool) {
assert!(n < 2usize);
let offs = 8usize + n * 1usize;
self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
}
#[doc = "Wakeup timer flag"]
#[inline(always)]
pub const fn wutf(&self) -> bool {
let val = (self.0 >> 10usize) & 0x01;
val != 0
}
#[doc = "Wakeup timer flag"]
#[inline(always)]
pub fn set_wutf(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
}
#[doc = "Timestamp flag"]
#[inline(always)]
pub const fn tsf(&self) -> bool {
let val = (self.0 >> 11usize) & 0x01;
val != 0
}
#[doc = "Timestamp flag"]
#[inline(always)]
pub fn set_tsf(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
}
#[doc = "Timestamp overflow flag"]
#[inline(always)]
pub const fn tsovf(&self) -> bool {
let val = (self.0 >> 12usize) & 0x01;
val != 0
}
#[doc = "Timestamp overflow flag"]
#[inline(always)]
pub fn set_tsovf(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
}
#[doc = "Tamper detection flag"]
#[inline(always)]
pub const fn tampf(&self, n: usize) -> bool {
assert!(n < 1usize);
let offs = 13usize + n * 1usize;
let val = (self.0 >> offs) & 0x01;
val != 0
}
#[doc = "Tamper detection flag"]
#[inline(always)]
pub fn set_tampf(&mut self, n: usize, val: bool) {
assert!(n < 1usize);
let offs = 13usize + n * 1usize;
self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
}
}
impl Default for Isr {
#[inline(always)]
fn default() -> Isr {
Isr(0)
}
}
impl core::fmt::Debug for Isr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Isr")
.field("alrwf[0]", &self.alrwf(0usize))
.field("alrwf[1]", &self.alrwf(1usize))
.field("wutwf", &self.wutwf())
.field("inits", &self.inits())
.field("rsf", &self.rsf())
.field("initf", &self.initf())
.field("init", &self.init())
.field("alrf[0]", &self.alrf(0usize))
.field("alrf[1]", &self.alrf(1usize))
.field("wutf", &self.wutf())
.field("tsf", &self.tsf())
.field("tsovf", &self.tsovf())
.field("tampf[0]", &self.tampf(0usize))
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Isr {
fn format(&self, f: defmt::Formatter) {
defmt :: write ! (f , "Isr {{ alrwf[0]: {=bool:?}, alrwf[1]: {=bool:?}, wutwf: {=bool:?}, inits: {=bool:?}, rsf: {=bool:?}, initf: {=bool:?}, init: {=bool:?}, alrf[0]: {=bool:?}, alrf[1]: {=bool:?}, wutf: {=bool:?}, tsf: {=bool:?}, tsovf: {=bool:?}, tampf[0]: {=bool:?} }}" , self . alrwf (0usize) , self . alrwf (1usize) , self . wutwf () , self . inits () , self . rsf () , self . initf () , self . init () , self . alrf (0usize) , self . alrf (1usize) , self . wutf () , self . tsf () , self . tsovf () , self . tampf (0usize))
}
}
#[doc = "Prescaler register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Prer(pub u32);
impl Prer {
#[doc = "Synchronous prescaler factor"]
#[inline(always)]
pub const fn prediv_s(&self) -> u16 {
let val = (self.0 >> 0usize) & 0x7fff;
val as u16
}
#[doc = "Synchronous prescaler factor"]
#[inline(always)]
pub fn set_prediv_s(&mut self, val: u16) {
self.0 = (self.0 & !(0x7fff << 0usize)) | (((val as u32) & 0x7fff) << 0usize);
}
#[doc = "Asynchronous prescaler factor"]
#[inline(always)]
pub const fn prediv_a(&self) -> u8 {
let val = (self.0 >> 16usize) & 0x7f;
val as u8
}
#[doc = "Asynchronous prescaler factor"]
#[inline(always)]
pub fn set_prediv_a(&mut self, val: u8) {
self.0 = (self.0 & !(0x7f << 16usize)) | (((val as u32) & 0x7f) << 16usize);
}
}
impl Default for Prer {
#[inline(always)]
fn default() -> Prer {
Prer(0)
}
}
impl core::fmt::Debug for Prer {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Prer")
.field("prediv_s", &self.prediv_s())
.field("prediv_a", &self.prediv_a())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Prer {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Prer {{ prediv_s: {=u16:?}, prediv_a: {=u8:?} }}",
self.prediv_s(),
self.prediv_a()
)
}
}
#[doc = "Tamper and alternate function configuration register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Tafcr(pub u32);
impl Tafcr {
#[doc = "Tamper detection enable"]
#[inline(always)]
pub const fn tampe(&self, n: usize) -> bool {
assert!(n < 1usize);
let offs = 0usize + ([0usize][n] as usize);
let val = (self.0 >> offs) & 0x01;
val != 0
}
#[doc = "Tamper detection enable"]
#[inline(always)]
pub fn set_tampe(&mut self, n: usize, val: bool) {
assert!(n < 1usize);
let offs = 0usize + ([0usize][n] as usize);
self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
}
#[doc = "Active level for tamper"]
#[inline(always)]
pub const fn tamptrg(&self, n: usize) -> super::vals::Tamptrg {
assert!(n < 1usize);
let offs = 1usize + ([0usize][n] as usize);
let val = (self.0 >> offs) & 0x01;
super::vals::Tamptrg::from_bits(val as u8)
}
#[doc = "Active level for tamper"]
#[inline(always)]
pub fn set_tamptrg(&mut self, n: usize, val: super::vals::Tamptrg) {
assert!(n < 1usize);
let offs = 1usize + ([0usize][n] as usize);
self.0 = (self.0 & !(0x01 << offs)) | (((val.to_bits() as u32) & 0x01) << offs);
}
#[doc = "Tamper interrupt enable"]
#[inline(always)]
pub const fn tampie(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Tamper interrupt enable"]
#[inline(always)]
pub fn set_tampie(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "Tamper 1 mapping"]
#[inline(always)]
pub const fn tamp1insel(&self) -> bool {
let val = (self.0 >> 16usize) & 0x01;
val != 0
}
#[doc = "Tamper 1 mapping"]
#[inline(always)]
pub fn set_tamp1insel(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
}
#[doc = "Timestamp mapping"]
#[inline(always)]
pub const fn tsinsel(&self) -> bool {
let val = (self.0 >> 17usize) & 0x01;
val != 0
}
#[doc = "Timestamp mapping"]
#[inline(always)]
pub fn set_tsinsel(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
}
#[doc = "AFO_ALARM output type"]
#[inline(always)]
pub const fn alarmouttype(&self) -> bool {
let val = (self.0 >> 18usize) & 0x01;
val != 0
}
#[doc = "AFO_ALARM output type"]
#[inline(always)]
pub fn set_alarmouttype(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
}
}
impl Default for Tafcr {
#[inline(always)]
fn default() -> Tafcr {
Tafcr(0)
}
}
impl core::fmt::Debug for Tafcr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Tafcr")
.field("tampe[0]", &self.tampe(0usize))
.field("tamptrg[0]", &self.tamptrg(0usize))
.field("tampie", &self.tampie())
.field("tamp1insel", &self.tamp1insel())
.field("tsinsel", &self.tsinsel())
.field("alarmouttype", &self.alarmouttype())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Tafcr {
fn format(&self, f: defmt::Formatter) {
defmt :: write ! (f , "Tafcr {{ tampe[0]: {=bool:?}, tamptrg[0]: {:?}, tampie: {=bool:?}, tamp1insel: {=bool:?}, tsinsel: {=bool:?}, alarmouttype: {=bool:?} }}" , self . tampe (0usize) , self . tamptrg (0usize) , self . tampie () , self . tamp1insel () , self . tsinsel () , self . alarmouttype ())
}
}
#[doc = "Time register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Tr(pub u32);
impl Tr {
#[doc = "Second units in BCD format"]
#[inline(always)]
pub const fn su(&self) -> u8 {
let val = (self.0 >> 0usize) & 0x0f;
val as u8
}
#[doc = "Second units in BCD format"]
#[inline(always)]
pub fn set_su(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 0usize)) | (((val as u32) & 0x0f) << 0usize);
}
#[doc = "Second tens in BCD format"]
#[inline(always)]
pub const fn st(&self) -> u8 {
let val = (self.0 >> 4usize) & 0x07;
val as u8
}
#[doc = "Second tens in BCD format"]
#[inline(always)]
pub fn set_st(&mut self, val: u8) {
self.0 = (self.0 & !(0x07 << 4usize)) | (((val as u32) & 0x07) << 4usize);
}
#[doc = "Minute units in BCD format"]
#[inline(always)]
pub const fn mnu(&self) -> u8 {
let val = (self.0 >> 8usize) & 0x0f;
val as u8
}
#[doc = "Minute units in BCD format"]
#[inline(always)]
pub fn set_mnu(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 8usize)) | (((val as u32) & 0x0f) << 8usize);
}
#[doc = "Minute tens in BCD format"]
#[inline(always)]
pub const fn mnt(&self) -> u8 {
let val = (self.0 >> 12usize) & 0x07;
val as u8
}
#[doc = "Minute tens in BCD format"]
#[inline(always)]
pub fn set_mnt(&mut self, val: u8) {
self.0 = (self.0 & !(0x07 << 12usize)) | (((val as u32) & 0x07) << 12usize);
}
#[doc = "Hour units in BCD format"]
#[inline(always)]
pub const fn hu(&self) -> u8 {
let val = (self.0 >> 16usize) & 0x0f;
val as u8
}
#[doc = "Hour units in BCD format"]
#[inline(always)]
pub fn set_hu(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 16usize)) | (((val as u32) & 0x0f) << 16usize);
}
#[doc = "Hour tens in BCD format"]
#[inline(always)]
pub const fn ht(&self) -> u8 {
let val = (self.0 >> 20usize) & 0x03;
val as u8
}
#[doc = "Hour tens in BCD format"]
#[inline(always)]
pub fn set_ht(&mut self, val: u8) {
self.0 = (self.0 & !(0x03 << 20usize)) | (((val as u32) & 0x03) << 20usize);
}
#[doc = "AM/PM notation"]
#[inline(always)]
pub const fn pm(&self) -> super::vals::Ampm {
let val = (self.0 >> 22usize) & 0x01;
super::vals::Ampm::from_bits(val as u8)
}
#[doc = "AM/PM notation"]
#[inline(always)]
pub fn set_pm(&mut self, val: super::vals::Ampm) {
self.0 = (self.0 & !(0x01 << 22usize)) | (((val.to_bits() as u32) & 0x01) << 22usize);
}
}
impl Default for Tr {
#[inline(always)]
fn default() -> Tr {
Tr(0)
}
}
impl core::fmt::Debug for Tr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Tr")
.field("su", &self.su())
.field("st", &self.st())
.field("mnu", &self.mnu())
.field("mnt", &self.mnt())
.field("hu", &self.hu())
.field("ht", &self.ht())
.field("pm", &self.pm())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Tr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Tr {{ su: {=u8:?}, st: {=u8:?}, mnu: {=u8:?}, mnt: {=u8:?}, hu: {=u8:?}, ht: {=u8:?}, pm: {:?} }}",
self.su(),
self.st(),
self.mnu(),
self.mnt(),
self.hu(),
self.ht(),
self.pm()
)
}
}
#[doc = "Timestamp date register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Tsdr(pub u32);
impl Tsdr {
#[doc = "Date units in BCD format"]
#[inline(always)]
pub const fn du(&self) -> u8 {
let val = (self.0 >> 0usize) & 0x0f;
val as u8
}
#[doc = "Date units in BCD format"]
#[inline(always)]
pub fn set_du(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 0usize)) | (((val as u32) & 0x0f) << 0usize);
}
#[doc = "Date tens in BCD format"]
#[inline(always)]
pub const fn dt(&self) -> u8 {
let val = (self.0 >> 4usize) & 0x03;
val as u8
}
#[doc = "Date tens in BCD format"]
#[inline(always)]
pub fn set_dt(&mut self, val: u8) {
self.0 = (self.0 & !(0x03 << 4usize)) | (((val as u32) & 0x03) << 4usize);
}
#[doc = "Month units in BCD format"]
#[inline(always)]
pub const fn mu(&self) -> u8 {
let val = (self.0 >> 8usize) & 0x0f;
val as u8
}
#[doc = "Month units in BCD format"]
#[inline(always)]
pub fn set_mu(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 8usize)) | (((val as u32) & 0x0f) << 8usize);
}
#[doc = "Month tens in BCD format"]
#[inline(always)]
pub const fn mt(&self) -> bool {
let val = (self.0 >> 12usize) & 0x01;
val != 0
}
#[doc = "Month tens in BCD format"]
#[inline(always)]
pub fn set_mt(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
}
#[doc = "Week day units"]
#[inline(always)]
pub const fn wdu(&self) -> u8 {
let val = (self.0 >> 13usize) & 0x07;
val as u8
}
#[doc = "Week day units"]
#[inline(always)]
pub fn set_wdu(&mut self, val: u8) {
self.0 = (self.0 & !(0x07 << 13usize)) | (((val as u32) & 0x07) << 13usize);
}
}
impl Default for Tsdr {
#[inline(always)]
fn default() -> Tsdr {
Tsdr(0)
}
}
impl core::fmt::Debug for Tsdr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Tsdr")
.field("du", &self.du())
.field("dt", &self.dt())
.field("mu", &self.mu())
.field("mt", &self.mt())
.field("wdu", &self.wdu())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Tsdr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Tsdr {{ du: {=u8:?}, dt: {=u8:?}, mu: {=u8:?}, mt: {=bool:?}, wdu: {=u8:?} }}",
self.du(),
self.dt(),
self.mu(),
self.mt(),
self.wdu()
)
}
}
#[doc = "Timestamp time register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Tstr(pub u32);
impl Tstr {
#[doc = "Second units in BCD format"]
#[inline(always)]
pub const fn su(&self) -> u8 {
let val = (self.0 >> 0usize) & 0x0f;
val as u8
}
#[doc = "Second units in BCD format"]
#[inline(always)]
pub fn set_su(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 0usize)) | (((val as u32) & 0x0f) << 0usize);
}
#[doc = "Second tens in BCD format"]
#[inline(always)]
pub const fn st(&self) -> u8 {
let val = (self.0 >> 4usize) & 0x07;
val as u8
}
#[doc = "Second tens in BCD format"]
#[inline(always)]
pub fn set_st(&mut self, val: u8) {
self.0 = (self.0 & !(0x07 << 4usize)) | (((val as u32) & 0x07) << 4usize);
}
#[doc = "Minute units in BCD format"]
#[inline(always)]
pub const fn mnu(&self) -> u8 {
let val = (self.0 >> 8usize) & 0x0f;
val as u8
}
#[doc = "Minute units in BCD format"]
#[inline(always)]
pub fn set_mnu(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 8usize)) | (((val as u32) & 0x0f) << 8usize);
}
#[doc = "Minute tens in BCD format"]
#[inline(always)]
pub const fn mnt(&self) -> u8 {
let val = (self.0 >> 12usize) & 0x07;
val as u8
}
#[doc = "Minute tens in BCD format"]
#[inline(always)]
pub fn set_mnt(&mut self, val: u8) {
self.0 = (self.0 & !(0x07 << 12usize)) | (((val as u32) & 0x07) << 12usize);
}
#[doc = "Hour units in BCD format"]
#[inline(always)]
pub const fn hu(&self) -> u8 {
let val = (self.0 >> 16usize) & 0x0f;
val as u8
}
#[doc = "Hour units in BCD format"]
#[inline(always)]
pub fn set_hu(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 16usize)) | (((val as u32) & 0x0f) << 16usize);
}
#[doc = "Hour tens in BCD format"]
#[inline(always)]
pub const fn ht(&self) -> u8 {
let val = (self.0 >> 20usize) & 0x03;
val as u8
}
#[doc = "Hour tens in BCD format"]
#[inline(always)]
pub fn set_ht(&mut self, val: u8) {
self.0 = (self.0 & !(0x03 << 20usize)) | (((val as u32) & 0x03) << 20usize);
}
#[doc = "AM/PM notation"]
#[inline(always)]
pub const fn pm(&self) -> super::vals::Ampm {
let val = (self.0 >> 22usize) & 0x01;
super::vals::Ampm::from_bits(val as u8)
}
#[doc = "AM/PM notation"]
#[inline(always)]
pub fn set_pm(&mut self, val: super::vals::Ampm) {
self.0 = (self.0 & !(0x01 << 22usize)) | (((val.to_bits() as u32) & 0x01) << 22usize);
}
}
impl Default for Tstr {
#[inline(always)]
fn default() -> Tstr {
Tstr(0)
}
}
impl core::fmt::Debug for Tstr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Tstr")
.field("su", &self.su())
.field("st", &self.st())
.field("mnu", &self.mnu())
.field("mnt", &self.mnt())
.field("hu", &self.hu())
.field("ht", &self.ht())
.field("pm", &self.pm())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Tstr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Tstr {{ su: {=u8:?}, st: {=u8:?}, mnu: {=u8:?}, mnt: {=u8:?}, hu: {=u8:?}, ht: {=u8:?}, pm: {:?} }}",
self.su(),
self.st(),
self.mnu(),
self.mnt(),
self.hu(),
self.ht(),
self.pm()
)
}
}
#[doc = "Write protection register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Wpr(pub u32);
impl Wpr {
#[doc = "Write protection key"]
#[inline(always)]
pub const fn key(&self) -> u8 {
let val = (self.0 >> 0usize) & 0xff;
val as u8
}
#[doc = "Write protection key"]
#[inline(always)]
pub fn set_key(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 0usize)) | (((val as u32) & 0xff) << 0usize);
}
}
impl Default for Wpr {
#[inline(always)]
fn default() -> Wpr {
Wpr(0)
}
}
impl core::fmt::Debug for Wpr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Wpr").field("key", &self.key()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Wpr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Wpr {{ key: {=u8:?} }}", self.key())
}
}
#[doc = "Wakeup timer register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Wutr(pub u32);
impl Wutr {
#[doc = "Wakeup auto-reload value bits"]
#[inline(always)]
pub const fn wut(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[doc = "Wakeup auto-reload value bits"]
#[inline(always)]
pub fn set_wut(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
}
impl Default for Wutr {
#[inline(always)]
fn default() -> Wutr {
Wutr(0)
}
}
impl core::fmt::Debug for Wutr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Wutr").field("wut", &self.wut()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Wutr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Wutr {{ wut: {=u16:?} }}", self.wut())
}
}
}
pub mod vals {
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum AlrmrMsk {
#[doc = "Alarm set if the date/day match"]
TO_MATCH = 0x0,
#[doc = "Date/day don’t care in Alarm comparison"]
NOT_MATCH = 0x01,
}
impl AlrmrMsk {
#[inline(always)]
pub const fn from_bits(val: u8) -> AlrmrMsk {
unsafe { core::mem::transmute(val & 0x01) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for AlrmrMsk {
#[inline(always)]
fn from(val: u8) -> AlrmrMsk {
AlrmrMsk::from_bits(val)
}
}
impl From<AlrmrMsk> for u8 {
#[inline(always)]
fn from(val: AlrmrMsk) -> u8 {
AlrmrMsk::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum AlrmrPm {
#[doc = "AM or 24-hour format"]
AM = 0x0,
#[doc = "PM"]
PM = 0x01,
}
impl AlrmrPm {
#[inline(always)]
pub const fn from_bits(val: u8) -> AlrmrPm {
unsafe { core::mem::transmute(val & 0x01) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for AlrmrPm {
#[inline(always)]
fn from(val: u8) -> AlrmrPm {
AlrmrPm::from_bits(val)
}
}
impl From<AlrmrPm> for u8 {
#[inline(always)]
fn from(val: AlrmrPm) -> u8 {
AlrmrPm::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum AlrmrWdsel {
#[doc = "DU\\[3:0\\]
represents the date units"]
DATE_UNITS = 0x0,
#[doc = "DU\\[3:0\\]
represents the week day. DT\\[1:0\\]
is don’t care"]
WEEK_DAY = 0x01,
}
impl AlrmrWdsel {
#[inline(always)]
pub const fn from_bits(val: u8) -> AlrmrWdsel {
unsafe { core::mem::transmute(val & 0x01) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for AlrmrWdsel {
#[inline(always)]
fn from(val: u8) -> AlrmrWdsel {
AlrmrWdsel::from_bits(val)
}
}
impl From<AlrmrWdsel> for u8 {
#[inline(always)]
fn from(val: AlrmrWdsel) -> u8 {
AlrmrWdsel::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Ampm {
#[doc = "AM or 24-hour format"]
AM = 0x0,
#[doc = "PM"]
PM = 0x01,
}
impl Ampm {
#[inline(always)]
pub const fn from_bits(val: u8) -> Ampm {
unsafe { core::mem::transmute(val & 0x01) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Ampm {
#[inline(always)]
fn from(val: u8) -> Ampm {
Ampm::from_bits(val)
}
}
impl From<Ampm> for u8 {
#[inline(always)]
fn from(val: Ampm) -> u8 {
Ampm::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Osel {
#[doc = "Output disabled"]
DISABLED = 0x0,
#[doc = "Alarm A output enabled"]
ALARM_A = 0x01,
#[doc = "Alarm B output enabled"]
ALARM_B = 0x02,
#[doc = "Wakeup output enabled"]
WAKEUP = 0x03,
}
impl Osel {
#[inline(always)]
pub const fn from_bits(val: u8) -> Osel {
unsafe { core::mem::transmute(val & 0x03) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Osel {
#[inline(always)]
fn from(val: u8) -> Osel {
Osel::from_bits(val)
}
}
impl From<Osel> for u8 {
#[inline(always)]
fn from(val: Osel) -> u8 {
Osel::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Pol {
#[doc = "The pin is high when ALRAF/ALRBF/WUTF is asserted (depending on OSEL\\[1:0\\])"]
HIGH = 0x0,
#[doc = "The pin is low when ALRAF/ALRBF/WUTF is asserted (depending on OSEL\\[1:0\\])"]
LOW = 0x01,
}
impl Pol {
#[inline(always)]
pub const fn from_bits(val: u8) -> Pol {
unsafe { core::mem::transmute(val & 0x01) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Pol {
#[inline(always)]
fn from(val: u8) -> Pol {
Pol::from_bits(val)
}
}
impl From<Pol> for u8 {
#[inline(always)]
fn from(val: Pol) -> u8 {
Pol::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Tamptrg {
#[doc = "If TAMPFLT = 00: RTC_TAMPx input rising edge triggers a tamper detection event. If TAMPFLT =\u{338} 00: RTC_TAMPx input staying low triggers a tamper detection event."]
RISING_EDGE = 0x0,
#[doc = "If TAMPFLT = 00: RTC_TAMPx input staying high triggers a tamper detection event. If TAMPFLT =\u{338} 00: RTC_TAMPx input falling edge triggers a tamper detection event"]
FALLING_EDGE = 0x01,
}
impl Tamptrg {
#[inline(always)]
pub const fn from_bits(val: u8) -> Tamptrg {
unsafe { core::mem::transmute(val & 0x01) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Tamptrg {
#[inline(always)]
fn from(val: u8) -> Tamptrg {
Tamptrg::from_bits(val)
}
}
impl From<Tamptrg> for u8 {
#[inline(always)]
fn from(val: Tamptrg) -> u8 {
Tamptrg::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Tsedge {
#[doc = "RTC_TS input rising edge generates a time-stamp event"]
RISING_EDGE = 0x0,
#[doc = "RTC_TS input falling edge generates a time-stamp event"]
FALLING_EDGE = 0x01,
}
impl Tsedge {
#[inline(always)]
pub const fn from_bits(val: u8) -> Tsedge {
unsafe { core::mem::transmute(val & 0x01) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Tsedge {
#[inline(always)]
fn from(val: u8) -> Tsedge {
Tsedge::from_bits(val)
}
}
impl From<Tsedge> for u8 {
#[inline(always)]
fn from(val: Tsedge) -> u8 {
Tsedge::to_bits(val)
}
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Wucksel {
#[doc = "RTC/16 clock is selected"]
DIV16 = 0x0,
#[doc = "RTC/8 clock is selected"]
DIV8 = 0x01,
#[doc = "RTC/4 clock is selected"]
DIV4 = 0x02,
#[doc = "RTC/2 clock is selected"]
DIV2 = 0x03,
#[doc = "ck_spre (usually 1 Hz) clock is selected"]
CLOCK_SPARE = 0x04,
_RESERVED_5 = 0x05,
#[doc = "ck_spre (usually 1 Hz) clock is selected and 2^16 is added to the WUT counter value"]
CLOCK_SPARE_WITH_OFFSET = 0x06,
_RESERVED_7 = 0x07,
}
impl Wucksel {
#[inline(always)]
pub const fn from_bits(val: u8) -> Wucksel {
unsafe { core::mem::transmute(val & 0x07) }
}
#[inline(always)]
pub const fn to_bits(self) -> u8 {
unsafe { core::mem::transmute(self) }
}
}
impl From<u8> for Wucksel {
#[inline(always)]
fn from(val: u8) -> Wucksel {
Wucksel::from_bits(val)
}
}
impl From<Wucksel> for u8 {
#[inline(always)]
fn from(val: Wucksel) -> u8 {
Wucksel::to_bits(val)
}
}
}