mtb_pac_psoc6_01 0.1.1

/*
(c) (2016-2024), Cypress Semiconductor Corporation (an Infineon company)

    or an affiliate of Cypress Semiconductor Corporation.



    SPDX-License-Identifier: Apache-2.0



    Licensed under the Apache License, Version 2.0 (the "License");

    you may not use this file except in compliance with the License.

    You may obtain a copy of the License at



      http://www.apache.org/licenses/LICENSE-2.0



    Unless required by applicable law or agreed to in writing, software

    distributed under the License is distributed on an "AS IS" BASIS,

    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

    See the License for the specific language governing permissions and

    limitations under the License.
*/
// Generated from SVD 1.0, with svd2pac 0.6.0 on Tue, 27 May 2025 19:21:54 +0000

#![allow(clippy::identity_op)]
#![allow(clippy::module_inception)]
#![allow(clippy::derivable_impls)]
#[allow(unused_imports)]
use crate::common::sealed;
#[allow(unused_imports)]
use crate::common::*;
#[doc = r"Low Power Comparators"]
unsafe impl ::core::marker::Send for super::Lpcomp {}
unsafe impl ::core::marker::Sync for super::Lpcomp {}
impl super::Lpcomp {
    #[allow(unused)]
    #[inline(always)]
    pub(crate) const fn _svd2pac_as_ptr(&self) -> *mut u8 {
        self.ptr
    }

    #[doc = "LPCOMP Configuration Register"]
    #[inline(always)]
    pub const fn config(
        &self,
    ) -> &'static crate::common::Reg<self::Config_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::Config_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(0usize),
            )
        }
    }

    #[doc = "LPCOMP Status Register"]
    #[inline(always)]
    pub const fn status(&self) -> &'static crate::common::Reg<self::Status_SPEC, crate::common::R> {
        unsafe {
            crate::common::Reg::<self::Status_SPEC, crate::common::R>::from_ptr(
                self._svd2pac_as_ptr().add(4usize),
            )
        }
    }

    #[doc = "LPCOMP Interrupt request register"]
    #[inline(always)]
    pub const fn intr(&self) -> &'static crate::common::Reg<self::Intr_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::Intr_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(16usize),
            )
        }
    }

    #[doc = "LPCOMP Interrupt set register"]
    #[inline(always)]
    pub const fn intr_set(
        &self,
    ) -> &'static crate::common::Reg<self::IntrSet_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::IntrSet_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(20usize),
            )
        }
    }

    #[doc = "LPCOMP Interrupt request mask"]
    #[inline(always)]
    pub const fn intr_mask(
        &self,
    ) -> &'static crate::common::Reg<self::IntrMask_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::IntrMask_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(24usize),
            )
        }
    }

    #[doc = "LPCOMP Interrupt request masked"]
    #[inline(always)]
    pub const fn intr_masked(
        &self,
    ) -> &'static crate::common::Reg<self::IntrMasked_SPEC, crate::common::R> {
        unsafe {
            crate::common::Reg::<self::IntrMasked_SPEC, crate::common::R>::from_ptr(
                self._svd2pac_as_ptr().add(28usize),
            )
        }
    }

    #[doc = "Comparator 0 control Register"]
    #[inline(always)]
    pub const fn cmp0_ctrl(
        &self,
    ) -> &'static crate::common::Reg<self::Cmp0Ctrl_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::Cmp0Ctrl_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(64usize),
            )
        }
    }

    #[doc = "Comparator 0 switch control"]
    #[inline(always)]
    pub const fn cmp0_sw(
        &self,
    ) -> &'static crate::common::Reg<self::Cmp0Sw_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::Cmp0Sw_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(80usize),
            )
        }
    }

    #[doc = "Comparator 0 switch control clear"]
    #[inline(always)]
    pub const fn cmp0_sw_clear(
        &self,
    ) -> &'static crate::common::Reg<self::Cmp0SwClear_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::Cmp0SwClear_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(84usize),
            )
        }
    }

    #[doc = "Comparator 1 control Register"]
    #[inline(always)]
    pub const fn cmp1_ctrl(
        &self,
    ) -> &'static crate::common::Reg<self::Cmp1Ctrl_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::Cmp1Ctrl_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(128usize),
            )
        }
    }

    #[doc = "Comparator 1 switch control"]
    #[inline(always)]
    pub const fn cmp1_sw(
        &self,
    ) -> &'static crate::common::Reg<self::Cmp1Sw_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::Cmp1Sw_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(144usize),
            )
        }
    }

    #[doc = "Comparator 1 switch control clear"]
    #[inline(always)]
    pub const fn cmp1_sw_clear(
        &self,
    ) -> &'static crate::common::Reg<self::Cmp1SwClear_SPEC, crate::common::RW> {
        unsafe {
            crate::common::Reg::<self::Cmp1SwClear_SPEC, crate::common::RW>::from_ptr(
                self._svd2pac_as_ptr().add(148usize),
            )
        }
    }
}
#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Config_SPEC;
impl crate::sealed::RegSpec for Config_SPEC {
    type DataType = u32;
}

