#[doc = "Register `CR2` reader"]
pub struct R(crate::R<CR2_SPEC>);
impl core::ops::Deref for R {
type Target = crate::R<CR2_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<CR2_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<CR2_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `CR2` writer"]
pub struct W(crate::W<CR2_SPEC>);
impl core::ops::Deref for W {
type Target = crate::W<CR2_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<CR2_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<CR2_SPEC>) -> Self {
W(writer)
}
}
#[doc = "LIN mode enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum LINEN_A {
#[doc = "0: LIN mode disabled"]
DISABLED = 0,
#[doc = "1: LIN mode enabled"]
ENABLED = 1,
}
impl From<LINEN_A> for bool {
#[inline(always)]
fn from(variant: LINEN_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `LINEN` reader - LIN mode enable"]
pub struct LINEN_R(crate::FieldReader<bool, LINEN_A>);
impl LINEN_R {
pub(crate) fn new(bits: bool) -> Self {
LINEN_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> LINEN_A {
match self.bits {
false => LINEN_A::DISABLED,
true => LINEN_A::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
**self == LINEN_A::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
**self == LINEN_A::ENABLED
}
}
impl core::ops::Deref for LINEN_R {
type Target = crate::FieldReader<bool, LINEN_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `LINEN` writer - LIN mode enable"]
pub struct LINEN_W<'a> {
w: &'a mut W,
}
impl<'a> LINEN_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: LINEN_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "LIN mode disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(LINEN_A::DISABLED)
}
#[doc = "LIN mode enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(LINEN_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 << 14)) | ((value as u32 & 0x01) << 14);
self.w
}
}
#[doc = "STOP bits\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(u8)]
pub enum STOP_A {
#[doc = "0: 1 stop bit"]
STOP1 = 0,
#[doc = "1: 0.5 stop bits"]
STOP0P5 = 1,
#[doc = "2: 2 stop bits"]
STOP2 = 2,
#[doc = "3: 1.5 stop bits"]
STOP1P5 = 3,
}
impl From<STOP_A> for u8 {
#[inline(always)]
fn from(variant: STOP_A) -> Self {
variant as _
}
}
#[doc = "Field `STOP` reader - STOP bits"]
pub struct STOP_R(crate::FieldReader<u8, STOP_A>);
impl STOP_R {
pub(crate) fn new(bits: u8) -> Self {
STOP_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> STOP_A {
match self.bits {
0 => STOP_A::STOP1,
1 => STOP_A::STOP0P5,
2 => STOP_A::STOP2,
3 => STOP_A::STOP1P5,
_ => unreachable!(),
}
}
#[doc = "Checks if the value of the field is `STOP1`"]
#[inline(always)]
pub fn is_stop1(&self) -> bool {
**self == STOP_A::STOP1
}
#[doc = "Checks if the value of the field is `STOP0P5`"]
#[inline(always)]
pub fn is_stop0p5(&self) -> bool {
**self == STOP_A::STOP0P5
}
#[doc = "Checks if the value of the field is `STOP2`"]
#[inline(always)]
pub fn is_stop2(&self) -> bool {
**self == STOP_A::STOP2
}
#[doc = "Checks if the value of the field is `STOP1P5`"]
#[inline(always)]
pub fn is_stop1p5(&self) -> bool {
**self == STOP_A::STOP1P5
}
}
impl core::ops::Deref for STOP_R {
type Target = crate::FieldReader<u8, STOP_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `STOP` writer - STOP bits"]
pub struct STOP_W<'a> {
w: &'a mut W,
}
impl<'a> STOP_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: STOP_A) -> &'a mut W {
self.bits(variant.into())
}
#[doc = "1 stop bit"]
#[inline(always)]
pub fn stop1(self) -> &'a mut W {
self.variant(STOP_A::STOP1)
}
#[doc = "0.5 stop bits"]
#[inline(always)]
pub fn stop0p5(self) -> &'a mut W {
self.variant(STOP_A::STOP0P5)
}
#[doc = "2 stop bits"]
#[inline(always)]
pub fn stop2(self) -> &'a mut W {
self.variant(STOP_A::STOP2)
}
#[doc = "1.5 stop bits"]
#[inline(always)]
pub fn stop1p5(self) -> &'a mut W {
self.variant(STOP_A::STOP1P5)
}
#[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 << 12)) | ((value as u32 & 0x03) << 12);
self.w
}
}
#[doc = "Clock enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CLKEN_A {
#[doc = "0: CK pin disabled"]
DISABLED = 0,
#[doc = "1: CK pin enabled"]
ENABLED = 1,
}
impl From<CLKEN_A> for bool {
#[inline(always)]
fn from(variant: CLKEN_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `CLKEN` reader - Clock enable"]
pub struct CLKEN_R(crate::FieldReader<bool, CLKEN_A>);
impl CLKEN_R {
pub(crate) fn new(bits: bool) -> Self {
CLKEN_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CLKEN_A {
match self.bits {
false => CLKEN_A::DISABLED,
true => CLKEN_A::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
**self == CLKEN_A::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
**self == CLKEN_A::ENABLED
}
}
impl core::ops::Deref for CLKEN_R {
type Target = crate::FieldReader<bool, CLKEN_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `CLKEN` writer - Clock enable"]
pub struct CLKEN_W<'a> {
w: &'a mut W,
}
impl<'a> CLKEN_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: CLKEN_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "CK pin disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(CLKEN_A::DISABLED)
}
#[doc = "CK pin enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(CLKEN_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 << 11)) | ((value as u32 & 0x01) << 11);
self.w
}
}
#[doc = "Clock polarity\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CPOL_A {
#[doc = "0: Steady low value on CK pin outside transmission window"]
LOW = 0,
#[doc = "1: Steady high value on CK pin outside transmission window"]
HIGH = 1,
}
impl From<CPOL_A> for bool {
#[inline(always)]
fn from(variant: CPOL_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `CPOL` reader - Clock polarity"]
pub struct CPOL_R(crate::FieldReader<bool, CPOL_A>);
impl CPOL_R {
pub(crate) fn new(bits: bool) -> Self {
CPOL_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CPOL_A {
match self.bits {
false => CPOL_A::LOW,
true => CPOL_A::HIGH,
}
}
#[doc = "Checks if the value of the field is `LOW`"]
#[inline(always)]
pub fn is_low(&self) -> bool {
**self == CPOL_A::LOW
}
#[doc = "Checks if the value of the field is `HIGH`"]
#[inline(always)]
pub fn is_high(&self) -> bool {
**self == CPOL_A::HIGH
}
}
impl core::ops::Deref for CPOL_R {
type Target = crate::FieldReader<bool, CPOL_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `CPOL` writer - Clock polarity"]
pub struct CPOL_W<'a> {
w: &'a mut W,
}
impl<'a> CPOL_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: CPOL_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "Steady low value on CK pin outside transmission window"]
#[inline(always)]
pub fn low(self) -> &'a mut W {
self.variant(CPOL_A::LOW)
}
#[doc = "Steady high value on CK pin outside transmission window"]
#[inline(always)]
pub fn high(self) -> &'a mut W {
self.variant(CPOL_A::HIGH)
}
#[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 << 10)) | ((value as u32 & 0x01) << 10);
self.w
}
}
#[doc = "Clock phase\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CPHA_A {
#[doc = "0: The first clock transition is the first data capture edge"]
FIRST = 0,
#[doc = "1: The second clock transition is the first data capture edge"]
SECOND = 1,
}
impl From<CPHA_A> for bool {
#[inline(always)]
fn from(variant: CPHA_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `CPHA` reader - Clock phase"]
pub struct CPHA_R(crate::FieldReader<bool, CPHA_A>);
impl CPHA_R {
pub(crate) fn new(bits: bool) -> Self {
CPHA_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CPHA_A {
match self.bits {
false => CPHA_A::FIRST,
true => CPHA_A::SECOND,
}
}
#[doc = "Checks if the value of the field is `FIRST`"]
#[inline(always)]
pub fn is_first(&self) -> bool {
**self == CPHA_A::FIRST
}
#[doc = "Checks if the value of the field is `SECOND`"]
#[inline(always)]
pub fn is_second(&self) -> bool {
**self == CPHA_A::SECOND
}
}
impl core::ops::Deref for CPHA_R {
type Target = crate::FieldReader<bool, CPHA_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `CPHA` writer - Clock phase"]
pub struct CPHA_W<'a> {
w: &'a mut W,
}
impl<'a> CPHA_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: CPHA_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "The first clock transition is the first data capture edge"]
#[inline(always)]
pub fn first(self) -> &'a mut W {
self.variant(CPHA_A::FIRST)
}
#[doc = "The second clock transition is the first data capture edge"]
#[inline(always)]
pub fn second(self) -> &'a mut W {
self.variant(CPHA_A::SECOND)
}
#[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 << 9)) | ((value as u32 & 0x01) << 9);
self.w
}
}
#[doc = "Field `LBCL` reader - Last bit clock pulse"]
pub struct LBCL_R(crate::FieldReader<bool, bool>);
impl LBCL_R {
pub(crate) fn new(bits: bool) -> Self {
LBCL_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for LBCL_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `LBCL` writer - Last bit clock pulse"]
pub struct LBCL_W<'a> {
w: &'a mut W,
}
impl<'a> LBCL_W<'a> {
#[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 << 8)) | ((value as u32 & 0x01) << 8);
self.w
}
}
#[doc = "LIN break detection interrupt enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum LBDIE_A {
#[doc = "0: LIN break detection interrupt disabled"]
DISABLED = 0,
#[doc = "1: LIN break detection interrupt enabled"]
ENABLED = 1,
}
impl From<LBDIE_A> for bool {
#[inline(always)]
fn from(variant: LBDIE_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `LBDIE` reader - LIN break detection interrupt enable"]
pub struct LBDIE_R(crate::FieldReader<bool, LBDIE_A>);
impl LBDIE_R {
pub(crate) fn new(bits: bool) -> Self {
LBDIE_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> LBDIE_A {
match self.bits {
false => LBDIE_A::DISABLED,
true => LBDIE_A::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
**self == LBDIE_A::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
**self == LBDIE_A::ENABLED
}
}
impl core::ops::Deref for LBDIE_R {
type Target = crate::FieldReader<bool, LBDIE_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `LBDIE` writer - LIN break detection interrupt enable"]
pub struct LBDIE_W<'a> {
w: &'a mut W,
}
impl<'a> LBDIE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: LBDIE_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "LIN break detection interrupt disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(LBDIE_A::DISABLED)
}
#[doc = "LIN break detection interrupt enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(LBDIE_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 << 6)) | ((value as u32 & 0x01) << 6);
self.w
}
}
#[doc = "lin break detection length\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum LBDL_A {
#[doc = "0: 10-bit break detection"]
LBDL10 = 0,
#[doc = "1: 11-bit break detection"]
LBDL11 = 1,
}
impl From<LBDL_A> for bool {
#[inline(always)]
fn from(variant: LBDL_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `LBDL` reader - lin break detection length"]
pub struct LBDL_R(crate::FieldReader<bool, LBDL_A>);
impl LBDL_R {
pub(crate) fn new(bits: bool) -> Self {
LBDL_R(crate::FieldReader::new(bits))
}
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> LBDL_A {
match self.bits {
false => LBDL_A::LBDL10,
true => LBDL_A::LBDL11,
}
}
#[doc = "Checks if the value of the field is `LBDL10`"]
#[inline(always)]
pub fn is_lbdl10(&self) -> bool {
**self == LBDL_A::LBDL10
}
#[doc = "Checks if the value of the field is `LBDL11`"]
#[inline(always)]
pub fn is_lbdl11(&self) -> bool {
**self == LBDL_A::LBDL11
}
}
impl core::ops::Deref for LBDL_R {
type Target = crate::FieldReader<bool, LBDL_A>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `LBDL` writer - lin break detection length"]
pub struct LBDL_W<'a> {
w: &'a mut W,
}
impl<'a> LBDL_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: LBDL_A) -> &'a mut W {
self.bit(variant.into())
}
#[doc = "10-bit break detection"]
#[inline(always)]
pub fn lbdl10(self) -> &'a mut W {
self.variant(LBDL_A::LBDL10)
}
#[doc = "11-bit break detection"]
#[inline(always)]
pub fn lbdl11(self) -> &'a mut W {
self.variant(LBDL_A::LBDL11)
}
#[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 << 5)) | ((value as u32 & 0x01) << 5);
self.w
}
}
#[doc = "Field `ADD` reader - Address of the USART node"]
pub struct ADD_R(crate::FieldReader<u8, u8>);
impl ADD_R {
pub(crate) fn new(bits: u8) -> Self {
ADD_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for ADD_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ADD` writer - Address of the USART node"]
pub struct ADD_W<'a> {
w: &'a mut W,
}
impl<'a> ADD_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 & !0x0f) | (value as u32 & 0x0f);
self.w
}
}
impl R {
#[doc = "Bit 14 - LIN mode enable"]
#[inline(always)]
pub fn linen(&self) -> LINEN_R {
LINEN_R::new(((self.bits >> 14) & 0x01) != 0)
}
#[doc = "Bits 12:13 - STOP bits"]
#[inline(always)]
pub fn stop(&self) -> STOP_R {
STOP_R::new(((self.bits >> 12) & 0x03) as u8)
}
#[doc = "Bit 11 - Clock enable"]
#[inline(always)]
pub fn clken(&self) -> CLKEN_R {
CLKEN_R::new(((self.bits >> 11) & 0x01) != 0)
}
#[doc = "Bit 10 - Clock polarity"]
#[inline(always)]
pub fn cpol(&self) -> CPOL_R {
CPOL_R::new(((self.bits >> 10) & 0x01) != 0)
}
#[doc = "Bit 9 - Clock phase"]
#[inline(always)]
pub fn cpha(&self) -> CPHA_R {
CPHA_R::new(((self.bits >> 9) & 0x01) != 0)
}
#[doc = "Bit 8 - Last bit clock pulse"]
#[inline(always)]
pub fn lbcl(&self) -> LBCL_R {
LBCL_R::new(((self.bits >> 8) & 0x01) != 0)
}
#[doc = "Bit 6 - LIN break detection interrupt enable"]
#[inline(always)]
pub fn lbdie(&self) -> LBDIE_R {
LBDIE_R::new(((self.bits >> 6) & 0x01) != 0)
}
#[doc = "Bit 5 - lin break detection length"]
#[inline(always)]
pub fn lbdl(&self) -> LBDL_R {
LBDL_R::new(((self.bits >> 5) & 0x01) != 0)
}
#[doc = "Bits 0:3 - Address of the USART node"]
#[inline(always)]
pub fn add(&self) -> ADD_R {
ADD_R::new((self.bits & 0x0f) as u8)
}
}
impl W {
#[doc = "Bit 14 - LIN mode enable"]
#[inline(always)]
pub fn linen(&mut self) -> LINEN_W {
LINEN_W { w: self }
}
#[doc = "Bits 12:13 - STOP bits"]
#[inline(always)]
pub fn stop(&mut self) -> STOP_W {
STOP_W { w: self }
}
#[doc = "Bit 11 - Clock enable"]
#[inline(always)]
pub fn clken(&mut self) -> CLKEN_W {
CLKEN_W { w: self }
}
#[doc = "Bit 10 - Clock polarity"]
#[inline(always)]
pub fn cpol(&mut self) -> CPOL_W {
CPOL_W { w: self }
}
#[doc = "Bit 9 - Clock phase"]
#[inline(always)]
pub fn cpha(&mut self) -> CPHA_W {
CPHA_W { w: self }
}
#[doc = "Bit 8 - Last bit clock pulse"]
#[inline(always)]
pub fn lbcl(&mut self) -> LBCL_W {
LBCL_W { w: self }
}
#[doc = "Bit 6 - LIN break detection interrupt enable"]
#[inline(always)]
pub fn lbdie(&mut self) -> LBDIE_W {
LBDIE_W { w: self }
}
#[doc = "Bit 5 - lin break detection length"]
#[inline(always)]
pub fn lbdl(&mut self) -> LBDL_W {
LBDL_W { w: self }
}
#[doc = "Bits 0:3 - Address of the USART node"]
#[inline(always)]
pub fn add(&mut self) -> ADD_W {
ADD_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 = "Control register 2\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 [cr2](index.html) module"]
pub struct CR2_SPEC;
impl crate::RegisterSpec for CR2_SPEC {
type Ux = u32;
}
#[doc = "`read()` method returns [cr2::R](R) reader structure"]
impl crate::Readable for CR2_SPEC {
type Reader = R;
}
#[doc = "`write(|w| ..)` method takes [cr2::W](W) writer structure"]
impl crate::Writable for CR2_SPEC {
type Writer = W;
}
#[doc = "`reset()` method sets CR2 to value 0"]
impl crate::Resettable for CR2_SPEC {
#[inline(always)]
fn reset_value() -> Self::Ux {
0
}
}