#[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 = "Field `ADD4_7` reader - Address of the USART node"]
pub struct ADD4_7_R(crate::FieldReader<u8, u8>);
impl ADD4_7_R {
pub(crate) fn new(bits: u8) -> Self {
ADD4_7_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for ADD4_7_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ADD4_7` writer - Address of the USART node"]
pub struct ADD4_7_W<'a> {
w: &'a mut W,
}
impl<'a> ADD4_7_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 & !(0x0f << 28)) | ((value as u32 & 0x0f) << 28);
self.w
}
}
#[doc = "Field `ADD0_3` reader - Address of the USART node"]
pub struct ADD0_3_R(crate::FieldReader<u8, u8>);
impl ADD0_3_R {
pub(crate) fn new(bits: u8) -> Self {
ADD0_3_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for ADD0_3_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ADD0_3` writer - Address of the USART node"]
pub struct ADD0_3_W<'a> {
w: &'a mut W,
}
impl<'a> ADD0_3_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 & !(0x0f << 24)) | ((value as u32 & 0x0f) << 24);
self.w
}
}
#[doc = "Field `RTOEN` reader - Receiver timeout enable"]
pub struct RTOEN_R(crate::FieldReader<bool, bool>);
impl RTOEN_R {
pub(crate) fn new(bits: bool) -> Self {
RTOEN_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for RTOEN_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `RTOEN` writer - Receiver timeout enable"]
pub struct RTOEN_W<'a> {
w: &'a mut W,
}
impl<'a> RTOEN_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 << 23)) | ((value as u32 & 0x01) << 23);
self.w
}
}
#[doc = "Field `ABRMOD1` reader - Auto baud rate mode"]
pub struct ABRMOD1_R(crate::FieldReader<bool, bool>);
impl ABRMOD1_R {
pub(crate) fn new(bits: bool) -> Self {
ABRMOD1_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for ABRMOD1_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ABRMOD1` writer - Auto baud rate mode"]
pub struct ABRMOD1_W<'a> {
w: &'a mut W,
}
impl<'a> ABRMOD1_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 << 22)) | ((value as u32 & 0x01) << 22);
self.w
}
}
#[doc = "Field `ABRMOD0` reader - ABRMOD0"]
pub struct ABRMOD0_R(crate::FieldReader<bool, bool>);
impl ABRMOD0_R {
pub(crate) fn new(bits: bool) -> Self {
ABRMOD0_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for ABRMOD0_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ABRMOD0` writer - ABRMOD0"]
pub struct ABRMOD0_W<'a> {
w: &'a mut W,
}
impl<'a> ABRMOD0_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 << 21)) | ((value as u32 & 0x01) << 21);
self.w
}
}
#[doc = "Field `ABREN` reader - Auto baud rate enable"]
pub struct ABREN_R(crate::FieldReader<bool, bool>);
impl ABREN_R {
pub(crate) fn new(bits: bool) -> Self {
ABREN_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for ABREN_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ABREN` writer - Auto baud rate enable"]
pub struct ABREN_W<'a> {
w: &'a mut W,
}
impl<'a> ABREN_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 << 20)) | ((value as u32 & 0x01) << 20);
self.w
}
}
#[doc = "Field `MSBFIRST` reader - Most significant bit first"]
pub struct MSBFIRST_R(crate::FieldReader<bool, bool>);
impl MSBFIRST_R {
pub(crate) fn new(bits: bool) -> Self {
MSBFIRST_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for MSBFIRST_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `MSBFIRST` writer - Most significant bit first"]
pub struct MSBFIRST_W<'a> {
w: &'a mut W,
}
impl<'a> MSBFIRST_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 << 19)) | ((value as u32 & 0x01) << 19);
self.w
}
}
#[doc = "Field `TAINV` reader - Binary data inversion"]
pub struct TAINV_R(crate::FieldReader<bool, bool>);
impl TAINV_R {
pub(crate) fn new(bits: bool) -> Self {
TAINV_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for TAINV_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `TAINV` writer - Binary data inversion"]
pub struct TAINV_W<'a> {
w: &'a mut W,
}
impl<'a> TAINV_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 << 18)) | ((value as u32 & 0x01) << 18);
self.w
}
}
#[doc = "Field `TXINV` reader - TX pin active level inversion"]
pub struct TXINV_R(crate::FieldReader<bool, bool>);
impl TXINV_R {
pub(crate) fn new(bits: bool) -> Self {
TXINV_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for TXINV_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `TXINV` writer - TX pin active level inversion"]
pub struct TXINV_W<'a> {
w: &'a mut W,
}
impl<'a> TXINV_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 << 17)) | ((value as u32 & 0x01) << 17);
self.w
}
}
#[doc = "Field `RXINV` reader - RX pin active level inversion"]
pub struct RXINV_R(crate::FieldReader<bool, bool>);
impl RXINV_R {
pub(crate) fn new(bits: bool) -> Self {
RXINV_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for RXINV_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `RXINV` writer - RX pin active level inversion"]
pub struct RXINV_W<'a> {
w: &'a mut W,
}
impl<'a> RXINV_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 << 16)) | ((value as u32 & 0x01) << 16);
self.w
}
}
#[doc = "Field `SWAP` reader - Swap TX/RX pins"]
pub struct SWAP_R(crate::FieldReader<bool, bool>);
impl SWAP_R {
pub(crate) fn new(bits: bool) -> Self {
SWAP_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for SWAP_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `SWAP` writer - Swap TX/RX pins"]
pub struct SWAP_W<'a> {
w: &'a mut W,
}
impl<'a> SWAP_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 << 15)) | ((value as u32 & 0x01) << 15);
self.w
}
}
#[doc = "Field `LINEN` reader - LIN mode enable"]
pub struct LINEN_R(crate::FieldReader<bool, bool>);
impl LINEN_R {
pub(crate) fn new(bits: bool) -> Self {
LINEN_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for LINEN_R {
type Target = crate::FieldReader<bool, bool>;
#[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"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 = "Field `STOP` reader - STOP bits"]
pub struct STOP_R(crate::FieldReader<u8, u8>);
impl STOP_R {
pub(crate) fn new(bits: u8) -> Self {
STOP_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for STOP_R {
type Target = crate::FieldReader<u8, u8>;
#[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 raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x03 << 12)) | ((value as u32 & 0x03) << 12);
self.w
}
}
#[doc = "Field `CLKEN` reader - Clock enable"]
pub struct CLKEN_R(crate::FieldReader<bool, bool>);
impl CLKEN_R {
pub(crate) fn new(bits: bool) -> Self {
CLKEN_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for CLKEN_R {
type Target = crate::FieldReader<bool, bool>;
#[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"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 = "Field `CPOL` reader - Clock polarity"]
pub struct CPOL_R(crate::FieldReader<bool, bool>);
impl CPOL_R {
pub(crate) fn new(bits: bool) -> Self {
CPOL_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for CPOL_R {
type Target = crate::FieldReader<bool, bool>;
#[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"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 = "Field `CPHA` reader - Clock phase"]
pub struct CPHA_R(crate::FieldReader<bool, bool>);
impl CPHA_R {
pub(crate) fn new(bits: bool) -> Self {
CPHA_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for CPHA_R {
type Target = crate::FieldReader<bool, bool>;
#[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"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 = "Field `LBDIE` reader - LIN break detection interrupt enable"]
pub struct LBDIE_R(crate::FieldReader<bool, bool>);
impl LBDIE_R {
pub(crate) fn new(bits: bool) -> Self {
LBDIE_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for LBDIE_R {
type Target = crate::FieldReader<bool, bool>;
#[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"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 = "Field `LBDL` reader - LIN break detection length"]
pub struct LBDL_R(crate::FieldReader<bool, bool>);
impl LBDL_R {
pub(crate) fn new(bits: bool) -> Self {
LBDL_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for LBDL_R {
type Target = crate::FieldReader<bool, bool>;
#[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"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 `ADDM7` reader - 7-bit Address Detection/4-bit Address Detection"]
pub struct ADDM7_R(crate::FieldReader<bool, bool>);
impl ADDM7_R {
pub(crate) fn new(bits: bool) -> Self {
ADDM7_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for ADDM7_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ADDM7` writer - 7-bit Address Detection/4-bit Address Detection"]
pub struct ADDM7_W<'a> {
w: &'a mut W,
}
impl<'a> ADDM7_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 << 4)) | ((value as u32 & 0x01) << 4);
self.w
}
}
#[doc = "Field `DIS_NSS` reader - DIS_NSS"]
pub struct DIS_NSS_R(crate::FieldReader<bool, bool>);
impl DIS_NSS_R {
pub(crate) fn new(bits: bool) -> Self {
DIS_NSS_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for DIS_NSS_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `DIS_NSS` writer - DIS_NSS"]
pub struct DIS_NSS_W<'a> {
w: &'a mut W,
}
impl<'a> DIS_NSS_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 << 3)) | ((value as u32 & 0x01) << 3);
self.w
}
}
#[doc = "Field `SLVEN` reader - SLVEN"]
pub struct SLVEN_R(crate::FieldReader<bool, bool>);
impl SLVEN_R {
pub(crate) fn new(bits: bool) -> Self {
SLVEN_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for SLVEN_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `SLVEN` writer - SLVEN"]
pub struct SLVEN_W<'a> {
w: &'a mut W,
}
impl<'a> SLVEN_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) | (value as u32 & 0x01);
self.w
}
}
impl R {
#[doc = "Bits 28:31 - Address of the USART node"]
#[inline(always)]
pub fn add4_7(&self) -> ADD4_7_R {
ADD4_7_R::new(((self.bits >> 28) & 0x0f) as u8)
}
#[doc = "Bits 24:27 - Address of the USART node"]
#[inline(always)]
pub fn add0_3(&self) -> ADD0_3_R {
ADD0_3_R::new(((self.bits >> 24) & 0x0f) as u8)
}
#[doc = "Bit 23 - Receiver timeout enable"]
#[inline(always)]
pub fn rtoen(&self) -> RTOEN_R {
RTOEN_R::new(((self.bits >> 23) & 0x01) != 0)
}
#[doc = "Bit 22 - Auto baud rate mode"]
#[inline(always)]
pub fn abrmod1(&self) -> ABRMOD1_R {
ABRMOD1_R::new(((self.bits >> 22) & 0x01) != 0)
}
#[doc = "Bit 21 - ABRMOD0"]
#[inline(always)]
pub fn abrmod0(&self) -> ABRMOD0_R {
ABRMOD0_R::new(((self.bits >> 21) & 0x01) != 0)
}
#[doc = "Bit 20 - Auto baud rate enable"]
#[inline(always)]
pub fn abren(&self) -> ABREN_R {
ABREN_R::new(((self.bits >> 20) & 0x01) != 0)
}
#[doc = "Bit 19 - Most significant bit first"]
#[inline(always)]
pub fn msbfirst(&self) -> MSBFIRST_R {
MSBFIRST_R::new(((self.bits >> 19) & 0x01) != 0)
}
#[doc = "Bit 18 - Binary data inversion"]
#[inline(always)]
pub fn tainv(&self) -> TAINV_R {
TAINV_R::new(((self.bits >> 18) & 0x01) != 0)
}
#[doc = "Bit 17 - TX pin active level inversion"]
#[inline(always)]
pub fn txinv(&self) -> TXINV_R {
TXINV_R::new(((self.bits >> 17) & 0x01) != 0)
}
#[doc = "Bit 16 - RX pin active level inversion"]
#[inline(always)]
pub fn rxinv(&self) -> RXINV_R {
RXINV_R::new(((self.bits >> 16) & 0x01) != 0)
}
#[doc = "Bit 15 - Swap TX/RX pins"]
#[inline(always)]
pub fn swap(&self) -> SWAP_R {
SWAP_R::new(((self.bits >> 15) & 0x01) != 0)
}
#[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 = "Bit 4 - 7-bit Address Detection/4-bit Address Detection"]
#[inline(always)]
pub fn addm7(&self) -> ADDM7_R {
ADDM7_R::new(((self.bits >> 4) & 0x01) != 0)
}
#[doc = "Bit 3 - DIS_NSS"]
#[inline(always)]
pub fn dis_nss(&self) -> DIS_NSS_R {
DIS_NSS_R::new(((self.bits >> 3) & 0x01) != 0)
}
#[doc = "Bit 0 - SLVEN"]
#[inline(always)]
pub fn slven(&self) -> SLVEN_R {
SLVEN_R::new((self.bits & 0x01) != 0)
}
}
impl W {
#[doc = "Bits 28:31 - Address of the USART node"]
#[inline(always)]
pub fn add4_7(&mut self) -> ADD4_7_W {
ADD4_7_W { w: self }
}
#[doc = "Bits 24:27 - Address of the USART node"]
#[inline(always)]
pub fn add0_3(&mut self) -> ADD0_3_W {
ADD0_3_W { w: self }
}
#[doc = "Bit 23 - Receiver timeout enable"]
#[inline(always)]
pub fn rtoen(&mut self) -> RTOEN_W {
RTOEN_W { w: self }
}
#[doc = "Bit 22 - Auto baud rate mode"]
#[inline(always)]
pub fn abrmod1(&mut self) -> ABRMOD1_W {
ABRMOD1_W { w: self }
}
#[doc = "Bit 21 - ABRMOD0"]
#[inline(always)]
pub fn abrmod0(&mut self) -> ABRMOD0_W {
ABRMOD0_W { w: self }
}
#[doc = "Bit 20 - Auto baud rate enable"]
#[inline(always)]
pub fn abren(&mut self) -> ABREN_W {
ABREN_W { w: self }
}
#[doc = "Bit 19 - Most significant bit first"]
#[inline(always)]
pub fn msbfirst(&mut self) -> MSBFIRST_W {
MSBFIRST_W { w: self }
}
#[doc = "Bit 18 - Binary data inversion"]
#[inline(always)]
pub fn tainv(&mut self) -> TAINV_W {
TAINV_W { w: self }
}
#[doc = "Bit 17 - TX pin active level inversion"]
#[inline(always)]
pub fn txinv(&mut self) -> TXINV_W {
TXINV_W { w: self }
}
#[doc = "Bit 16 - RX pin active level inversion"]
#[inline(always)]
pub fn rxinv(&mut self) -> RXINV_W {
RXINV_W { w: self }
}
#[doc = "Bit 15 - Swap TX/RX pins"]
#[inline(always)]
pub fn swap(&mut self) -> SWAP_W {
SWAP_W { w: self }
}
#[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 = "Bit 4 - 7-bit Address Detection/4-bit Address Detection"]
#[inline(always)]
pub fn addm7(&mut self) -> ADDM7_W {
ADDM7_W { w: self }
}
#[doc = "Bit 3 - DIS_NSS"]
#[inline(always)]
pub fn dis_nss(&mut self) -> DIS_NSS_W {
DIS_NSS_W { w: self }
}
#[doc = "Bit 0 - SLVEN"]
#[inline(always)]
pub fn slven(&mut self) -> SLVEN_W {
SLVEN_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
}
}