#[doc = "LPCOMP Configuration Register"]
pub type Config = crate::RegValueT<Config_SPEC>;

impl Config {
    #[doc = "Enable the local reference generator circuit to generate the local Vref and Ibias. Ibias current is an  alternative to the reference current IREF generated by SRSS. This bit must be set for System Deep Sleep and System Hibernate operation."]
    #[inline(always)]
    pub fn lpref_en(
        self,
    ) -> crate::common::RegisterFieldBool<30, 1, 0, Config_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<30, 1, 0, Config_SPEC, crate::common::RW>::from_register(
            self, 0,
        )
    }

    #[doc = "- 0: LPCOMP disabled (puts analog in power down, opens all switches, all clocks turned off)\n- 1: LPCOMP enabled"]
    #[inline(always)]
    pub fn enabled(
        self,
    ) -> crate::common::RegisterFieldBool<31, 1, 0, Config_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<31, 1, 0, Config_SPEC, crate::common::RW>::from_register(
            self, 0,
        )
    }
}
impl ::core::default::Default for Config {
    #[inline(always)]
    fn default() -> Config {
        <crate::RegValueT<Config_SPEC> as RegisterValue<_>>::new(0)
    }
}

#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Status_SPEC;
impl crate::sealed::RegSpec for Status_SPEC {
    type DataType = u32;
}

#[doc = "LPCOMP Status Register"]
pub type Status = crate::RegValueT<Status_SPEC>;

impl Status {
    #[doc = "Current output value of the comparator 0."]
    #[inline(always)]
    pub fn out0(self) -> crate::common::RegisterFieldBool<0, 1, 0, Status_SPEC, crate::common::R> {
        crate::common::RegisterFieldBool::<0, 1, 0, Status_SPEC, crate::common::R>::from_register(
            self, 0,
        )
    }

    #[doc = "Current output value of the comparator 1."]
    #[inline(always)]
    pub fn out1(self) -> crate::common::RegisterFieldBool<16, 1, 0, Status_SPEC, crate::common::R> {
        crate::common::RegisterFieldBool::<16, 1, 0, Status_SPEC, crate::common::R>::from_register(
            self, 0,
        )
    }
}
impl ::core::default::Default for Status {
    #[inline(always)]
    fn default() -> Status {
        <crate::RegValueT<Status_SPEC> as RegisterValue<_>>::new(0)
    }
}

#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Intr_SPEC;
impl crate::sealed::RegSpec for Intr_SPEC {
    type DataType = u32;
}

#[doc = "LPCOMP Interrupt request register"]
pub type Intr = crate::RegValueT<Intr_SPEC>;

impl Intr {
    #[doc = "Comparator 0 Interrupt: hardware sets this interrupt when comparator 0 triggers. Write with \'1\' to clear bit."]
    #[inline(always)]
    pub fn comp0(self) -> crate::common::RegisterFieldBool<0, 1, 0, Intr_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<0, 1, 0, Intr_SPEC, crate::common::RW>::from_register(
            self, 0,
        )
    }

    #[doc = "Comparator 1 Interrupt: hardware sets this interrupt when comparator 1 triggers. Write with \'1\' to clear bit."]
    #[inline(always)]
    pub fn comp1(self) -> crate::common::RegisterFieldBool<1, 1, 0, Intr_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<1, 1, 0, Intr_SPEC, crate::common::RW>::from_register(
            self, 0,
        )
    }
}
impl ::core::default::Default for Intr {
    #[inline(always)]
    fn default() -> Intr {
        <crate::RegValueT<Intr_SPEC> as RegisterValue<_>>::new(0)
    }
}

