sam3x8e-pac 0.1.6-dev

#[doc = "Chip ID Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cidr(pub u32);
impl Cidr {
    #[doc = "Version of the Device"]
    #[must_use]
    #[inline(always)]
    pub const fn version(&self) -> u8 {
        let val = (self.0 >> 0usize) & 0x1f;
        val as u8
    }
    #[doc = "Version of the Device"]
    #[inline(always)]
    pub const fn set_version(&mut self, val: u8) {
        self.0 = (self.0 & !(0x1f << 0usize)) | (((val as u32) & 0x1f) << 0usize);
    }
    #[doc = "Embedded Processor"]
    #[must_use]
    #[inline(always)]
    pub const fn eproc(&self) -> super::vals::Eproc {
        let val = (self.0 >> 5usize) & 0x07;
        super::vals::Eproc::from_bits(val as u8)
    }
    #[doc = "Embedded Processor"]
    #[inline(always)]
    pub const fn set_eproc(&mut self, val: super::vals::Eproc) {
        self.0 = (self.0 & !(0x07 << 5usize)) | (((val.to_bits() as u32) & 0x07) << 5usize);
    }
    #[doc = "Nonvolatile Program Memory Size"]
    #[must_use]
    #[inline(always)]
    pub const fn nvpsiz(&self) -> super::vals::Nvpsiz {
        let val = (self.0 >> 8usize) & 0x0f;
        super::vals::Nvpsiz::from_bits(val as u8)
    }
    #[doc = "Nonvolatile Program Memory Size"]
    #[inline(always)]
    pub const fn set_nvpsiz(&mut self, val: super::vals::Nvpsiz) {
        self.0 = (self.0 & !(0x0f << 8usize)) | (((val.to_bits() as u32) & 0x0f) << 8usize);
    }
    #[doc = "Second Nonvolatile Program Memory Size"]
    #[must_use]
    #[inline(always)]
    pub const fn nvpsiz2(&self) -> super::vals::Nvpsiz2 {
        let val = (self.0 >> 12usize) & 0x0f;
        super::vals::Nvpsiz2::from_bits(val as u8)
    }
    #[doc = "Second Nonvolatile Program Memory Size"]
    #[inline(always)]
    pub const fn set_nvpsiz2(&mut self, val: super::vals::Nvpsiz2) {
        self.0 = (self.0 & !(0x0f << 12usize)) | (((val.to_bits() as u32) & 0x0f) << 12usize);
    }
    #[doc = "Internal SRAM Size"]
    #[must_use]
    #[inline(always)]
    pub const fn sramsiz(&self) -> super::vals::Sramsiz {
        let val = (self.0 >> 16usize) & 0x0f;
        super::vals::Sramsiz::from_bits(val as u8)
    }
    #[doc = "Internal SRAM Size"]
    #[inline(always)]
    pub const fn set_sramsiz(&mut self, val: super::vals::Sramsiz) {
        self.0 = (self.0 & !(0x0f << 16usize)) | (((val.to_bits() as u32) & 0x0f) << 16usize);
    }
    #[doc = "Architecture Identifier"]
    #[must_use]
    #[inline(always)]
    pub const fn arch(&self) -> super::vals::Arch {
        let val = (self.0 >> 20usize) & 0xff;
        super::vals::Arch::from_bits(val as u8)
    }
    #[doc = "Architecture Identifier"]
    #[inline(always)]
    pub const fn set_arch(&mut self, val: super::vals::Arch) {
        self.0 = (self.0 & !(0xff << 20usize)) | (((val.to_bits() as u32) & 0xff) << 20usize);
    }
    #[doc = "Nonvolatile Program Memory Type"]
    #[must_use]
    #[inline(always)]
    pub const fn nvptyp(&self) -> super::vals::Nvptyp {
        let val = (self.0 >> 28usize) & 0x07;
        super::vals::Nvptyp::from_bits(val as u8)
    }
    #[doc = "Nonvolatile Program Memory Type"]
    #[inline(always)]
    pub const fn set_nvptyp(&mut self, val: super::vals::Nvptyp) {
        self.0 = (self.0 & !(0x07 << 28usize)) | (((val.to_bits() as u32) & 0x07) << 28usize);
    }
    #[doc = "Extension Flag"]
    #[must_use]
    #[inline(always)]
    pub const fn ext(&self) -> bool {
        let val = (self.0 >> 31usize) & 0x01;
        val != 0
    }
    #[doc = "Extension Flag"]
    #[inline(always)]
    pub const fn set_ext(&mut self, val: bool) {
        self.0 = (self.0 & !(0x01 << 31usize)) | (((val as u32) & 0x01) << 31usize);
    }
}
impl Default for Cidr {
    #[inline(always)]
    fn default() -> Cidr {
        Cidr(0)
    }
}
impl core::fmt::Debug for Cidr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Cidr")
            .field("version", &self.version())
            .field("eproc", &self.eproc())
            .field("nvpsiz", &self.nvpsiz())
            .field("nvpsiz2", &self.nvpsiz2())
            .field("sramsiz", &self.sramsiz())
            .field("arch", &self.arch())
            .field("nvptyp", &self.nvptyp())
            .field("ext", &self.ext())
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Cidr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Cidr {{ version: {=u8:?}, eproc: {:?}, nvpsiz: {:?}, nvpsiz2: {:?}, sramsiz: {:?}, arch: {:?}, nvptyp: {:?}, ext: {=bool:?} }}",
            self.version(),
            self.eproc(),
            self.nvpsiz(),
            self.nvpsiz2(),
            self.sramsiz(),
            self.arch(),
            self.nvptyp(),
            self.ext()
        )
    }
}
#[doc = "Chip ID Extension Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Exid(pub u32);
impl Exid {
    #[doc = "Chip ID Extension"]
    #[must_use]
    #[inline(always)]
    pub const fn exid(&self) -> u32 {
        let val = (self.0 >> 0usize) & 0xffff_ffff;
        val as u32
    }
    #[doc = "Chip ID Extension"]
    #[inline(always)]
    pub const fn set_exid(&mut self, val: u32) {
        self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
    }
}
impl Default for Exid {
    #[inline(always)]
    fn default() -> Exid {
        Exid(0)
    }
}
impl core::fmt::Debug for Exid {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Exid").field("exid", &self.exid()).finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Exid {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(f, "Exid {{ exid: {=u32:?} }}", self.exid())
    }
}