#[doc = "Register `CFGR` reader"]
pub struct R(crate::R<CFGR_SPEC>);
impl core::ops::Deref for R {
type Target = crate::R<CFGR_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<CFGR_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<CFGR_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `CFGR` writer"]
pub struct W(crate::W<CFGR_SPEC>);
impl core::ops::Deref for W {
type Target = crate::W<CFGR_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl core::ops::DerefMut for W {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl From<crate::W<CFGR_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<CFGR_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Injected Queue disable\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum JQDIS_A {
#[doc = "0: Injected Queue enabled"]
ENABLED = 0,
#[doc = "1: Injected Queue disabled"]
DISABLED = 1,
}
impl From<JQDIS_A> for bool {
#[inline(always)]
fn from(variant: JQDIS_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `JQDIS` reader - Injected Queue disable"]
pub struct JQDIS_R(crate::FieldReader<bool, JQDIS_A>);
impl JQDIS_R {
pub(crate) fn new(bits: bool) -> Self {
JQDIS_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> JQDIS_A {
match self.bits {
false => JQDIS_A::ENABLED,
true => JQDIS_A::DISABLED,
}
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
**self == JQDIS_A::ENABLED
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
**self == JQDIS_A::DISABLED
}
}
impl core::ops::Deref for JQDIS_R {
type Target = crate::FieldReader<bool, JQDIS_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `JQDIS` writer - Injected Queue disable"]
pub struct JQDIS_W<'a> {
w: &'a mut W,
}
impl<'a> JQDIS_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: JQDIS_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Injected Queue enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(JQDIS_A::ENABLED)
}
#[doc = "Injected Queue disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(JQDIS_A::DISABLED)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 31)) | ((value as u32 & 0x01) << 31);
self.w
}
}
#[doc = "Field `AWD1CH` reader - Analog watchdog 1 channel selection"]
pub struct AWD1CH_R(crate::FieldReader<u8, u8>);
impl AWD1CH_R {
pub(crate) fn new(bits: u8) -> Self {
AWD1CH_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for AWD1CH_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `AWD1CH` writer - Analog watchdog 1 channel selection"]
pub struct AWD1CH_W<'a> {
w: &'a mut W,
}
impl<'a> AWD1CH_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x1f << 26)) | ((value as u32 & 0x1f) << 26);
self.w
}
}
#[doc = "Automatic injected group conversion\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum JAUTO_A {
#[doc = "0: Automatic injected group conversion disabled"]
DISABLED = 0,
#[doc = "1: Automatic injected group conversion enabled"]
ENABLED = 1,
}
impl From<JAUTO_A> for bool {
#[inline(always)]
fn from(variant: JAUTO_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `JAUTO` reader - Automatic injected group conversion"]
pub struct JAUTO_R(crate::FieldReader<bool, JAUTO_A>);
impl JAUTO_R {
pub(crate) fn new(bits: bool) -> Self {
JAUTO_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> JAUTO_A {
match self.bits {
false => JAUTO_A::DISABLED,
true => JAUTO_A::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
**self == JAUTO_A::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
**self == JAUTO_A::ENABLED
}
}
impl core::ops::Deref for JAUTO_R {
type Target = crate::FieldReader<bool, JAUTO_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `JAUTO` writer - Automatic injected group conversion"]
pub struct JAUTO_W<'a> {
w: &'a mut W,
}
impl<'a> JAUTO_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: JAUTO_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Automatic injected group conversion disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(JAUTO_A::DISABLED)
}
#[doc = "Automatic injected group conversion enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(JAUTO_A::ENABLED)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 25)) | ((value as u32 & 0x01) << 25);
self.w
}
}
#[doc = "Analog watchdog 1 enable on injected channels\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum JAWD1EN_A {
#[doc = "0: Analog watchdog 1 disabled on injected channels"]
DISABLED = 0,
#[doc = "1: Analog watchdog 1 enabled on injected channels"]
ENABLED = 1,
}
impl From<JAWD1EN_A> for bool {
#[inline(always)]
fn from(variant: JAWD1EN_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `JAWD1EN` reader - Analog watchdog 1 enable on injected channels"]
pub struct JAWD1EN_R(crate::FieldReader<bool, JAWD1EN_A>);
impl JAWD1EN_R {
pub(crate) fn new(bits: bool) -> Self {
JAWD1EN_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> JAWD1EN_A {
match self.bits {
false => JAWD1EN_A::DISABLED,
true => JAWD1EN_A::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
**self == JAWD1EN_A::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
**self == JAWD1EN_A::ENABLED
}
}
impl core::ops::Deref for JAWD1EN_R {
type Target = crate::FieldReader<bool, JAWD1EN_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `JAWD1EN` writer - Analog watchdog 1 enable on injected channels"]
pub struct JAWD1EN_W<'a> {
w: &'a mut W,
}
impl<'a> JAWD1EN_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: JAWD1EN_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Analog watchdog 1 disabled on injected channels"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(JAWD1EN_A::DISABLED)
}
#[doc = "Analog watchdog 1 enabled on injected channels"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(JAWD1EN_A::ENABLED)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 24)) | ((value as u32 & 0x01) << 24);
self.w
}
}
#[doc = "Analog watchdog 1 enable on regular channels\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum AWD1EN_A {
#[doc = "0: Analog watchdog 1 disabled on regular channels"]
DISABLED = 0,
#[doc = "1: Analog watchdog 1 enabled on regular channels"]
ENABLED = 1,
}
impl From<AWD1EN_A> for bool {
#[inline(always)]
fn from(variant: AWD1EN_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `AWD1EN` reader - Analog watchdog 1 enable on regular channels"]
pub struct AWD1EN_R(crate::FieldReader<bool, AWD1EN_A>);
impl AWD1EN_R {
pub(crate) fn new(bits: bool) -> Self {
AWD1EN_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> AWD1EN_A {
match self.bits {
false => AWD1EN_A::DISABLED,
true => AWD1EN_A::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
**self == AWD1EN_A::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
**self == AWD1EN_A::ENABLED
}
}
impl core::ops::Deref for AWD1EN_R {
type Target = crate::FieldReader<bool, AWD1EN_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `AWD1EN` writer - Analog watchdog 1 enable on regular channels"]
pub struct AWD1EN_W<'a> {
w: &'a mut W,
}
impl<'a> AWD1EN_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: AWD1EN_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Analog watchdog 1 disabled on regular channels"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(AWD1EN_A::DISABLED)
}
#[doc = "Analog watchdog 1 enabled on regular channels"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(AWD1EN_A::ENABLED)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 23)) | ((value as u32 & 0x01) << 23);
self.w
}
}
#[doc = "Enable the watchdog 1 on a single channel or on all channels\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum AWD1SGL_A {
#[doc = "0: Analog watchdog 1 enabled on all channels"]
ALL = 0,
#[doc = "1: Analog watchdog 1 enabled on single channel selected in AWD1CH"]
SINGLE = 1,
}
impl From<AWD1SGL_A> for bool {
#[inline(always)]
fn from(variant: AWD1SGL_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `AWD1SGL` reader - Enable the watchdog 1 on a single channel or on all channels"]
pub struct AWD1SGL_R(crate::FieldReader<bool, AWD1SGL_A>);
impl AWD1SGL_R {
pub(crate) fn new(bits: bool) -> Self {
AWD1SGL_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> AWD1SGL_A {
match self.bits {
false => AWD1SGL_A::ALL,
true => AWD1SGL_A::SINGLE,
}
}
#[doc = "Checks if the value of the field is `ALL`"]
#[inline(always)]
pub fn is_all(&self) -> bool {
**self == AWD1SGL_A::ALL
}
#[doc = "Checks if the value of the field is `SINGLE`"]
#[inline(always)]
pub fn is_single(&self) -> bool {
**self == AWD1SGL_A::SINGLE
}
}
impl core::ops::Deref for AWD1SGL_R {
type Target = crate::FieldReader<bool, AWD1SGL_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `AWD1SGL` writer - Enable the watchdog 1 on a single channel or on all channels"]
pub struct AWD1SGL_W<'a> {
w: &'a mut W,
}
impl<'a> AWD1SGL_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: AWD1SGL_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Analog watchdog 1 enabled on all channels"]
#[inline(always)]
pub fn all(self) -> &'a mut W {
self.variant(AWD1SGL_A::ALL)
}
#[doc = "Analog watchdog 1 enabled on single channel selected in AWD1CH"]
#[inline(always)]
pub fn single(self) -> &'a mut W {
self.variant(AWD1SGL_A::SINGLE)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 22)) | ((value as u32 & 0x01) << 22);
self.w
}
}
#[doc = "JSQR queue mode\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum JQM_A {
#[doc = "0: JSQR Mode 0: Queue maintains the last written configuration into JSQR"]
MODE0 = 0,
#[doc = "1: JSQR Mode 1: An empty queue disables software and hardware triggers of the injected sequence"]
MODE1 = 1,
}
impl From<JQM_A> for bool {
#[inline(always)]
fn from(variant: JQM_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `JQM` reader - JSQR queue mode"]
pub struct JQM_R(crate::FieldReader<bool, JQM_A>);
impl JQM_R {
pub(crate) fn new(bits: bool) -> Self {
JQM_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> JQM_A {
match self.bits {
false => JQM_A::MODE0,
true => JQM_A::MODE1,
}
}
#[doc = "Checks if the value of the field is `MODE0`"]
#[inline(always)]
pub fn is_mode0(&self) -> bool {
**self == JQM_A::MODE0
}
#[doc = "Checks if the value of the field is `MODE1`"]
#[inline(always)]
pub fn is_mode1(&self) -> bool {
**self == JQM_A::MODE1
}
}
impl core::ops::Deref for JQM_R {
type Target = crate::FieldReader<bool, JQM_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `JQM` writer - JSQR queue mode"]
pub struct JQM_W<'a> {
w: &'a mut W,
}
impl<'a> JQM_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: JQM_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "JSQR Mode 0: Queue maintains the last written configuration into JSQR"]
#[inline(always)]
pub fn mode0(self) -> &'a mut W {
self.variant(JQM_A::MODE0)
}
#[doc = "JSQR Mode 1: An empty queue disables software and hardware triggers of the injected sequence"]
#[inline(always)]
pub fn mode1(self) -> &'a mut W {
self.variant(JQM_A::MODE1)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 21)) | ((value as u32 & 0x01) << 21);
self.w
}
}
#[doc = "Discontinuous mode on injected channels\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum JDISCEN_A {
#[doc = "0: Discontinuous mode on injected channels disabled"]
DISABLED = 0,
#[doc = "1: Discontinuous mode on injected channels enabled"]
ENABLED = 1,
}
impl From<JDISCEN_A> for bool {
#[inline(always)]
fn from(variant: JDISCEN_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `JDISCEN` reader - Discontinuous mode on injected channels"]
pub struct JDISCEN_R(crate::FieldReader<bool, JDISCEN_A>);
impl JDISCEN_R {
pub(crate) fn new(bits: bool) -> Self {
JDISCEN_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> JDISCEN_A {
match self.bits {
false => JDISCEN_A::DISABLED,
true => JDISCEN_A::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
**self == JDISCEN_A::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
**self == JDISCEN_A::ENABLED
}
}
impl core::ops::Deref for JDISCEN_R {
type Target = crate::FieldReader<bool, JDISCEN_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `JDISCEN` writer - Discontinuous mode on injected channels"]
pub struct JDISCEN_W<'a> {
w: &'a mut W,
}
impl<'a> JDISCEN_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: JDISCEN_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Discontinuous mode on injected channels disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(JDISCEN_A::DISABLED)
}
#[doc = "Discontinuous mode on injected channels enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(JDISCEN_A::ENABLED)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 20)) | ((value as u32 & 0x01) << 20);
self.w
}
}
#[doc = "Field `DISCNUM` reader - Discontinuous mode channel count"]
pub struct DISCNUM_R(crate::FieldReader<u8, u8>);
impl DISCNUM_R {
pub(crate) fn new(bits: u8) -> Self {
DISCNUM_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for DISCNUM_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `DISCNUM` writer - Discontinuous mode channel count"]
pub struct DISCNUM_W<'a> {
w: &'a mut W,
}
impl<'a> DISCNUM_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x07 << 17)) | ((value as u32 & 0x07) << 17);
self.w
}
}
#[doc = "Discontinuous mode for regular channels\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum DISCEN_A {
#[doc = "0: Discontinuous mode on regular channels disabled"]
DISABLED = 0,
#[doc = "1: Discontinuous mode on regular channels enabled"]
ENABLED = 1,
}
impl From<DISCEN_A> for bool {
#[inline(always)]
fn from(variant: DISCEN_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `DISCEN` reader - Discontinuous mode for regular channels"]
pub struct DISCEN_R(crate::FieldReader<bool, DISCEN_A>);
impl DISCEN_R {
pub(crate) fn new(bits: bool) -> Self {
DISCEN_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> DISCEN_A {
match self.bits {
false => DISCEN_A::DISABLED,
true => DISCEN_A::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
**self == DISCEN_A::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
**self == DISCEN_A::ENABLED
}
}
impl core::ops::Deref for DISCEN_R {
type Target = crate::FieldReader<bool, DISCEN_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `DISCEN` writer - Discontinuous mode for regular channels"]
pub struct DISCEN_W<'a> {
w: &'a mut W,
}
impl<'a> DISCEN_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: DISCEN_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Discontinuous mode on regular channels disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(DISCEN_A::DISABLED)
}
#[doc = "Discontinuous mode on regular channels enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(DISCEN_A::ENABLED)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 16)) | ((value as u32 & 0x01) << 16);
self.w
}
}
#[doc = "Data alignment\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ALIGN_A {
#[doc = "0: Right alignment"]
RIGHT = 0,
#[doc = "1: Left alignment"]
LEFT = 1,
}
impl From<ALIGN_A> for bool {
#[inline(always)]
fn from(variant: ALIGN_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `ALIGN` reader - Data alignment"]
pub struct ALIGN_R(crate::FieldReader<bool, ALIGN_A>);
impl ALIGN_R {
pub(crate) fn new(bits: bool) -> Self {
ALIGN_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> ALIGN_A {
match self.bits {
false => ALIGN_A::RIGHT,
true => ALIGN_A::LEFT,
}
}
#[doc = "Checks if the value of the field is `RIGHT`"]
#[inline(always)]
pub fn is_right(&self) -> bool {
**self == ALIGN_A::RIGHT
}
#[doc = "Checks if the value of the field is `LEFT`"]
#[inline(always)]
pub fn is_left(&self) -> bool {
**self == ALIGN_A::LEFT
}
}
impl core::ops::Deref for ALIGN_R {
type Target = crate::FieldReader<bool, ALIGN_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ALIGN` writer - Data alignment"]
pub struct ALIGN_W<'a> {
w: &'a mut W,
}
impl<'a> ALIGN_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: ALIGN_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Right alignment"]
#[inline(always)]
pub fn right(self) -> &'a mut W {
self.variant(ALIGN_A::RIGHT)
}
#[doc = "Left alignment"]
#[inline(always)]
pub fn left(self) -> &'a mut W {
self.variant(ALIGN_A::LEFT)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 15)) | ((value as u32 & 0x01) << 15);
self.w
}
}
#[doc = "Delayed conversion mode\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum AUTDLY_A {
#[doc = "0: Auto delayed conversion mode off"]
OFF = 0,
#[doc = "1: Auto delayed conversion mode on"]
ON = 1,
}
impl From<AUTDLY_A> for bool {
#[inline(always)]
fn from(variant: AUTDLY_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `AUTDLY` reader - Delayed conversion mode"]
pub struct AUTDLY_R(crate::FieldReader<bool, AUTDLY_A>);
impl AUTDLY_R {
pub(crate) fn new(bits: bool) -> Self {
AUTDLY_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> AUTDLY_A {
match self.bits {
false => AUTDLY_A::OFF,
true => AUTDLY_A::ON,
}
}
#[doc = "Checks if the value of the field is `OFF`"]
#[inline(always)]
pub fn is_off(&self) -> bool {
**self == AUTDLY_A::OFF
}
#[doc = "Checks if the value of the field is `ON`"]
#[inline(always)]
pub fn is_on(&self) -> bool {
**self == AUTDLY_A::ON
}
}
impl core::ops::Deref for AUTDLY_R {
type Target = crate::FieldReader<bool, AUTDLY_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `AUTDLY` writer - Delayed conversion mode"]
pub struct AUTDLY_W<'a> {
w: &'a mut W,
}
impl<'a> AUTDLY_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: AUTDLY_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Auto delayed conversion mode off"]
#[inline(always)]
pub fn off(self) -> &'a mut W {
self.variant(AUTDLY_A::OFF)
}
#[doc = "Auto delayed conversion mode on"]
#[inline(always)]
pub fn on(self) -> &'a mut W {
self.variant(AUTDLY_A::ON)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 14)) | ((value as u32 & 0x01) << 14);
self.w
}
}
#[doc = "Single / continuous conversion mode for regular conversions\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CONT_A {
#[doc = "0: Single conversion mode"]
SINGLE = 0,
#[doc = "1: Continuous conversion mode"]
CONTINUOUS = 1,
}
impl From<CONT_A> for bool {
#[inline(always)]
fn from(variant: CONT_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `CONT` reader - Single / continuous conversion mode for regular conversions"]
pub struct CONT_R(crate::FieldReader<bool, CONT_A>);
impl CONT_R {
pub(crate) fn new(bits: bool) -> Self {
CONT_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CONT_A {
match self.bits {
false => CONT_A::SINGLE,
true => CONT_A::CONTINUOUS,
}
}
#[doc = "Checks if the value of the field is `SINGLE`"]
#[inline(always)]
pub fn is_single(&self) -> bool {
**self == CONT_A::SINGLE
}
#[doc = "Checks if the value of the field is `CONTINUOUS`"]
#[inline(always)]
pub fn is_continuous(&self) -> bool {
**self == CONT_A::CONTINUOUS
}
}
impl core::ops::Deref for CONT_R {
type Target = crate::FieldReader<bool, CONT_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `CONT` writer - Single / continuous conversion mode for regular conversions"]
pub struct CONT_W<'a> {
w: &'a mut W,
}
impl<'a> CONT_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: CONT_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Single conversion mode"]
#[inline(always)]
pub fn single(self) -> &'a mut W {
self.variant(CONT_A::SINGLE)
}
#[doc = "Continuous conversion mode"]
#[inline(always)]
pub fn continuous(self) -> &'a mut W {
self.variant(CONT_A::CONTINUOUS)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 13)) | ((value as u32 & 0x01) << 13);
self.w
}
}
#[doc = "Overrun mode\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum OVRMOD_A {
#[doc = "0: Preserve DR register when an overrun is detected"]
PRESERVE = 0,
#[doc = "1: Overwrite DR register when an overrun is detected"]
OVERWRITE = 1,
}
impl From<OVRMOD_A> for bool {
#[inline(always)]
fn from(variant: OVRMOD_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `OVRMOD` reader - Overrun mode"]
pub struct OVRMOD_R(crate::FieldReader<bool, OVRMOD_A>);
impl OVRMOD_R {
pub(crate) fn new(bits: bool) -> Self {
OVRMOD_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> OVRMOD_A {
match self.bits {
false => OVRMOD_A::PRESERVE,
true => OVRMOD_A::OVERWRITE,
}
}
#[doc = "Checks if the value of the field is `PRESERVE`"]
#[inline(always)]
pub fn is_preserve(&self) -> bool {
**self == OVRMOD_A::PRESERVE
}
#[doc = "Checks if the value of the field is `OVERWRITE`"]
#[inline(always)]
pub fn is_overwrite(&self) -> bool {
**self == OVRMOD_A::OVERWRITE
}
}
impl core::ops::Deref for OVRMOD_R {
type Target = crate::FieldReader<bool, OVRMOD_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `OVRMOD` writer - Overrun mode"]
pub struct OVRMOD_W<'a> {
w: &'a mut W,
}
impl<'a> OVRMOD_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: OVRMOD_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Preserve DR register when an overrun is detected"]
#[inline(always)]
pub fn preserve(self) -> &'a mut W {
self.variant(OVRMOD_A::PRESERVE)
}
#[doc = "Overwrite DR register when an overrun is detected"]
#[inline(always)]
pub fn overwrite(self) -> &'a mut W {
self.variant(OVRMOD_A::OVERWRITE)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 12)) | ((value as u32 & 0x01) << 12);
self.w
}
}
#[doc = "External trigger enable and polarity selection for regular channels\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(u8)]
pub enum EXTEN_A {
#[doc = "0: Trigger detection disabled"]
DISABLED = 0,
#[doc = "1: Trigger detection on the rising edge"]
RISINGEDGE = 1,
#[doc = "2: Trigger detection on the falling edge"]
FALLINGEDGE = 2,
#[doc = "3: Trigger detection on both the rising and falling edges"]
BOTHEDGES = 3,
}
impl From<EXTEN_A> for u8 {
#[inline(always)]
fn from(variant: EXTEN_A) -> Self {
variant as _
}
}
#[doc = "Field `EXTEN` reader - External trigger enable and polarity selection for regular channels"]
pub struct EXTEN_R(crate::FieldReader<u8, EXTEN_A>);
impl EXTEN_R {
pub(crate) fn new(bits: u8) -> Self {
EXTEN_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> EXTEN_A {
match self.bits {
0 => EXTEN_A::DISABLED,
1 => EXTEN_A::RISINGEDGE,
2 => EXTEN_A::FALLINGEDGE,
3 => EXTEN_A::BOTHEDGES,
_ => unreachable!(),
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
**self == EXTEN_A::DISABLED
}
#[doc = "Checks if the value of the field is `RISINGEDGE`"]
#[inline(always)]
pub fn is_rising_edge(&self) -> bool {
**self == EXTEN_A::RISINGEDGE
}
#[doc = "Checks if the value of the field is `FALLINGEDGE`"]
#[inline(always)]
pub fn is_falling_edge(&self) -> bool {
**self == EXTEN_A::FALLINGEDGE
}
#[doc = "Checks if the value of the field is `BOTHEDGES`"]
#[inline(always)]
pub fn is_both_edges(&self) -> bool {
**self == EXTEN_A::BOTHEDGES
}
}
impl core::ops::Deref for EXTEN_R {
type Target = crate::FieldReader<u8, EXTEN_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `EXTEN` writer - External trigger enable and polarity selection for regular channels"]
pub struct EXTEN_W<'a> {
w: &'a mut W,
}
impl<'a> EXTEN_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: EXTEN_A) -> &'a mut W {
self.bits(variant.into())
}
#[doc = "Trigger detection disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(EXTEN_A::DISABLED)
}
#[doc = "Trigger detection on the rising edge"]
#[inline(always)]
pub fn rising_edge(self) -> &'a mut W {
self.variant(EXTEN_A::RISINGEDGE)
}
#[doc = "Trigger detection on the falling edge"]
#[inline(always)]
pub fn falling_edge(self) -> &'a mut W {
self.variant(EXTEN_A::FALLINGEDGE)
}
#[doc = "Trigger detection on both the rising and falling edges"]
#[inline(always)]
pub fn both_edges(self) -> &'a mut W {
self.variant(EXTEN_A::BOTHEDGES)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x03 << 10)) | ((value as u32 & 0x03) << 10);
self.w
}
}
#[doc = "External trigger selection for regular group\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(u8)]
pub enum EXTSEL_A {
#[doc = "7: HRTIM_ADCTRG1 event"]
HRTIM_ADCTRG1 = 7,
#[doc = "8: HRTIM_ADCTRG3 event"]
HRTIM_ADCTRG3 = 8,
#[doc = "0: Timer 1 CC1 event"]
TIM1_CC1 = 0,
#[doc = "1: Timer 1 CC2 event"]
TIM1_CC2 = 1,
#[doc = "2: Timer 1 CC3 event"]
TIM1_CC3 = 2,
#[doc = "3: Timer 2 CC2 event"]
TIM2_CC2 = 3,
#[doc = "4: Timer 3 TRGO event"]
TIM3_TRGO = 4,
#[doc = "6: EXTI line 11"]
EXTI11 = 6,
#[doc = "9: Timer 1 TRGO event"]
TIM1_TRGO = 9,
#[doc = "10: Timer 1 TRGO2 event"]
TIM1_TRGO2 = 10,
#[doc = "11: Timer 2 TRGO event"]
TIM2_TRGO = 11,
#[doc = "13: Timer 6 TRGO event"]
TIM6_TRGO = 13,
#[doc = "14: Timer 15 TRGO event"]
TIM15_TRGO = 14,
#[doc = "15: Timer 3 CC4 event"]
TIM3_CC4 = 15,
}
impl From<EXTSEL_A> for u8 {
#[inline(always)]
fn from(variant: EXTSEL_A) -> Self {
variant as _
}
}
#[doc = "Field `EXTSEL` reader - External trigger selection for regular group"]
pub struct EXTSEL_R(crate::FieldReader<u8, EXTSEL_A>);
impl EXTSEL_R {
pub(crate) fn new(bits: u8) -> Self {
EXTSEL_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> Option<EXTSEL_A> {
match self.bits {
7 => Some(EXTSEL_A::HRTIM_ADCTRG1),
8 => Some(EXTSEL_A::HRTIM_ADCTRG3),
0 => Some(EXTSEL_A::TIM1_CC1),
1 => Some(EXTSEL_A::TIM1_CC2),
2 => Some(EXTSEL_A::TIM1_CC3),
3 => Some(EXTSEL_A::TIM2_CC2),
4 => Some(EXTSEL_A::TIM3_TRGO),
6 => Some(EXTSEL_A::EXTI11),
9 => Some(EXTSEL_A::TIM1_TRGO),
10 => Some(EXTSEL_A::TIM1_TRGO2),
11 => Some(EXTSEL_A::TIM2_TRGO),
13 => Some(EXTSEL_A::TIM6_TRGO),
14 => Some(EXTSEL_A::TIM15_TRGO),
15 => Some(EXTSEL_A::TIM3_CC4),
_ => None,
}
}
#[doc = "Checks if the value of the field is `HRTIM_ADCTRG1`"]
#[inline(always)]
pub fn is_hrtim_adctrg1(&self) -> bool {
**self == EXTSEL_A::HRTIM_ADCTRG1
}
#[doc = "Checks if the value of the field is `HRTIM_ADCTRG3`"]
#[inline(always)]
pub fn is_hrtim_adctrg3(&self) -> bool {
**self == EXTSEL_A::HRTIM_ADCTRG3
}
#[doc = "Checks if the value of the field is `TIM1_CC1`"]
#[inline(always)]
pub fn is_tim1_cc1(&self) -> bool {
**self == EXTSEL_A::TIM1_CC1
}
#[doc = "Checks if the value of the field is `TIM1_CC2`"]
#[inline(always)]
pub fn is_tim1_cc2(&self) -> bool {
**self == EXTSEL_A::TIM1_CC2
}
#[doc = "Checks if the value of the field is `TIM1_CC3`"]
#[inline(always)]
pub fn is_tim1_cc3(&self) -> bool {
**self == EXTSEL_A::TIM1_CC3
}
#[doc = "Checks if the value of the field is `TIM2_CC2`"]
#[inline(always)]
pub fn is_tim2_cc2(&self) -> bool {
**self == EXTSEL_A::TIM2_CC2
}
#[doc = "Checks if the value of the field is `TIM3_TRGO`"]
#[inline(always)]
pub fn is_tim3_trgo(&self) -> bool {
**self == EXTSEL_A::TIM3_TRGO
}
#[doc = "Checks if the value of the field is `EXTI11`"]
#[inline(always)]
pub fn is_exti11(&self) -> bool {
**self == EXTSEL_A::EXTI11
}
#[doc = "Checks if the value of the field is `TIM1_TRGO`"]
#[inline(always)]
pub fn is_tim1_trgo(&self) -> bool {
**self == EXTSEL_A::TIM1_TRGO
}
#[doc = "Checks if the value of the field is `TIM1_TRGO2`"]
#[inline(always)]
pub fn is_tim1_trgo2(&self) -> bool {
**self == EXTSEL_A::TIM1_TRGO2
}
#[doc = "Checks if the value of the field is `TIM2_TRGO`"]
#[inline(always)]
pub fn is_tim2_trgo(&self) -> bool {
**self == EXTSEL_A::TIM2_TRGO
}
#[doc = "Checks if the value of the field is `TIM6_TRGO`"]
#[inline(always)]
pub fn is_tim6_trgo(&self) -> bool {
**self == EXTSEL_A::TIM6_TRGO
}
#[doc = "Checks if the value of the field is `TIM15_TRGO`"]
#[inline(always)]
pub fn is_tim15_trgo(&self) -> bool {
**self == EXTSEL_A::TIM15_TRGO
}
#[doc = "Checks if the value of the field is `TIM3_CC4`"]
#[inline(always)]
pub fn is_tim3_cc4(&self) -> bool {
**self == EXTSEL_A::TIM3_CC4
}
}
impl core::ops::Deref for EXTSEL_R {
type Target = crate::FieldReader<u8, EXTSEL_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `EXTSEL` writer - External trigger selection for regular group"]
pub struct EXTSEL_W<'a> {
w: &'a mut W,
}
impl<'a> EXTSEL_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: EXTSEL_A) -> &'a mut W {
unsafe { self.bits(variant.into()) }
}
#[doc = "HRTIM_ADCTRG1 event"]
#[inline(always)]
pub fn hrtim_adctrg1(self) -> &'a mut W {
self.variant(EXTSEL_A::HRTIM_ADCTRG1)
}
#[doc = "HRTIM_ADCTRG3 event"]
#[inline(always)]
pub fn hrtim_adctrg3(self) -> &'a mut W {
self.variant(EXTSEL_A::HRTIM_ADCTRG3)
}
#[doc = "Timer 1 CC1 event"]
#[inline(always)]
pub fn tim1_cc1(self) -> &'a mut W {
self.variant(EXTSEL_A::TIM1_CC1)
}
#[doc = "Timer 1 CC2 event"]
#[inline(always)]
pub fn tim1_cc2(self) -> &'a mut W {
self.variant(EXTSEL_A::TIM1_CC2)
}
#[doc = "Timer 1 CC3 event"]
#[inline(always)]
pub fn tim1_cc3(self) -> &'a mut W {
self.variant(EXTSEL_A::TIM1_CC3)
}
#[doc = "Timer 2 CC2 event"]
#[inline(always)]
pub fn tim2_cc2(self) -> &'a mut W {
self.variant(EXTSEL_A::TIM2_CC2)
}
#[doc = "Timer 3 TRGO event"]
#[inline(always)]
pub fn tim3_trgo(self) -> &'a mut W {
self.variant(EXTSEL_A::TIM3_TRGO)
}
#[doc = "EXTI line 11"]
#[inline(always)]
pub fn exti11(self) -> &'a mut W {
self.variant(EXTSEL_A::EXTI11)
}
#[doc = "Timer 1 TRGO event"]
#[inline(always)]
pub fn tim1_trgo(self) -> &'a mut W {
self.variant(EXTSEL_A::TIM1_TRGO)
}
#[doc = "Timer 1 TRGO2 event"]
#[inline(always)]
pub fn tim1_trgo2(self) -> &'a mut W {
self.variant(EXTSEL_A::TIM1_TRGO2)
}
#[doc = "Timer 2 TRGO event"]
#[inline(always)]
pub fn tim2_trgo(self) -> &'a mut W {
self.variant(EXTSEL_A::TIM2_TRGO)
}
#[doc = "Timer 6 TRGO event"]
#[inline(always)]
pub fn tim6_trgo(self) -> &'a mut W {
self.variant(EXTSEL_A::TIM6_TRGO)
}
#[doc = "Timer 15 TRGO event"]
#[inline(always)]
pub fn tim15_trgo(self) -> &'a mut W {
self.variant(EXTSEL_A::TIM15_TRGO)
}
#[doc = "Timer 3 CC4 event"]
#[inline(always)]
pub fn tim3_cc4(self) -> &'a mut W {
self.variant(EXTSEL_A::TIM3_CC4)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x1f << 5)) | ((value as u32 & 0x1f) << 5);
self.w
}
}
#[doc = "Data resolution\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(u8)]
pub enum RES_A {
#[doc = "0: 12-bit"]
BITS12 = 0,
#[doc = "1: 10-bit"]
BITS10 = 1,
#[doc = "2: 8-bit"]
BITS8 = 2,
#[doc = "3: 6-bit"]
BITS6 = 3,
}
impl From<RES_A> for u8 {
#[inline(always)]
fn from(variant: RES_A) -> Self {
variant as _
}
}
#[doc = "Field `RES` reader - Data resolution"]
pub struct RES_R(crate::FieldReader<u8, RES_A>);
impl RES_R {
pub(crate) fn new(bits: u8) -> Self {
RES_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> RES_A {
match self.bits {
0 => RES_A::BITS12,
1 => RES_A::BITS10,
2 => RES_A::BITS8,
3 => RES_A::BITS6,
_ => unreachable!(),
}
}
#[doc = "Checks if the value of the field is `BITS12`"]
#[inline(always)]
pub fn is_bits12(&self) -> bool {
**self == RES_A::BITS12
}
#[doc = "Checks if the value of the field is `BITS10`"]
#[inline(always)]
pub fn is_bits10(&self) -> bool {
**self == RES_A::BITS10
}
#[doc = "Checks if the value of the field is `BITS8`"]
#[inline(always)]
pub fn is_bits8(&self) -> bool {
**self == RES_A::BITS8
}
#[doc = "Checks if the value of the field is `BITS6`"]
#[inline(always)]
pub fn is_bits6(&self) -> bool {
**self == RES_A::BITS6
}
}
impl core::ops::Deref for RES_R {
type Target = crate::FieldReader<u8, RES_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `RES` writer - Data resolution"]
pub struct RES_W<'a> {
w: &'a mut W,
}
impl<'a> RES_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: RES_A) -> &'a mut W {
self.bits(variant.into())
}
#[doc = "12-bit"]
#[inline(always)]
pub fn bits12(self) -> &'a mut W {
self.variant(RES_A::BITS12)
}
#[doc = "10-bit"]
#[inline(always)]
pub fn bits10(self) -> &'a mut W {
self.variant(RES_A::BITS10)
}
#[doc = "8-bit"]
#[inline(always)]
pub fn bits8(self) -> &'a mut W {
self.variant(RES_A::BITS8)
}
#[doc = "6-bit"]
#[inline(always)]
pub fn bits6(self) -> &'a mut W {
self.variant(RES_A::BITS6)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x03 << 3)) | ((value as u32 & 0x03) << 3);
self.w
}
}
#[doc = "Direct memory access configuration\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum DMACFG_A {
#[doc = "0: DMA One Shot Mode selected"]
ONESHOT = 0,
#[doc = "1: DMA circular mode selected"]
CIRCULAR = 1,
}
impl From<DMACFG_A> for bool {
#[inline(always)]
fn from(variant: DMACFG_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `DMACFG` reader - Direct memory access configuration"]
pub struct DMACFG_R(crate::FieldReader<bool, DMACFG_A>);
impl DMACFG_R {
pub(crate) fn new(bits: bool) -> Self {
DMACFG_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> DMACFG_A {
match self.bits {
false => DMACFG_A::ONESHOT,
true => DMACFG_A::CIRCULAR,
}
}
#[doc = "Checks if the value of the field is `ONESHOT`"]
#[inline(always)]
pub fn is_one_shot(&self) -> bool {
**self == DMACFG_A::ONESHOT
}
#[doc = "Checks if the value of the field is `CIRCULAR`"]
#[inline(always)]
pub fn is_circular(&self) -> bool {
**self == DMACFG_A::CIRCULAR
}
}
impl core::ops::Deref for DMACFG_R {
type Target = crate::FieldReader<bool, DMACFG_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `DMACFG` writer - Direct memory access configuration"]
pub struct DMACFG_W<'a> {
w: &'a mut W,
}
impl<'a> DMACFG_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: DMACFG_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "DMA One Shot Mode selected"]
#[inline(always)]
pub fn one_shot(self) -> &'a mut W {
self.variant(DMACFG_A::ONESHOT)
}
#[doc = "DMA circular mode selected"]
#[inline(always)]
pub fn circular(self) -> &'a mut W {
self.variant(DMACFG_A::CIRCULAR)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 1)) | ((value as u32 & 0x01) << 1);
self.w
}
}
#[doc = "Direct memory access enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum DMAEN_A {
#[doc = "0: DMA disabled"]
DISABLED = 0,
#[doc = "1: DMA enabled"]
ENABLED = 1,
}
impl From<DMAEN_A> for bool {
#[inline(always)]
fn from(variant: DMAEN_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `DMAEN` reader - Direct memory access enable"]
pub struct DMAEN_R(crate::FieldReader<bool, DMAEN_A>);
impl DMAEN_R {
pub(crate) fn new(bits: bool) -> Self {
DMAEN_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> DMAEN_A {
match self.bits {
false => DMAEN_A::DISABLED,
true => DMAEN_A::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
**self == DMAEN_A::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
**self == DMAEN_A::ENABLED
}
}
impl core::ops::Deref for DMAEN_R {
type Target = crate::FieldReader<bool, DMAEN_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `DMAEN` writer - Direct memory access enable"]
pub struct DMAEN_W<'a> {
w: &'a mut W,
}
impl<'a> DMAEN_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: DMAEN_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "DMA disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(DMAEN_A::DISABLED)
}
#[doc = "DMA enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(DMAEN_A::ENABLED)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !0x01) | (value as u32 & 0x01);
self.w
}
}
impl R {
#[doc = "Bit 31 - Injected Queue disable"]
#[inline(always)]
pub fn jqdis(&self) -> JQDIS_R {
JQDIS_R::new(((self.bits >> 31) & 0x01) != 0)
}
#[doc = "Bits 26:30 - Analog watchdog 1 channel selection"]
#[inline(always)]
pub fn awd1ch(&self) -> AWD1CH_R {
AWD1CH_R::new(((self.bits >> 26) & 0x1f) as u8)
}
#[doc = "Bit 25 - Automatic injected group conversion"]
#[inline(always)]
pub fn jauto(&self) -> JAUTO_R {
JAUTO_R::new(((self.bits >> 25) & 0x01) != 0)
}
#[doc = "Bit 24 - Analog watchdog 1 enable on injected channels"]
#[inline(always)]
pub fn jawd1en(&self) -> JAWD1EN_R {
JAWD1EN_R::new(((self.bits >> 24) & 0x01) != 0)
}
#[doc = "Bit 23 - Analog watchdog 1 enable on regular channels"]
#[inline(always)]
pub fn awd1en(&self) -> AWD1EN_R {
AWD1EN_R::new(((self.bits >> 23) & 0x01) != 0)
}
#[doc = "Bit 22 - Enable the watchdog 1 on a single channel or on all channels"]
#[inline(always)]
pub fn awd1sgl(&self) -> AWD1SGL_R {
AWD1SGL_R::new(((self.bits >> 22) & 0x01) != 0)
}
#[doc = "Bit 21 - JSQR queue mode"]
#[inline(always)]
pub fn jqm(&self) -> JQM_R {
JQM_R::new(((self.bits >> 21) & 0x01) != 0)
}
#[doc = "Bit 20 - Discontinuous mode on injected channels"]
#[inline(always)]
pub fn jdiscen(&self) -> JDISCEN_R {
JDISCEN_R::new(((self.bits >> 20) & 0x01) != 0)
}
#[doc = "Bits 17:19 - Discontinuous mode channel count"]
#[inline(always)]
pub fn discnum(&self) -> DISCNUM_R {
DISCNUM_R::new(((self.bits >> 17) & 0x07) as u8)
}
#[doc = "Bit 16 - Discontinuous mode for regular channels"]
#[inline(always)]
pub fn discen(&self) -> DISCEN_R {
DISCEN_R::new(((self.bits >> 16) & 0x01) != 0)
}
#[doc = "Bit 15 - Data alignment"]
#[inline(always)]
pub fn align(&self) -> ALIGN_R {
ALIGN_R::new(((self.bits >> 15) & 0x01) != 0)
}
#[doc = "Bit 14 - Delayed conversion mode"]
#[inline(always)]
pub fn autdly(&self) -> AUTDLY_R {
AUTDLY_R::new(((self.bits >> 14) & 0x01) != 0)
}
#[doc = "Bit 13 - Single / continuous conversion mode for regular conversions"]
#[inline(always)]
pub fn cont(&self) -> CONT_R {
CONT_R::new(((self.bits >> 13) & 0x01) != 0)
}
#[doc = "Bit 12 - Overrun mode"]
#[inline(always)]
pub fn ovrmod(&self) -> OVRMOD_R {
OVRMOD_R::new(((self.bits >> 12) & 0x01) != 0)
}
#[doc = "Bits 10:11 - External trigger enable and polarity selection for regular channels"]
#[inline(always)]
pub fn exten(&self) -> EXTEN_R {
EXTEN_R::new(((self.bits >> 10) & 0x03) as u8)
}
#[doc = "Bits 5:9 - External trigger selection for regular group"]
#[inline(always)]
pub fn extsel(&self) -> EXTSEL_R {
EXTSEL_R::new(((self.bits >> 5) & 0x1f) as u8)
}
#[doc = "Bits 3:4 - Data resolution"]
#[inline(always)]
pub fn res(&self) -> RES_R {
RES_R::new(((self.bits >> 3) & 0x03) as u8)
}
#[doc = "Bit 1 - Direct memory access configuration"]
#[inline(always)]
pub fn dmacfg(&self) -> DMACFG_R {
DMACFG_R::new(((self.bits >> 1) & 0x01) != 0)
}
#[doc = "Bit 0 - Direct memory access enable"]
#[inline(always)]
pub fn dmaen(&self) -> DMAEN_R {
DMAEN_R::new((self.bits & 0x01) != 0)
}
}
impl W {
#[doc = "Bit 31 - Injected Queue disable"]
#[inline(always)]
pub fn jqdis(&mut self) -> JQDIS_W {
JQDIS_W { w: self }
}
#[doc = "Bits 26:30 - Analog watchdog 1 channel selection"]
#[inline(always)]
pub fn awd1ch(&mut self) -> AWD1CH_W {
AWD1CH_W { w: self }
}
#[doc = "Bit 25 - Automatic injected group conversion"]
#[inline(always)]
pub fn jauto(&mut self) -> JAUTO_W {
JAUTO_W { w: self }
}
#[doc = "Bit 24 - Analog watchdog 1 enable on injected channels"]
#[inline(always)]
pub fn jawd1en(&mut self) -> JAWD1EN_W {
JAWD1EN_W { w: self }
}
#[doc = "Bit 23 - Analog watchdog 1 enable on regular channels"]
#[inline(always)]
pub fn awd1en(&mut self) -> AWD1EN_W {
AWD1EN_W { w: self }
}
#[doc = "Bit 22 - Enable the watchdog 1 on a single channel or on all channels"]
#[inline(always)]
pub fn awd1sgl(&mut self) -> AWD1SGL_W {
AWD1SGL_W { w: self }
}
#[doc = "Bit 21 - JSQR queue mode"]
#[inline(always)]
pub fn jqm(&mut self) -> JQM_W {
JQM_W { w: self }
}
#[doc = "Bit 20 - Discontinuous mode on injected channels"]
#[inline(always)]
pub fn jdiscen(&mut self) -> JDISCEN_W {
JDISCEN_W { w: self }
}
#[doc = "Bits 17:19 - Discontinuous mode channel count"]
#[inline(always)]
pub fn discnum(&mut self) -> DISCNUM_W {
DISCNUM_W { w: self }
}
#[doc = "Bit 16 - Discontinuous mode for regular channels"]
#[inline(always)]
pub fn discen(&mut self) -> DISCEN_W {
DISCEN_W { w: self }
}
#[doc = "Bit 15 - Data alignment"]
#[inline(always)]
pub fn align(&mut self) -> ALIGN_W {
ALIGN_W { w: self }
}
#[doc = "Bit 14 - Delayed conversion mode"]
#[inline(always)]
pub fn autdly(&mut self) -> AUTDLY_W {
AUTDLY_W { w: self }
}
#[doc = "Bit 13 - Single / continuous conversion mode for regular conversions"]
#[inline(always)]
pub fn cont(&mut self) -> CONT_W {
CONT_W { w: self }
}
#[doc = "Bit 12 - Overrun mode"]
#[inline(always)]
pub fn ovrmod(&mut self) -> OVRMOD_W {
OVRMOD_W { w: self }
}
#[doc = "Bits 10:11 - External trigger enable and polarity selection for regular channels"]
#[inline(always)]
pub fn exten(&mut self) -> EXTEN_W {
EXTEN_W { w: self }
}
#[doc = "Bits 5:9 - External trigger selection for regular group"]
#[inline(always)]
pub fn extsel(&mut self) -> EXTSEL_W {
EXTSEL_W { w: self }
}
#[doc = "Bits 3:4 - Data resolution"]
#[inline(always)]
pub fn res(&mut self) -> RES_W {
RES_W { w: self }
}
#[doc = "Bit 1 - Direct memory access configuration"]
#[inline(always)]
pub fn dmacfg(&mut self) -> DMACFG_W {
DMACFG_W { w: self }
}
#[doc = "Bit 0 - Direct memory access enable"]
#[inline(always)]
pub fn dmaen(&mut self) -> DMAEN_W {
DMAEN_W { w: self }
}
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.0.bits(bits);
self
}
}
#[doc = "configuration register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [cfgr](index.html) module"]
pub struct CFGR_SPEC;
impl crate::RegisterSpec for CFGR_SPEC {
type Ux = u32;
}
#[doc = "`read()` method returns [cfgr::R](R) reader structure"]
impl crate::Readable for CFGR_SPEC {
type Reader = R;
}
#[doc = "`write(|w| ..)` method takes [cfgr::W](W) writer structure"]
impl crate::Writable for CFGR_SPEC {
type Writer = W;
}
#[doc = "`reset()` method sets CFGR to value 0x8000_0000"]
impl crate::Resettable for CFGR_SPEC {
#[inline(always)]
fn reset_value() -> Self::Ux {
0x8000_0000
}
}