#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct IntrSet_SPEC;
impl crate::sealed::RegSpec for IntrSet_SPEC {
    type DataType = u32;
}

#[doc = "LPCOMP Interrupt set register"]
pub type IntrSet = crate::RegValueT<IntrSet_SPEC>;

impl IntrSet {
    #[doc = "Write with \'1\' to set corresponding bit in interrupt request register."]
    #[inline(always)]
    pub fn comp0(
        self,
    ) -> crate::common::RegisterFieldBool<0, 1, 0, IntrSet_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<0, 1, 0, IntrSet_SPEC, crate::common::RW>::from_register(
            self, 0,
        )
    }

    #[doc = "Write with \'1\' to set corresponding bit in interrupt request register."]
    #[inline(always)]
    pub fn comp1(
        self,
    ) -> crate::common::RegisterFieldBool<1, 1, 0, IntrSet_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<1, 1, 0, IntrSet_SPEC, crate::common::RW>::from_register(
            self, 0,
        )
    }
}
impl ::core::default::Default for IntrSet {
    #[inline(always)]
    fn default() -> IntrSet {
        <crate::RegValueT<IntrSet_SPEC> as RegisterValue<_>>::new(0)
    }
}

#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct IntrMask_SPEC;
impl crate::sealed::RegSpec for IntrMask_SPEC {
    type DataType = u32;
}

#[doc = "LPCOMP Interrupt request mask"]
pub type IntrMask = crate::RegValueT<IntrMask_SPEC>;

impl IntrMask {
    #[doc = "Mask bit for corresponding bit in interrupt request register."]
    #[inline(always)]
    pub fn comp0_mask(
        self,
    ) -> crate::common::RegisterFieldBool<0, 1, 0, IntrMask_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<0, 1, 0, IntrMask_SPEC, crate::common::RW>::from_register(
            self, 0,
        )
    }

    #[doc = "Mask bit for corresponding bit in interrupt request register."]
    #[inline(always)]
    pub fn comp1_mask(
        self,
    ) -> crate::common::RegisterFieldBool<1, 1, 0, IntrMask_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<1, 1, 0, IntrMask_SPEC, crate::common::RW>::from_register(
            self, 0,
        )
    }
}
impl ::core::default::Default for IntrMask {
    #[inline(always)]
    fn default() -> IntrMask {
        <crate::RegValueT<IntrMask_SPEC> as RegisterValue<_>>::new(0)
    }
}

#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct IntrMasked_SPEC;
impl crate::sealed::RegSpec for IntrMasked_SPEC {
    type DataType = u32;
}

#[doc = "LPCOMP Interrupt request masked"]
pub type IntrMasked = crate::RegValueT<IntrMasked_SPEC>;

impl IntrMasked {
    #[doc = "Logical and of corresponding request and mask bits."]
    #[inline(always)]
    pub fn comp0_masked(
        self,
    ) -> crate::common::RegisterFieldBool<0, 1, 0, IntrMasked_SPEC, crate::common::R> {
        crate::common::RegisterFieldBool::<0,1,0,IntrMasked_SPEC,crate::common::R>::from_register(self,0)
    }

    #[doc = "Logical and of corresponding request and mask bits."]
    #[inline(always)]
    pub fn comp1_masked(
        self,
    ) -> crate::common::RegisterFieldBool<1, 1, 0, IntrMasked_SPEC, crate::common::R> {
        crate::common::RegisterFieldBool::<1,1,0,IntrMasked_SPEC,crate::common::R>::from_register(self,0)
    }
}
impl ::core::default::Default for IntrMasked {
    #[inline(always)]
    fn default() -> IntrMasked {
        <crate::RegValueT<IntrMasked_SPEC> as RegisterValue<_>>::new(0)
    }
}

