#[doc = "Register `I2C_CR1` reader"]
pub struct R(crate::R<I2C_CR1_SPEC>);
impl core::ops::Deref for R {
type Target = crate::R<I2C_CR1_SPEC>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl From<crate::R<I2C_CR1_SPEC>> for R {
#[inline(always)]
fn from(reader: crate::R<I2C_CR1_SPEC>) -> Self {
R(reader)
}
}
#[doc = "Register `I2C_CR1` writer"]
pub struct W(crate::W<I2C_CR1_SPEC>);
impl core::ops::Deref for W {
type Target = crate::W<I2C_CR1_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<I2C_CR1_SPEC>> for W {
#[inline(always)]
fn from(writer: crate::W<I2C_CR1_SPEC>) -> Self {
W(writer)
}
}
#[doc = "Field `PE` reader - PE"]
pub struct PE_R(crate::FieldReader<bool, bool>);
impl PE_R {
pub(crate) fn new(bits: bool) -> Self {
PE_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for PE_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `PE` writer - PE"]
pub struct PE_W<'a> {
w: &'a mut W,
}
impl<'a> PE_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
}
}
#[doc = "Field `TXIE` reader - TXIE"]
pub struct TXIE_R(crate::FieldReader<bool, bool>);
impl TXIE_R {
pub(crate) fn new(bits: bool) -> Self {
TXIE_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for TXIE_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `TXIE` writer - TXIE"]
pub struct TXIE_W<'a> {
w: &'a mut W,
}
impl<'a> TXIE_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 << 1)) | ((value as u32 & 0x01) << 1);
self.w
}
}
#[doc = "Field `RXIE` reader - RXIE"]
pub struct RXIE_R(crate::FieldReader<bool, bool>);
impl RXIE_R {
pub(crate) fn new(bits: bool) -> Self {
RXIE_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for RXIE_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `RXIE` writer - RXIE"]
pub struct RXIE_W<'a> {
w: &'a mut W,
}
impl<'a> RXIE_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 << 2)) | ((value as u32 & 0x01) << 2);
self.w
}
}
#[doc = "Field `ADDRIE` reader - ADDRIE"]
pub struct ADDRIE_R(crate::FieldReader<bool, bool>);
impl ADDRIE_R {
pub(crate) fn new(bits: bool) -> Self {
ADDRIE_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for ADDRIE_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ADDRIE` writer - ADDRIE"]
pub struct ADDRIE_W<'a> {
w: &'a mut W,
}
impl<'a> ADDRIE_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 `NACKIE` reader - NACKIE"]
pub struct NACKIE_R(crate::FieldReader<bool, bool>);
impl NACKIE_R {
pub(crate) fn new(bits: bool) -> Self {
NACKIE_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for NACKIE_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `NACKIE` writer - NACKIE"]
pub struct NACKIE_W<'a> {
w: &'a mut W,
}
impl<'a> NACKIE_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 `STOPIE` reader - STOPIE"]
pub struct STOPIE_R(crate::FieldReader<bool, bool>);
impl STOPIE_R {
pub(crate) fn new(bits: bool) -> Self {
STOPIE_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for STOPIE_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `STOPIE` writer - STOPIE"]
pub struct STOPIE_W<'a> {
w: &'a mut W,
}
impl<'a> STOPIE_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 `TCIE` reader - TCIE"]
pub struct TCIE_R(crate::FieldReader<bool, bool>);
impl TCIE_R {
pub(crate) fn new(bits: bool) -> Self {
TCIE_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for TCIE_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `TCIE` writer - TCIE"]
pub struct TCIE_W<'a> {
w: &'a mut W,
}
impl<'a> TCIE_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 `ERRIE` reader - ERRIE"]
pub struct ERRIE_R(crate::FieldReader<bool, bool>);
impl ERRIE_R {
pub(crate) fn new(bits: bool) -> Self {
ERRIE_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for ERRIE_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ERRIE` writer - ERRIE"]
pub struct ERRIE_W<'a> {
w: &'a mut W,
}
impl<'a> ERRIE_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 << 7)) | ((value as u32 & 0x01) << 7);
self.w
}
}
#[doc = "Field `DNF` reader - DNF"]
pub struct DNF_R(crate::FieldReader<u8, u8>);
impl DNF_R {
pub(crate) fn new(bits: u8) -> Self {
DNF_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for DNF_R {
type Target = crate::FieldReader<u8, u8>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `DNF` writer - DNF"]
pub struct DNF_W<'a> {
w: &'a mut W,
}
impl<'a> DNF_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 << 8)) | ((value as u32 & 0x0f) << 8);
self.w
}
}
#[doc = "Field `ANFOFF` reader - ANFOFF"]
pub struct ANFOFF_R(crate::FieldReader<bool, bool>);
impl ANFOFF_R {
pub(crate) fn new(bits: bool) -> Self {
ANFOFF_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for ANFOFF_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ANFOFF` writer - ANFOFF"]
pub struct ANFOFF_W<'a> {
w: &'a mut W,
}
impl<'a> ANFOFF_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 << 12)) | ((value as u32 & 0x01) << 12);
self.w
}
}
#[doc = "Field `TXDMAEN` reader - TXDMAEN"]
pub struct TXDMAEN_R(crate::FieldReader<bool, bool>);
impl TXDMAEN_R {
pub(crate) fn new(bits: bool) -> Self {
TXDMAEN_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for TXDMAEN_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `TXDMAEN` writer - TXDMAEN"]
pub struct TXDMAEN_W<'a> {
w: &'a mut W,
}
impl<'a> TXDMAEN_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 `RXDMAEN` reader - RXDMAEN"]
pub struct RXDMAEN_R(crate::FieldReader<bool, bool>);
impl RXDMAEN_R {
pub(crate) fn new(bits: bool) -> Self {
RXDMAEN_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for RXDMAEN_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `RXDMAEN` writer - RXDMAEN"]
pub struct RXDMAEN_W<'a> {
w: &'a mut W,
}
impl<'a> RXDMAEN_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 `SBC` reader - SBC"]
pub struct SBC_R(crate::FieldReader<bool, bool>);
impl SBC_R {
pub(crate) fn new(bits: bool) -> Self {
SBC_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for SBC_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `SBC` writer - SBC"]
pub struct SBC_W<'a> {
w: &'a mut W,
}
impl<'a> SBC_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 `NOSTRETCH` reader - NOSTRETCH"]
pub struct NOSTRETCH_R(crate::FieldReader<bool, bool>);
impl NOSTRETCH_R {
pub(crate) fn new(bits: bool) -> Self {
NOSTRETCH_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for NOSTRETCH_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `NOSTRETCH` writer - NOSTRETCH"]
pub struct NOSTRETCH_W<'a> {
w: &'a mut W,
}
impl<'a> NOSTRETCH_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 `WUPEN` reader - WUPEN"]
pub struct WUPEN_R(crate::FieldReader<bool, bool>);
impl WUPEN_R {
pub(crate) fn new(bits: bool) -> Self {
WUPEN_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for WUPEN_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `WUPEN` writer - WUPEN"]
pub struct WUPEN_W<'a> {
w: &'a mut W,
}
impl<'a> WUPEN_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 `GCEN` reader - GCEN"]
pub struct GCEN_R(crate::FieldReader<bool, bool>);
impl GCEN_R {
pub(crate) fn new(bits: bool) -> Self {
GCEN_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for GCEN_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `GCEN` writer - GCEN"]
pub struct GCEN_W<'a> {
w: &'a mut W,
}
impl<'a> GCEN_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 `SMBHEN` reader - SMBHEN"]
pub struct SMBHEN_R(crate::FieldReader<bool, bool>);
impl SMBHEN_R {
pub(crate) fn new(bits: bool) -> Self {
SMBHEN_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for SMBHEN_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `SMBHEN` writer - SMBHEN"]
pub struct SMBHEN_W<'a> {
w: &'a mut W,
}
impl<'a> SMBHEN_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 `SMBDEN` reader - SMBDEN"]
pub struct SMBDEN_R(crate::FieldReader<bool, bool>);
impl SMBDEN_R {
pub(crate) fn new(bits: bool) -> Self {
SMBDEN_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for SMBDEN_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `SMBDEN` writer - SMBDEN"]
pub struct SMBDEN_W<'a> {
w: &'a mut W,
}
impl<'a> SMBDEN_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 `ALERTEN` reader - ALERTEN"]
pub struct ALERTEN_R(crate::FieldReader<bool, bool>);
impl ALERTEN_R {
pub(crate) fn new(bits: bool) -> Self {
ALERTEN_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for ALERTEN_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `ALERTEN` writer - ALERTEN"]
pub struct ALERTEN_W<'a> {
w: &'a mut W,
}
impl<'a> ALERTEN_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 `PECEN` reader - PECEN"]
pub struct PECEN_R(crate::FieldReader<bool, bool>);
impl PECEN_R {
pub(crate) fn new(bits: bool) -> Self {
PECEN_R(crate::FieldReader::new(bits))
}
}
impl core::ops::Deref for PECEN_R {
type Target = crate::FieldReader<bool, bool>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[doc = "Field `PECEN` writer - PECEN"]
pub struct PECEN_W<'a> {
w: &'a mut W,
}
impl<'a> PECEN_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
}
}
impl R {
#[doc = "Bit 0 - PE"]
#[inline(always)]
pub fn pe(&self) -> PE_R {
PE_R::new((self.bits & 0x01) != 0)
}
#[doc = "Bit 1 - TXIE"]
#[inline(always)]
pub fn txie(&self) -> TXIE_R {
TXIE_R::new(((self.bits >> 1) & 0x01) != 0)
}
#[doc = "Bit 2 - RXIE"]
#[inline(always)]
pub fn rxie(&self) -> RXIE_R {
RXIE_R::new(((self.bits >> 2) & 0x01) != 0)
}
#[doc = "Bit 3 - ADDRIE"]
#[inline(always)]
pub fn addrie(&self) -> ADDRIE_R {
ADDRIE_R::new(((self.bits >> 3) & 0x01) != 0)
}
#[doc = "Bit 4 - NACKIE"]
#[inline(always)]
pub fn nackie(&self) -> NACKIE_R {
NACKIE_R::new(((self.bits >> 4) & 0x01) != 0)
}
#[doc = "Bit 5 - STOPIE"]
#[inline(always)]
pub fn stopie(&self) -> STOPIE_R {
STOPIE_R::new(((self.bits >> 5) & 0x01) != 0)
}
#[doc = "Bit 6 - TCIE"]
#[inline(always)]
pub fn tcie(&self) -> TCIE_R {
TCIE_R::new(((self.bits >> 6) & 0x01) != 0)
}
#[doc = "Bit 7 - ERRIE"]
#[inline(always)]
pub fn errie(&self) -> ERRIE_R {
ERRIE_R::new(((self.bits >> 7) & 0x01) != 0)
}
#[doc = "Bits 8:11 - DNF"]
#[inline(always)]
pub fn dnf(&self) -> DNF_R {
DNF_R::new(((self.bits >> 8) & 0x0f) as u8)
}
#[doc = "Bit 12 - ANFOFF"]
#[inline(always)]
pub fn anfoff(&self) -> ANFOFF_R {
ANFOFF_R::new(((self.bits >> 12) & 0x01) != 0)
}
#[doc = "Bit 14 - TXDMAEN"]
#[inline(always)]
pub fn txdmaen(&self) -> TXDMAEN_R {
TXDMAEN_R::new(((self.bits >> 14) & 0x01) != 0)
}
#[doc = "Bit 15 - RXDMAEN"]
#[inline(always)]
pub fn rxdmaen(&self) -> RXDMAEN_R {
RXDMAEN_R::new(((self.bits >> 15) & 0x01) != 0)
}
#[doc = "Bit 16 - SBC"]
#[inline(always)]
pub fn sbc(&self) -> SBC_R {
SBC_R::new(((self.bits >> 16) & 0x01) != 0)
}
#[doc = "Bit 17 - NOSTRETCH"]
#[inline(always)]
pub fn nostretch(&self) -> NOSTRETCH_R {
NOSTRETCH_R::new(((self.bits >> 17) & 0x01) != 0)
}
#[doc = "Bit 18 - WUPEN"]
#[inline(always)]
pub fn wupen(&self) -> WUPEN_R {
WUPEN_R::new(((self.bits >> 18) & 0x01) != 0)
}
#[doc = "Bit 19 - GCEN"]
#[inline(always)]
pub fn gcen(&self) -> GCEN_R {
GCEN_R::new(((self.bits >> 19) & 0x01) != 0)
}
#[doc = "Bit 20 - SMBHEN"]
#[inline(always)]
pub fn smbhen(&self) -> SMBHEN_R {
SMBHEN_R::new(((self.bits >> 20) & 0x01) != 0)
}
#[doc = "Bit 21 - SMBDEN"]
#[inline(always)]
pub fn smbden(&self) -> SMBDEN_R {
SMBDEN_R::new(((self.bits >> 21) & 0x01) != 0)
}
#[doc = "Bit 22 - ALERTEN"]
#[inline(always)]
pub fn alerten(&self) -> ALERTEN_R {
ALERTEN_R::new(((self.bits >> 22) & 0x01) != 0)
}
#[doc = "Bit 23 - PECEN"]
#[inline(always)]
pub fn pecen(&self) -> PECEN_R {
PECEN_R::new(((self.bits >> 23) & 0x01) != 0)
}
}
impl W {
#[doc = "Bit 0 - PE"]
#[inline(always)]
pub fn pe(&mut self) -> PE_W {
PE_W { w: self }
}
#[doc = "Bit 1 - TXIE"]
#[inline(always)]
pub fn txie(&mut self) -> TXIE_W {
TXIE_W { w: self }
}
#[doc = "Bit 2 - RXIE"]
#[inline(always)]
pub fn rxie(&mut self) -> RXIE_W {
RXIE_W { w: self }
}
#[doc = "Bit 3 - ADDRIE"]
#[inline(always)]
pub fn addrie(&mut self) -> ADDRIE_W {
ADDRIE_W { w: self }
}
#[doc = "Bit 4 - NACKIE"]
#[inline(always)]
pub fn nackie(&mut self) -> NACKIE_W {
NACKIE_W { w: self }
}
#[doc = "Bit 5 - STOPIE"]
#[inline(always)]
pub fn stopie(&mut self) -> STOPIE_W {
STOPIE_W { w: self }
}
#[doc = "Bit 6 - TCIE"]
#[inline(always)]
pub fn tcie(&mut self) -> TCIE_W {
TCIE_W { w: self }
}
#[doc = "Bit 7 - ERRIE"]
#[inline(always)]
pub fn errie(&mut self) -> ERRIE_W {
ERRIE_W { w: self }
}
#[doc = "Bits 8:11 - DNF"]
#[inline(always)]
pub fn dnf(&mut self) -> DNF_W {
DNF_W { w: self }
}
#[doc = "Bit 12 - ANFOFF"]
#[inline(always)]
pub fn anfoff(&mut self) -> ANFOFF_W {
ANFOFF_W { w: self }
}
#[doc = "Bit 14 - TXDMAEN"]
#[inline(always)]
pub fn txdmaen(&mut self) -> TXDMAEN_W {
TXDMAEN_W { w: self }
}
#[doc = "Bit 15 - RXDMAEN"]
#[inline(always)]
pub fn rxdmaen(&mut self) -> RXDMAEN_W {
RXDMAEN_W { w: self }
}
#[doc = "Bit 16 - SBC"]
#[inline(always)]
pub fn sbc(&mut self) -> SBC_W {
SBC_W { w: self }
}
#[doc = "Bit 17 - NOSTRETCH"]
#[inline(always)]
pub fn nostretch(&mut self) -> NOSTRETCH_W {
NOSTRETCH_W { w: self }
}
#[doc = "Bit 18 - WUPEN"]
#[inline(always)]
pub fn wupen(&mut self) -> WUPEN_W {
WUPEN_W { w: self }
}
#[doc = "Bit 19 - GCEN"]
#[inline(always)]
pub fn gcen(&mut self) -> GCEN_W {
GCEN_W { w: self }
}
#[doc = "Bit 20 - SMBHEN"]
#[inline(always)]
pub fn smbhen(&mut self) -> SMBHEN_W {
SMBHEN_W { w: self }
}
#[doc = "Bit 21 - SMBDEN"]
#[inline(always)]
pub fn smbden(&mut self) -> SMBDEN_W {
SMBDEN_W { w: self }
}
#[doc = "Bit 22 - ALERTEN"]
#[inline(always)]
pub fn alerten(&mut self) -> ALERTEN_W {
ALERTEN_W { w: self }
}
#[doc = "Bit 23 - PECEN"]
#[inline(always)]
pub fn pecen(&mut self) -> PECEN_W {
PECEN_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 = "Access: No wait states, except if a write access occurs while a write access to this register is ongoing. In this case, wait states are inserted in the second write access until the previous one is completed. The latency of the second write access can be up to 2xi2c_pclk+6xi2c_ker_ck.\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 [i2c_cr1](index.html) module"]
pub struct I2C_CR1_SPEC;
impl crate::RegisterSpec for I2C_CR1_SPEC {
type Ux = u32;
}
#[doc = "`read()` method returns [i2c_cr1::R](R) reader structure"]
impl crate::Readable for I2C_CR1_SPEC {
type Reader = R;
}
#[doc = "`write(|w| ..)` method takes [i2c_cr1::W](W) writer structure"]
impl crate::Writable for I2C_CR1_SPEC {
type Writer = W;
}
#[doc = "`reset()` method sets I2C_CR1 to value 0"]
impl crate::Resettable for I2C_CR1_SPEC {
#[inline(always)]
fn reset_value() -> Self::Ux {
0
}
}