#[doc = "Register `SINTSET` reader"]
pub type R = crate::R<SintsetSpec>;
#[doc = "Register `SINTSET` writer"]
pub type W = crate::W<SintsetSpec>;
#[doc = "Start Interrupt Enable\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Start {
#[doc = "0: Disable"]
Disable = 0,
#[doc = "1: Enable"]
Enable = 1,
}
impl From<Start> for bool {
#[inline(always)]
fn from(variant: Start) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `START` reader - Start Interrupt Enable"]
pub type StartR = crate::BitReader<Start>;
impl StartR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Start {
match self.bits {
false => Start::Disable,
true => Start::Enable,
}
}
#[doc = "Disable"]
#[inline(always)]
pub fn is_disable(&self) -> bool {
*self == Start::Disable
}
#[doc = "Enable"]
#[inline(always)]
pub fn is_enable(&self) -> bool {
*self == Start::Enable
}
}
#[doc = "Field `START` writer - Start Interrupt Enable"]
pub type StartW<'a, REG> = crate::BitWriter1S<'a, REG, Start>;
impl<'a, REG> StartW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "Disable"]
#[inline(always)]
pub fn disable(self) -> &'a mut crate::W<REG> {
self.variant(Start::Disable)
}
#[doc = "Enable"]
#[inline(always)]
pub fn enable(self) -> &'a mut crate::W<REG> {
self.variant(Start::Enable)
}
}
#[doc = "Match Interrupt Enable\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Matched {
#[doc = "0: Disable"]
Disable = 0,
#[doc = "1: Enable"]
Enable = 1,
}
impl From<Matched> for bool {
#[inline(always)]
fn from(variant: Matched) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `MATCHED` reader - Match Interrupt Enable"]
pub type MatchedR = crate::BitReader<Matched>;
impl MatchedR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Matched {
match self.bits {
false => Matched::Disable,
true => Matched::Enable,
}
}
#[doc = "Disable"]
#[inline(always)]
pub fn is_disable(&self) -> bool {
*self == Matched::Disable
}
#[doc = "Enable"]
#[inline(always)]
pub fn is_enable(&self) -> bool {
*self == Matched::Enable
}
}
#[doc = "Field `MATCHED` writer - Match Interrupt Enable"]
pub type MatchedW<'a, REG> = crate::BitWriter1S<'a, REG, Matched>;
impl<'a, REG> MatchedW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "Disable"]
#[inline(always)]
pub fn disable(self) -> &'a mut crate::W<REG> {
self.variant(Matched::Disable)
}
#[doc = "Enable"]
#[inline(always)]
pub fn enable(self) -> &'a mut crate::W<REG> {
self.variant(Matched::Enable)
}
}
#[doc = "Stop Interrupt Enable\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Stop {
#[doc = "0: Disable"]
Disable = 0,
#[doc = "1: Enable"]
Enable = 1,
}
impl From<Stop> for bool {
#[inline(always)]
fn from(variant: Stop) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `STOP` reader - Stop Interrupt Enable"]
pub type StopR = crate::BitReader<Stop>;
impl StopR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Stop {
match self.bits {
false => Stop::Disable,
true => Stop::Enable,
}
}
#[doc = "Disable"]
#[inline(always)]
pub fn is_disable(&self) -> bool {
*self == Stop::Disable
}
#[doc = "Enable"]
#[inline(always)]
pub fn is_enable(&self) -> bool {
*self == Stop::Enable
}
}
#[doc = "Field `STOP` writer - Stop Interrupt Enable"]
pub type StopW<'a, REG> = crate::BitWriter1S<'a, REG, Stop>;
impl<'a, REG> StopW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "Disable"]
#[inline(always)]
pub fn disable(self) -> &'a mut crate::W<REG> {
self.variant(Stop::Disable)
}
#[doc = "Enable"]
#[inline(always)]
pub fn enable(self) -> &'a mut crate::W<REG> {
self.variant(Stop::Enable)
}
}
#[doc = "Receive Interrupt Enable\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Rxpend {
#[doc = "0: Disable"]
Disable = 0,
#[doc = "1: Enable"]
Enable = 1,
}
impl From<Rxpend> for bool {
#[inline(always)]
fn from(variant: Rxpend) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `RXPEND` reader - Receive Interrupt Enable"]
pub type RxpendR = crate::BitReader<Rxpend>;
impl RxpendR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Rxpend {
match self.bits {
false => Rxpend::Disable,
true => Rxpend::Enable,
}
}
#[doc = "Disable"]
#[inline(always)]
pub fn is_disable(&self) -> bool {
*self == Rxpend::Disable
}
#[doc = "Enable"]
#[inline(always)]
pub fn is_enable(&self) -> bool {
*self == Rxpend::Enable
}
}
#[doc = "Field `RXPEND` writer - Receive Interrupt Enable"]
pub type RxpendW<'a, REG> = crate::BitWriter1S<'a, REG, Rxpend>;
impl<'a, REG> RxpendW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "Disable"]
#[inline(always)]
pub fn disable(self) -> &'a mut crate::W<REG> {
self.variant(Rxpend::Disable)
}
#[doc = "Enable"]
#[inline(always)]
pub fn enable(self) -> &'a mut crate::W<REG> {
self.variant(Rxpend::Enable)
}
}
#[doc = "Transmit Interrupt Enable\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Txsend {
#[doc = "0: Disable"]
Disable = 0,
#[doc = "1: Enable"]
Enable = 1,
}
impl From<Txsend> for bool {
#[inline(always)]
fn from(variant: Txsend) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `TXSEND` reader - Transmit Interrupt Enable"]
pub type TxsendR = crate::BitReader<Txsend>;
impl TxsendR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Txsend {
match self.bits {
false => Txsend::Disable,
true => Txsend::Enable,
}
}
#[doc = "Disable"]
#[inline(always)]
pub fn is_disable(&self) -> bool {
*self == Txsend::Disable
}
#[doc = "Enable"]
#[inline(always)]
pub fn is_enable(&self) -> bool {
*self == Txsend::Enable
}
}
#[doc = "Field `TXSEND` writer - Transmit Interrupt Enable"]
pub type TxsendW<'a, REG> = crate::BitWriter1S<'a, REG, Txsend>;
impl<'a, REG> TxsendW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "Disable"]
#[inline(always)]
pub fn disable(self) -> &'a mut crate::W<REG> {
self.variant(Txsend::Disable)
}
#[doc = "Enable"]
#[inline(always)]
pub fn enable(self) -> &'a mut crate::W<REG> {
self.variant(Txsend::Enable)
}
}
#[doc = "Dynamic Address Change Interrupt Enable\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Dachg {
#[doc = "0: Disable"]
Disable = 0,
#[doc = "1: Enable"]
Enable = 1,
}
impl From<Dachg> for bool {
#[inline(always)]
fn from(variant: Dachg) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `DACHG` reader - Dynamic Address Change Interrupt Enable"]
pub type DachgR = crate::BitReader<Dachg>;
impl DachgR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Dachg {
match self.bits {
false => Dachg::Disable,
true => Dachg::Enable,
}
}
#[doc = "Disable"]
#[inline(always)]
pub fn is_disable(&self) -> bool {
*self == Dachg::Disable
}
#[doc = "Enable"]
#[inline(always)]
pub fn is_enable(&self) -> bool {
*self == Dachg::Enable
}
}
#[doc = "Field `DACHG` writer - Dynamic Address Change Interrupt Enable"]
pub type DachgW<'a, REG> = crate::BitWriter1S<'a, REG, Dachg>;
impl<'a, REG> DachgW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "Disable"]
#[inline(always)]
pub fn disable(self) -> &'a mut crate::W<REG> {
self.variant(Dachg::Disable)
}
#[doc = "Enable"]
#[inline(always)]
pub fn enable(self) -> &'a mut crate::W<REG> {
self.variant(Dachg::Enable)
}
}
#[doc = "Common Command Code (CCC) Interrupt Enable\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Ccc {
#[doc = "0: Disable"]
Disable = 0,
#[doc = "1: Enable"]
Enable = 1,
}
impl From<Ccc> for bool {
#[inline(always)]
fn from(variant: Ccc) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `CCC` reader - Common Command Code (CCC) Interrupt Enable"]
pub type CccR = crate::BitReader<Ccc>;
impl CccR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Ccc {
match self.bits {
false => Ccc::Disable,
true => Ccc::Enable,
}
}
#[doc = "Disable"]
#[inline(always)]
pub fn is_disable(&self) -> bool {
*self == Ccc::Disable
}
#[doc = "Enable"]
#[inline(always)]
pub fn is_enable(&self) -> bool {
*self == Ccc::Enable
}
}
#[doc = "Field `CCC` writer - Common Command Code (CCC) Interrupt Enable"]
pub type CccW<'a, REG> = crate::BitWriter1S<'a, REG, Ccc>;
impl<'a, REG> CccW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "Disable"]
#[inline(always)]
pub fn disable(self) -> &'a mut crate::W<REG> {
self.variant(Ccc::Disable)
}
#[doc = "Enable"]
#[inline(always)]
pub fn enable(self) -> &'a mut crate::W<REG> {
self.variant(Ccc::Enable)
}
}
#[doc = "Error or Warning Interrupt Enable\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Errwarn {
#[doc = "0: Disable"]
Disable = 0,
#[doc = "1: Enable"]
Enable = 1,
}
impl From<Errwarn> for bool {
#[inline(always)]
fn from(variant: Errwarn) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `ERRWARN` reader - Error or Warning Interrupt Enable"]
pub type ErrwarnR = crate::BitReader<Errwarn>;
impl ErrwarnR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Errwarn {
match self.bits {
false => Errwarn::Disable,
true => Errwarn::Enable,
}
}
#[doc = "Disable"]
#[inline(always)]
pub fn is_disable(&self) -> bool {
*self == Errwarn::Disable
}
#[doc = "Enable"]
#[inline(always)]
pub fn is_enable(&self) -> bool {
*self == Errwarn::Enable
}
}
#[doc = "Field `ERRWARN` writer - Error or Warning Interrupt Enable"]
pub type ErrwarnW<'a, REG> = crate::BitWriter1S<'a, REG, Errwarn>;
impl<'a, REG> ErrwarnW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "Disable"]
#[inline(always)]
pub fn disable(self) -> &'a mut crate::W<REG> {
self.variant(Errwarn::Disable)
}
#[doc = "Enable"]
#[inline(always)]
pub fn enable(self) -> &'a mut crate::W<REG> {
self.variant(Errwarn::Enable)
}
}
#[doc = "Double Data Rate Interrupt Enable\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Ddrmatched {
#[doc = "0: Disable"]
Disable = 0,
#[doc = "1: Enable"]
Enable = 1,
}
impl From<Ddrmatched> for bool {
#[inline(always)]
fn from(variant: Ddrmatched) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `DDRMATCHED` reader - Double Data Rate Interrupt Enable"]
pub type DdrmatchedR = crate::BitReader<Ddrmatched>;
impl DdrmatchedR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Ddrmatched {
match self.bits {
false => Ddrmatched::Disable,
true => Ddrmatched::Enable,
}
}
#[doc = "Disable"]
#[inline(always)]
pub fn is_disable(&self) -> bool {
*self == Ddrmatched::Disable
}
#[doc = "Enable"]
#[inline(always)]
pub fn is_enable(&self) -> bool {
*self == Ddrmatched::Enable
}
}
#[doc = "Field `DDRMATCHED` writer - Double Data Rate Interrupt Enable"]
pub type DdrmatchedW<'a, REG> = crate::BitWriter1S<'a, REG, Ddrmatched>;
impl<'a, REG> DdrmatchedW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "Disable"]
#[inline(always)]
pub fn disable(self) -> &'a mut crate::W<REG> {
self.variant(Ddrmatched::Disable)
}
#[doc = "Enable"]
#[inline(always)]
pub fn enable(self) -> &'a mut crate::W<REG> {
self.variant(Ddrmatched::Enable)
}
}
#[doc = "Common Command Code (CCC) Interrupt Enable\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Chandled {
#[doc = "0: Disable"]
Disable = 0,
#[doc = "1: Enable"]
Enable = 1,
}
impl From<Chandled> for bool {
#[inline(always)]
fn from(variant: Chandled) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `CHANDLED` reader - Common Command Code (CCC) Interrupt Enable"]
pub type ChandledR = crate::BitReader<Chandled>;
impl ChandledR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Chandled {
match self.bits {
false => Chandled::Disable,
true => Chandled::Enable,
}
}
#[doc = "Disable"]
#[inline(always)]
pub fn is_disable(&self) -> bool {
*self == Chandled::Disable
}
#[doc = "Enable"]
#[inline(always)]
pub fn is_enable(&self) -> bool {
*self == Chandled::Enable
}
}
#[doc = "Field `CHANDLED` writer - Common Command Code (CCC) Interrupt Enable"]
pub type ChandledW<'a, REG> = crate::BitWriter1S<'a, REG, Chandled>;
impl<'a, REG> ChandledW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "Disable"]
#[inline(always)]
pub fn disable(self) -> &'a mut crate::W<REG> {
self.variant(Chandled::Disable)
}
#[doc = "Enable"]
#[inline(always)]
pub fn enable(self) -> &'a mut crate::W<REG> {
self.variant(Chandled::Enable)
}
}
#[doc = "Event Interrupt Enable\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Event {
#[doc = "0: Disable"]
Disable = 0,
#[doc = "1: Enable"]
Enable = 1,
}
impl From<Event> for bool {
#[inline(always)]
fn from(variant: Event) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `EVENT` reader - Event Interrupt Enable"]
pub type EventR = crate::BitReader<Event>;
impl EventR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Event {
match self.bits {
false => Event::Disable,
true => Event::Enable,
}
}
#[doc = "Disable"]
#[inline(always)]
pub fn is_disable(&self) -> bool {
*self == Event::Disable
}
#[doc = "Enable"]
#[inline(always)]
pub fn is_enable(&self) -> bool {
*self == Event::Enable
}
}
#[doc = "Field `EVENT` writer - Event Interrupt Enable"]
pub type EventW<'a, REG> = crate::BitWriter1S<'a, REG, Event>;
impl<'a, REG> EventW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "Disable"]
#[inline(always)]
pub fn disable(self) -> &'a mut crate::W<REG> {
self.variant(Event::Disable)
}
#[doc = "Enable"]
#[inline(always)]
pub fn enable(self) -> &'a mut crate::W<REG> {
self.variant(Event::Enable)
}
}
impl R {
#[doc = "Bit 8 - Start Interrupt Enable"]
#[inline(always)]
pub fn start(&self) -> StartR {
StartR::new(((self.bits >> 8) & 1) != 0)
}
#[doc = "Bit 9 - Match Interrupt Enable"]
#[inline(always)]
pub fn matched(&self) -> MatchedR {
MatchedR::new(((self.bits >> 9) & 1) != 0)
}
#[doc = "Bit 10 - Stop Interrupt Enable"]
#[inline(always)]
pub fn stop(&self) -> StopR {
StopR::new(((self.bits >> 10) & 1) != 0)
}
#[doc = "Bit 11 - Receive Interrupt Enable"]
#[inline(always)]
pub fn rxpend(&self) -> RxpendR {
RxpendR::new(((self.bits >> 11) & 1) != 0)
}
#[doc = "Bit 12 - Transmit Interrupt Enable"]
#[inline(always)]
pub fn txsend(&self) -> TxsendR {
TxsendR::new(((self.bits >> 12) & 1) != 0)
}
#[doc = "Bit 13 - Dynamic Address Change Interrupt Enable"]
#[inline(always)]
pub fn dachg(&self) -> DachgR {
DachgR::new(((self.bits >> 13) & 1) != 0)
}
#[doc = "Bit 14 - Common Command Code (CCC) Interrupt Enable"]
#[inline(always)]
pub fn ccc(&self) -> CccR {
CccR::new(((self.bits >> 14) & 1) != 0)
}
#[doc = "Bit 15 - Error or Warning Interrupt Enable"]
#[inline(always)]
pub fn errwarn(&self) -> ErrwarnR {
ErrwarnR::new(((self.bits >> 15) & 1) != 0)
}
#[doc = "Bit 16 - Double Data Rate Interrupt Enable"]
#[inline(always)]
pub fn ddrmatched(&self) -> DdrmatchedR {
DdrmatchedR::new(((self.bits >> 16) & 1) != 0)
}
#[doc = "Bit 17 - Common Command Code (CCC) Interrupt Enable"]
#[inline(always)]
pub fn chandled(&self) -> ChandledR {
ChandledR::new(((self.bits >> 17) & 1) != 0)
}
#[doc = "Bit 18 - Event Interrupt Enable"]
#[inline(always)]
pub fn event(&self) -> EventR {
EventR::new(((self.bits >> 18) & 1) != 0)
}
}
#[cfg(feature = "debug")]
impl core::fmt::Debug for R {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("SINTSET")
.field("start", &self.start())
.field("matched", &self.matched())
.field("stop", &self.stop())
.field("rxpend", &self.rxpend())
.field("txsend", &self.txsend())
.field("dachg", &self.dachg())
.field("ccc", &self.ccc())
.field("errwarn", &self.errwarn())
.field("ddrmatched", &self.ddrmatched())
.field("chandled", &self.chandled())
.field("event", &self.event())
.finish()
}
}
impl W {
#[doc = "Bit 8 - Start Interrupt Enable"]
#[inline(always)]
pub fn start(&mut self) -> StartW<'_, SintsetSpec> {
StartW::new(self, 8)
}
#[doc = "Bit 9 - Match Interrupt Enable"]
#[inline(always)]
pub fn matched(&mut self) -> MatchedW<'_, SintsetSpec> {
MatchedW::new(self, 9)
}
#[doc = "Bit 10 - Stop Interrupt Enable"]
#[inline(always)]
pub fn stop(&mut self) -> StopW<'_, SintsetSpec> {
StopW::new(self, 10)
}
#[doc = "Bit 11 - Receive Interrupt Enable"]
#[inline(always)]
pub fn rxpend(&mut self) -> RxpendW<'_, SintsetSpec> {
RxpendW::new(self, 11)
}
#[doc = "Bit 12 - Transmit Interrupt Enable"]
#[inline(always)]
pub fn txsend(&mut self) -> TxsendW<'_, SintsetSpec> {
TxsendW::new(self, 12)
}
#[doc = "Bit 13 - Dynamic Address Change Interrupt Enable"]
#[inline(always)]
pub fn dachg(&mut self) -> DachgW<'_, SintsetSpec> {
DachgW::new(self, 13)
}
#[doc = "Bit 14 - Common Command Code (CCC) Interrupt Enable"]
#[inline(always)]
pub fn ccc(&mut self) -> CccW<'_, SintsetSpec> {
CccW::new(self, 14)
}
#[doc = "Bit 15 - Error or Warning Interrupt Enable"]
#[inline(always)]
pub fn errwarn(&mut self) -> ErrwarnW<'_, SintsetSpec> {
ErrwarnW::new(self, 15)
}
#[doc = "Bit 16 - Double Data Rate Interrupt Enable"]
#[inline(always)]
pub fn ddrmatched(&mut self) -> DdrmatchedW<'_, SintsetSpec> {
DdrmatchedW::new(self, 16)
}
#[doc = "Bit 17 - Common Command Code (CCC) Interrupt Enable"]
#[inline(always)]
pub fn chandled(&mut self) -> ChandledW<'_, SintsetSpec> {
ChandledW::new(self, 17)
}
#[doc = "Bit 18 - Event Interrupt Enable"]
#[inline(always)]
pub fn event(&mut self) -> EventW<'_, SintsetSpec> {
EventW::new(self, 18)
}
}
#[doc = "Target Interrupt Set\n\nYou can [`read`](crate::Reg::read) this register and get [`sintset::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`sintset::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct SintsetSpec;
impl crate::RegisterSpec for SintsetSpec {
type Ux = u32;
}
#[doc = "`read()` method returns [`sintset::R`](R) reader structure"]
impl crate::Readable for SintsetSpec {}
#[doc = "`write(|w| ..)` method takes [`sintset::W`](W) writer structure"]
impl crate::Writable for SintsetSpec {
type Safety = crate::Unsafe;
const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0x0007_ff00;
}
#[doc = "`reset()` method sets SINTSET to value 0"]
impl crate::Resettable for SintsetSpec {}