#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cmp0Ctrl_SPEC;
impl crate::sealed::RegSpec for Cmp0Ctrl_SPEC {
    type DataType = u32;
}

#[doc = "Comparator 0 control Register"]
pub type Cmp0Ctrl = crate::RegValueT<Cmp0Ctrl_SPEC>;

impl Cmp0Ctrl {
    #[doc = "N/A"]
    #[inline(always)]
    pub fn mode0(
        self,
    ) -> crate::common::RegisterField<
        0,
        0x3,
        1,
        0,
        cmp0_ctrl::Mode0,
        cmp0_ctrl::Mode0,
        Cmp0Ctrl_SPEC,
        crate::common::RW,
    > {
        crate::common::RegisterField::<
            0,
            0x3,
            1,
            0,
            cmp0_ctrl::Mode0,
            cmp0_ctrl::Mode0,
            Cmp0Ctrl_SPEC,
            crate::common::RW,
        >::from_register(self, 0)
    }

    #[doc = "Add hysteresis to the comparator\n0= Disable Hysteresis\n1= Enable Hysteresis"]
    #[inline(always)]
    pub fn hyst0(
        self,
    ) -> crate::common::RegisterFieldBool<5, 1, 0, Cmp0Ctrl_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<5, 1, 0, Cmp0Ctrl_SPEC, crate::common::RW>::from_register(
            self, 0,
        )
    }

    #[doc = "N/A"]
    #[inline(always)]
    pub fn inttype0(
        self,
    ) -> crate::common::RegisterField<
        6,
        0x3,
        1,
        0,
        cmp0_ctrl::Inttype0,
        cmp0_ctrl::Inttype0,
        Cmp0Ctrl_SPEC,
        crate::common::RW,
    > {
        crate::common::RegisterField::<
            6,
            0x3,
            1,
            0,
            cmp0_ctrl::Inttype0,
            cmp0_ctrl::Inttype0,
            Cmp0Ctrl_SPEC,
            crate::common::RW,
        >::from_register(self, 0)
    }

    #[doc = "Asynchronous: bypass comparator output synchronization: \n0=synchronize (level or pulse)\n1=bypass (output async)\nNote that in System Deep Sleep mode, this bit needs to be set to observe the output on the dedicated pin."]
    #[inline(always)]
    pub fn dsi_bypass0(
        self,
    ) -> crate::common::RegisterFieldBool<10, 1, 0, Cmp0Ctrl_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<10,1,0,Cmp0Ctrl_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Synchronous comparator output (trigger): \n0=pulse \n1=level"]
    #[inline(always)]
    pub fn dsi_level0(
        self,
    ) -> crate::common::RegisterFieldBool<11, 1, 0, Cmp0Ctrl_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<11,1,0,Cmp0Ctrl_SPEC,crate::common::RW>::from_register(self,0)
    }
}
impl ::core::default::Default for Cmp0Ctrl {
    #[inline(always)]
    fn default() -> Cmp0Ctrl {
        <crate::RegValueT<Cmp0Ctrl_SPEC> as RegisterValue<_>>::new(0)
    }
}
pub mod cmp0_ctrl {

    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
    pub struct Mode0_SPEC;
    pub type Mode0 = crate::EnumBitfieldStruct<u8, Mode0_SPEC>;
    impl Mode0 {
        #[doc = "Off"]
        pub const OFF: Self = Self::new(0);

        #[doc = "Ultra lowpower operating mode (uses less power, < 300nA), must be used for DeepSleep or Hibernate. Only in this mode a local iref will be used."]
        pub const ULP: Self = Self::new(1);

        #[doc = "Low Power operating mode (uses more power, <10uA @@@ TBD). In this mode the iref from SRSS will be used."]
        pub const LP: Self = Self::new(2);

        #[doc = "Normal, full speed power operating mode (uses <150uA). In this mode the iref from SRSS will be used."]
        pub const NORMAL: Self = Self::new(3);
    }
    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
    pub struct Inttype0_SPEC;
    pub type Inttype0 = crate::EnumBitfieldStruct<u8, Inttype0_SPEC>;
    impl Inttype0 {
        #[doc = "Disabled, no interrupts will be detected"]
        pub const DISABLE: Self = Self::new(0);

        #[doc = "Rising edge"]
        pub const RISING: Self = Self::new(1);

        #[doc = "Falling edge"]
        pub const FALLING: Self = Self::new(2);

        #[doc = "Both rising and falling edges"]
        pub const BOTH: Self = Self::new(3);
    }
}
#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cmp0Sw_SPEC;
impl crate::sealed::RegSpec for Cmp0Sw_SPEC {
    type DataType = u32;
}

#[doc = "Comparator 0 switch control"]
pub type Cmp0Sw = crate::RegValueT<Cmp0Sw_SPEC>;

impl Cmp0Sw {
    #[doc = "Comparator 0 positive terminal isolation switch to GPIO"]
    #[inline(always)]
    pub fn cmp0_ip0(
        self,
    ) -> crate::common::RegisterFieldBool<0, 1, 0, Cmp0Sw_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<0, 1, 0, Cmp0Sw_SPEC, crate::common::RW>::from_register(
            self, 0,
        )
    }

    #[doc = "Comparator 0 positive terminal  switch to amuxbusA"]
    #[inline(always)]
    pub fn cmp0_ap0(
        self,
    ) -> crate::common::RegisterFieldBool<1, 1, 0, Cmp0Sw_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<1, 1, 0, Cmp0Sw_SPEC, crate::common::RW>::from_register(
            self, 0,
        )
    }

    #[doc = "Comparator 0 positive terminal  switch to amuxbusB"]
    #[inline(always)]
    pub fn cmp0_bp0(
        self,
    ) -> crate::common::RegisterFieldBool<2, 1, 0, Cmp0Sw_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<2, 1, 0, Cmp0Sw_SPEC, crate::common::RW>::from_register(
            self, 0,
        )
    }

    #[doc = "Comparator 0 negative terminal isolation switch to GPIO"]
    #[inline(always)]
    pub fn cmp0_in0(
        self,
    ) -> crate::common::RegisterFieldBool<4, 1, 0, Cmp0Sw_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<4, 1, 0, Cmp0Sw_SPEC, crate::common::RW>::from_register(
            self, 0,
        )
    }

    #[doc = "Comparator 0 negative terminal  switch to amuxbusA"]
    #[inline(always)]
    pub fn cmp0_an0(
        self,
    ) -> crate::common::RegisterFieldBool<5, 1, 0, Cmp0Sw_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<5, 1, 0, Cmp0Sw_SPEC, crate::common::RW>::from_register(
            self, 0,
        )
    }

    #[doc = "Comparator 0 negative terminal  switch to amuxbusB"]
    #[inline(always)]
    pub fn cmp0_bn0(
        self,
    ) -> crate::common::RegisterFieldBool<6, 1, 0, Cmp0Sw_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<6, 1, 0, Cmp0Sw_SPEC, crate::common::RW>::from_register(
            self, 0,
        )
    }

    #[doc = "Comparator 0 negative terminal  switch to local Vref  (LPREF_EN must be set)"]
    #[inline(always)]
    pub fn cmp0_vn0(
        self,
    ) -> crate::common::RegisterFieldBool<7, 1, 0, Cmp0Sw_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<7, 1, 0, Cmp0Sw_SPEC, crate::common::RW>::from_register(
            self, 0,
        )
    }
}
impl ::core::default::Default for Cmp0Sw {
    #[inline(always)]
    fn default() -> Cmp0Sw {
        <crate::RegValueT<Cmp0Sw_SPEC> as RegisterValue<_>>::new(0)
    }
}

#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cmp0SwClear_SPEC;
impl crate::sealed::RegSpec for Cmp0SwClear_SPEC {
    type DataType = u32;
}

#[doc = "Comparator 0 switch control clear"]
pub type Cmp0SwClear = crate::RegValueT<Cmp0SwClear_SPEC>;

impl Cmp0SwClear {
    #[doc = "see corresponding bit in CMP0_SW"]
    #[inline(always)]
    pub fn cmp0_ip0(
        self,
    ) -> crate::common::RegisterFieldBool<0, 1, 0, Cmp0SwClear_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<0,1,0,Cmp0SwClear_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "see corresponding bit in CMP0_SW"]
    #[inline(always)]
    pub fn cmp0_ap0(
        self,
    ) -> crate::common::RegisterFieldBool<1, 1, 0, Cmp0SwClear_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<1,1,0,Cmp0SwClear_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "see corresponding bit in CMP0_SW"]
    #[inline(always)]
    pub fn cmp0_bp0(
        self,
    ) -> crate::common::RegisterFieldBool<2, 1, 0, Cmp0SwClear_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<2,1,0,Cmp0SwClear_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "see corresponding bit in CMP0_SW"]
    #[inline(always)]
    pub fn cmp0_in0(
        self,
    ) -> crate::common::RegisterFieldBool<4, 1, 0, Cmp0SwClear_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<4,1,0,Cmp0SwClear_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "see corresponding bit in CMP0_SW"]
    #[inline(always)]
    pub fn cmp0_an0(
        self,
    ) -> crate::common::RegisterFieldBool<5, 1, 0, Cmp0SwClear_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<5,1,0,Cmp0SwClear_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "see corresponding bit in CMP0_SW"]
    #[inline(always)]
    pub fn cmp0_bn0(
        self,
    ) -> crate::common::RegisterFieldBool<6, 1, 0, Cmp0SwClear_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<6,1,0,Cmp0SwClear_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "see corresponding bit in CMP0_SW"]
    #[inline(always)]
    pub fn cmp0_vn0(
        self,
    ) -> crate::common::RegisterFieldBool<7, 1, 0, Cmp0SwClear_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<7,1,0,Cmp0SwClear_SPEC,crate::common::RW>::from_register(self,0)
    }
}
impl ::core::default::Default for Cmp0SwClear {
    #[inline(always)]
    fn default() -> Cmp0SwClear {
        <crate::RegValueT<Cmp0SwClear_SPEC> as RegisterValue<_>>::new(0)
    }
}

#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cmp1Ctrl_SPEC;
impl crate::sealed::RegSpec for Cmp1Ctrl_SPEC {
    type DataType = u32;
}

#[doc = "Comparator 1 control Register"]
pub type Cmp1Ctrl = crate::RegValueT<Cmp1Ctrl_SPEC>;

impl Cmp1Ctrl {
    #[doc = "N/A"]
    #[inline(always)]
    pub fn mode1(
        self,
    ) -> crate::common::RegisterField<
        0,
        0x3,
        1,
        0,
        cmp1_ctrl::Mode1,
        cmp1_ctrl::Mode1,
        Cmp1Ctrl_SPEC,
        crate::common::RW,
    > {
        crate::common::RegisterField::<
            0,
            0x3,
            1,
            0,
            cmp1_ctrl::Mode1,
            cmp1_ctrl::Mode1,
            Cmp1Ctrl_SPEC,
            crate::common::RW,
        >::from_register(self, 0)
    }

    #[doc = "Add hysteresis to the comparator\n0= Disable Hysteresis\n1= Enable Hysteresis"]
    #[inline(always)]
    pub fn hyst1(
        self,
    ) -> crate::common::RegisterFieldBool<5, 1, 0, Cmp1Ctrl_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<5, 1, 0, Cmp1Ctrl_SPEC, crate::common::RW>::from_register(
            self, 0,
        )
    }

    #[doc = "N/A"]
    #[inline(always)]
    pub fn inttype1(
        self,
    ) -> crate::common::RegisterField<
        6,
        0x3,
        1,
        0,
        cmp1_ctrl::Inttype1,
        cmp1_ctrl::Inttype1,
        Cmp1Ctrl_SPEC,
        crate::common::RW,
    > {
        crate::common::RegisterField::<
            6,
            0x3,
            1,
            0,
            cmp1_ctrl::Inttype1,
            cmp1_ctrl::Inttype1,
            Cmp1Ctrl_SPEC,
            crate::common::RW,
        >::from_register(self, 0)
    }

    #[doc = "Asynchronous: bypass comparator output synchronization: \n0=synchronize (level or pulse)\n1=bypass (output async)\nNote that in System Deep Sleep mode, this bit needs to be set to observe the output on the dedicated pin."]
    #[inline(always)]
    pub fn dsi_bypass1(
        self,
    ) -> crate::common::RegisterFieldBool<10, 1, 0, Cmp1Ctrl_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<10,1,0,Cmp1Ctrl_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "Synchronous comparator output (trigger): \n0=pulse \n1=level"]
    #[inline(always)]
    pub fn dsi_level1(
        self,
    ) -> crate::common::RegisterFieldBool<11, 1, 0, Cmp1Ctrl_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<11,1,0,Cmp1Ctrl_SPEC,crate::common::RW>::from_register(self,0)
    }
}
impl ::core::default::Default for Cmp1Ctrl {
    #[inline(always)]
    fn default() -> Cmp1Ctrl {
        <crate::RegValueT<Cmp1Ctrl_SPEC> as RegisterValue<_>>::new(0)
    }
}
pub mod cmp1_ctrl {

    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
    pub struct Mode1_SPEC;
    pub type Mode1 = crate::EnumBitfieldStruct<u8, Mode1_SPEC>;
    impl Mode1 {
        #[doc = "Off"]
        pub const OFF: Self = Self::new(0);

        #[doc = "Ultra lowpower operating mode (uses less power, < 300nA), must be used for DeepSleep or Hibernate. Only in this mode a local iref will be used."]
        pub const ULP: Self = Self::new(1);

        #[doc = "Low Power operating mode (uses more power, <10uA @@@ TBD). In this mode the iref from SRSS will be used."]
        pub const LP: Self = Self::new(2);

        #[doc = "Normal, full speed power operating mode (uses <150uA). In this mode the iref from SRSS will be used."]
        pub const NORMAL: Self = Self::new(3);
    }
    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
    pub struct Inttype1_SPEC;
    pub type Inttype1 = crate::EnumBitfieldStruct<u8, Inttype1_SPEC>;
    impl Inttype1 {
        #[doc = "Disabled, no interrupts will be detected"]
        pub const DISABLE: Self = Self::new(0);

        #[doc = "Rising edge"]
        pub const RISING: Self = Self::new(1);

        #[doc = "Falling edge"]
        pub const FALLING: Self = Self::new(2);

        #[doc = "Both rising and falling edges"]
        pub const BOTH: Self = Self::new(3);
    }
}
#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cmp1Sw_SPEC;
impl crate::sealed::RegSpec for Cmp1Sw_SPEC {
    type DataType = u32;
}

#[doc = "Comparator 1 switch control"]
pub type Cmp1Sw = crate::RegValueT<Cmp1Sw_SPEC>;

impl Cmp1Sw {
    #[doc = "Comparator 1 positive terminal isolation switch to GPIO"]
    #[inline(always)]
    pub fn cmp1_ip1(
        self,
    ) -> crate::common::RegisterFieldBool<0, 1, 0, Cmp1Sw_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<0, 1, 0, Cmp1Sw_SPEC, crate::common::RW>::from_register(
            self, 0,
        )
    }

    #[doc = "Comparator 1 positive terminal  switch to amuxbusA"]
    #[inline(always)]
    pub fn cmp1_ap1(
        self,
    ) -> crate::common::RegisterFieldBool<1, 1, 0, Cmp1Sw_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<1, 1, 0, Cmp1Sw_SPEC, crate::common::RW>::from_register(
            self, 0,
        )
    }

    #[doc = "Comparator 1 positive terminal  switch to amuxbusB"]
    #[inline(always)]
    pub fn cmp1_bp1(
        self,
    ) -> crate::common::RegisterFieldBool<2, 1, 0, Cmp1Sw_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<2, 1, 0, Cmp1Sw_SPEC, crate::common::RW>::from_register(
            self, 0,
        )
    }

    #[doc = "Comparator 1 negative terminal isolation switch to GPIO"]
    #[inline(always)]
    pub fn cmp1_in1(
        self,
    ) -> crate::common::RegisterFieldBool<4, 1, 0, Cmp1Sw_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<4, 1, 0, Cmp1Sw_SPEC, crate::common::RW>::from_register(
            self, 0,
        )
    }

    #[doc = "Comparator 1 negative terminal  switch to amuxbusA"]
    #[inline(always)]
    pub fn cmp1_an1(
        self,
    ) -> crate::common::RegisterFieldBool<5, 1, 0, Cmp1Sw_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<5, 1, 0, Cmp1Sw_SPEC, crate::common::RW>::from_register(
            self, 0,
        )
    }

    #[doc = "Comparator 1 negative terminal  switch to amuxbusB"]
    #[inline(always)]
    pub fn cmp1_bn1(
        self,
    ) -> crate::common::RegisterFieldBool<6, 1, 0, Cmp1Sw_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<6, 1, 0, Cmp1Sw_SPEC, crate::common::RW>::from_register(
            self, 0,
        )
    }

    #[doc = "Comparator 1 negative terminal  switch to local Vref  (LPREF_EN must be set)"]
    #[inline(always)]
    pub fn cmp1_vn1(
        self,
    ) -> crate::common::RegisterFieldBool<7, 1, 0, Cmp1Sw_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<7, 1, 0, Cmp1Sw_SPEC, crate::common::RW>::from_register(
            self, 0,
        )
    }
}
impl ::core::default::Default for Cmp1Sw {
    #[inline(always)]
    fn default() -> Cmp1Sw {
        <crate::RegValueT<Cmp1Sw_SPEC> as RegisterValue<_>>::new(0)
    }
}

#[doc(hidden)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cmp1SwClear_SPEC;
impl crate::sealed::RegSpec for Cmp1SwClear_SPEC {
    type DataType = u32;
}

#[doc = "Comparator 1 switch control clear"]
pub type Cmp1SwClear = crate::RegValueT<Cmp1SwClear_SPEC>;

impl Cmp1SwClear {
    #[doc = "see corresponding bit in CMP1_SW"]
    #[inline(always)]
    pub fn cmp1_ip1(
        self,
    ) -> crate::common::RegisterFieldBool<0, 1, 0, Cmp1SwClear_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<0,1,0,Cmp1SwClear_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "see corresponding bit in CMP1_SW"]
    #[inline(always)]
    pub fn cmp1_ap1(
        self,
    ) -> crate::common::RegisterFieldBool<1, 1, 0, Cmp1SwClear_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<1,1,0,Cmp1SwClear_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "see corresponding bit in CMP1_SW"]
    #[inline(always)]
    pub fn cmp1_bp1(
        self,
    ) -> crate::common::RegisterFieldBool<2, 1, 0, Cmp1SwClear_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<2,1,0,Cmp1SwClear_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "see corresponding bit in CMP1_SW"]
    #[inline(always)]
    pub fn cmp1_in1(
        self,
    ) -> crate::common::RegisterFieldBool<4, 1, 0, Cmp1SwClear_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<4,1,0,Cmp1SwClear_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "see corresponding bit in CMP1_SW"]
    #[inline(always)]
    pub fn cmp1_an1(
        self,
    ) -> crate::common::RegisterFieldBool<5, 1, 0, Cmp1SwClear_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<5,1,0,Cmp1SwClear_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "see corresponding bit in CMP1_SW"]
    #[inline(always)]
    pub fn cmp1_bn1(
        self,
    ) -> crate::common::RegisterFieldBool<6, 1, 0, Cmp1SwClear_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<6,1,0,Cmp1SwClear_SPEC,crate::common::RW>::from_register(self,0)
    }

    #[doc = "see corresponding bit in CMP1_SW"]
    #[inline(always)]
    pub fn cmp1_vn1(
        self,
    ) -> crate::common::RegisterFieldBool<7, 1, 0, Cmp1SwClear_SPEC, crate::common::RW> {
        crate::common::RegisterFieldBool::<7,1,0,Cmp1SwClear_SPEC,crate::common::RW>::from_register(self,0)
    }
}
impl ::core::default::Default for Cmp1SwClear {
    #[inline(always)]
    fn default() -> Cmp1SwClear {
        <crate::RegValueT<Cmp1SwClear_SPEC> as RegisterValue<_>>::new(0)
    }
}