#[doc = "Reader of register CFG"]
pub type R = crate::R<u32, super::CFG>;
#[doc = "Writer for register CFG"]
pub type W = crate::W<u32, super::CFG>;
#[doc = "Register CFG `reset()`'s with value 0"]
impl crate::ResetValue for super::CFG {
type Type = u32;
#[inline(always)]
fn reset_value() -> Self::Type {
0
}
}
#[doc = "Possible values of the field `ENABLE`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ENABLE_A {
#[doc = "Disabled. The SPI is disabled and the internal state machine and counters are reset."]
DISABLED,
#[doc = "Enabled. The SPI is enabled for operation."]
ENABLED,
}
impl From<ENABLE_A> for bool {
#[inline(always)]
fn from(variant: ENABLE_A) -> Self {
match variant {
ENABLE_A::DISABLED => false,
ENABLE_A::ENABLED => true,
}
}
}
#[doc = "Reader of field `ENABLE`"]
pub type ENABLE_R = crate::R<bool, ENABLE_A>;
impl ENABLE_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> ENABLE_A {
match self.bits {
false => ENABLE_A::DISABLED,
true => ENABLE_A::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == ENABLE_A::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == ENABLE_A::ENABLED
}
}
#[doc = "Write proxy for field `ENABLE`"]
pub struct ENABLE_W<'a> {
w: &'a mut W,
}
impl<'a> ENABLE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: ENABLE_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Disabled. The SPI is disabled and the internal state machine and counters are reset."]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(ENABLE_A::DISABLED)
}
#[doc = "Enabled. The SPI is enabled for operation."]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(ENABLE_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
}
}
#[doc = "Possible values of the field `MASTER`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum MASTER_A {
#[doc = "Slave mode. The SPI will operate in slave mode. SCK, MOSI, and the SSEL signals are inputs, MISO is an output."]
SLAVE_MODE,
#[doc = "Master mode. The SPI will operate in master mode. SCK, MOSI, and the SSEL signals are outputs, MISO is an input."]
MASTER_MODE,
}
impl From<MASTER_A> for bool {
#[inline(always)]
fn from(variant: MASTER_A) -> Self {
match variant {
MASTER_A::SLAVE_MODE => false,
MASTER_A::MASTER_MODE => true,
}
}
}
#[doc = "Reader of field `MASTER`"]
pub type MASTER_R = crate::R<bool, MASTER_A>;
impl MASTER_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> MASTER_A {
match self.bits {
false => MASTER_A::SLAVE_MODE,
true => MASTER_A::MASTER_MODE,
}
}
#[doc = "Checks if the value of the field is `SLAVE_MODE`"]
#[inline(always)]
pub fn is_slave_mode(&self) -> bool {
*self == MASTER_A::SLAVE_MODE
}
#[doc = "Checks if the value of the field is `MASTER_MODE`"]
#[inline(always)]
pub fn is_master_mode(&self) -> bool {
*self == MASTER_A::MASTER_MODE
}
}
#[doc = "Write proxy for field `MASTER`"]
pub struct MASTER_W<'a> {
w: &'a mut W,
}
impl<'a> MASTER_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: MASTER_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Slave mode. The SPI will operate in slave mode. SCK, MOSI, and the SSEL signals are inputs, MISO is an output."]
#[inline(always)]
pub fn slave_mode(self) -> &'a mut W {
self.variant(MASTER_A::SLAVE_MODE)
}
#[doc = "Master mode. The SPI will operate in master mode. SCK, MOSI, and the SSEL signals are outputs, MISO is an input."]
#[inline(always)]
pub fn master_mode(self) -> &'a mut W {
self.variant(MASTER_A::MASTER_MODE)
}
#[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 = "Possible values of the field `LSBF`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum LSBF_A {
#[doc = "Standard. Data is transmitted and received in standard MSB first order."]
STANDARD,
#[doc = "Reverse. Data is transmitted and received in reverse order (LSB first)."]
REVERSE,
}
impl From<LSBF_A> for bool {
#[inline(always)]
fn from(variant: LSBF_A) -> Self {
match variant {
LSBF_A::STANDARD => false,
LSBF_A::REVERSE => true,
}
}
}
#[doc = "Reader of field `LSBF`"]
pub type LSBF_R = crate::R<bool, LSBF_A>;
impl LSBF_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> LSBF_A {
match self.bits {
false => LSBF_A::STANDARD,
true => LSBF_A::REVERSE,
}
}
#[doc = "Checks if the value of the field is `STANDARD`"]
#[inline(always)]
pub fn is_standard(&self) -> bool {
*self == LSBF_A::STANDARD
}
#[doc = "Checks if the value of the field is `REVERSE`"]
#[inline(always)]
pub fn is_reverse(&self) -> bool {
*self == LSBF_A::REVERSE
}
}
#[doc = "Write proxy for field `LSBF`"]
pub struct LSBF_W<'a> {
w: &'a mut W,
}
impl<'a> LSBF_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: LSBF_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Standard. Data is transmitted and received in standard MSB first order."]
#[inline(always)]
pub fn standard(self) -> &'a mut W {
self.variant(LSBF_A::STANDARD)
}
#[doc = "Reverse. Data is transmitted and received in reverse order (LSB first)."]
#[inline(always)]
pub fn reverse(self) -> &'a mut W {
self.variant(LSBF_A::REVERSE)
}
#[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 = "Possible values of the field `CPHA`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CPHA_A {
#[doc = "Change. The SPI captures serial data on the first clock transition of the transfer (when the clock changes away from the rest state). Data is changed on the following edge."]
CHANGE,
#[doc = "Capture. The SPI changes serial data on the first clock transition of the transfer (when the clock changes away from the rest state). Data is captured on the following edge."]
CAPTURE,
}
impl From<CPHA_A> for bool {
#[inline(always)]
fn from(variant: CPHA_A) -> Self {
match variant {
CPHA_A::CHANGE => false,
CPHA_A::CAPTURE => true,
}
}
}
#[doc = "Reader of field `CPHA`"]
pub type CPHA_R = crate::R<bool, CPHA_A>;
impl CPHA_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CPHA_A {
match self.bits {
false => CPHA_A::CHANGE,
true => CPHA_A::CAPTURE,
}
}
#[doc = "Checks if the value of the field is `CHANGE`"]
#[inline(always)]
pub fn is_change(&self) -> bool {
*self == CPHA_A::CHANGE
}
#[doc = "Checks if the value of the field is `CAPTURE`"]
#[inline(always)]
pub fn is_capture(&self) -> bool {
*self == CPHA_A::CAPTURE
}
}
#[doc = "Write proxy for field `CPHA`"]
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 = "Change. The SPI captures serial data on the first clock transition of the transfer (when the clock changes away from the rest state). Data is changed on the following edge."]
#[inline(always)]
pub fn change(self) -> &'a mut W {
self.variant(CPHA_A::CHANGE)
}
#[doc = "Capture. The SPI changes serial data on the first clock transition of the transfer (when the clock changes away from the rest state). Data is captured on the following edge."]
#[inline(always)]
pub fn capture(self) -> &'a mut W {
self.variant(CPHA_A::CAPTURE)
}
#[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 = "Possible values of the field `CPOL`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CPOL_A {
#[doc = "Low. The rest state of the clock (between transfers) is low."]
LOW,
#[doc = "High. The rest state of the clock (between transfers) is high."]
HIGH,
}
impl From<CPOL_A> for bool {
#[inline(always)]
fn from(variant: CPOL_A) -> Self {
match variant {
CPOL_A::LOW => false,
CPOL_A::HIGH => true,
}
}
}
#[doc = "Reader of field `CPOL`"]
pub type CPOL_R = crate::R<bool, CPOL_A>;
impl CPOL_R {
#[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
}
}
#[doc = "Write proxy for field `CPOL`"]
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 = "Low. The rest state of the clock (between transfers) is low."]
#[inline(always)]
pub fn low(self) -> &'a mut W {
self.variant(CPOL_A::LOW)
}
#[doc = "High. The rest state of the clock (between transfers) is high."]
#[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 << 5)) | (((value as u32) & 0x01) << 5);
self.w
}
}
#[doc = "Possible values of the field `LOOP`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum LOOP_A {
#[doc = "Disabled."]
DISABLED,
#[doc = "Enabled."]
ENABLED,
}
impl From<LOOP_A> for bool {
#[inline(always)]
fn from(variant: LOOP_A) -> Self {
match variant {
LOOP_A::DISABLED => false,
LOOP_A::ENABLED => true,
}
}
}
#[doc = "Reader of field `LOOP`"]
pub type LOOP_R = crate::R<bool, LOOP_A>;
impl LOOP_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> LOOP_A {
match self.bits {
false => LOOP_A::DISABLED,
true => LOOP_A::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == LOOP_A::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == LOOP_A::ENABLED
}
}
#[doc = "Write proxy for field `LOOP`"]
pub struct LOOP_W<'a> {
w: &'a mut W,
}
impl<'a> LOOP_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: LOOP_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Disabled."]
#[inline(always)]
pub fn disabled(self) -> &'a mut W {
self.variant(LOOP_A::DISABLED)
}
#[doc = "Enabled."]
#[inline(always)]
pub fn enabled(self) -> &'a mut W {
self.variant(LOOP_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 << 7)) | (((value as u32) & 0x01) << 7);
self.w
}
}
#[doc = "Possible values of the field `SPOL0`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum SPOL0_A {
#[doc = "Low. The SSEL0 pin is active low."]
LOW,
#[doc = "High. The SSEL0 pin is active high."]
HIGH,
}
impl From<SPOL0_A> for bool {
#[inline(always)]
fn from(variant: SPOL0_A) -> Self {
match variant {
SPOL0_A::LOW => false,
SPOL0_A::HIGH => true,
}
}
}
#[doc = "Reader of field `SPOL0`"]
pub type SPOL0_R = crate::R<bool, SPOL0_A>;
impl SPOL0_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> SPOL0_A {
match self.bits {
false => SPOL0_A::LOW,
true => SPOL0_A::HIGH,
}
}
#[doc = "Checks if the value of the field is `LOW`"]
#[inline(always)]
pub fn is_low(&self) -> bool {
*self == SPOL0_A::LOW
}
#[doc = "Checks if the value of the field is `HIGH`"]
#[inline(always)]
pub fn is_high(&self) -> bool {
*self == SPOL0_A::HIGH
}
}
#[doc = "Write proxy for field `SPOL0`"]
pub struct SPOL0_W<'a> {
w: &'a mut W,
}
impl<'a> SPOL0_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: SPOL0_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Low. The SSEL0 pin is active low."]
#[inline(always)]
pub fn low(self) -> &'a mut W {
self.variant(SPOL0_A::LOW)
}
#[doc = "High. The SSEL0 pin is active high."]
#[inline(always)]
pub fn high(self) -> &'a mut W {
self.variant(SPOL0_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 << 8)) | (((value as u32) & 0x01) << 8);
self.w
}
}
#[doc = "Possible values of the field `SPOL1`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum SPOL1_A {
#[doc = "Low. The SSEL1 pin is active low."]
LOW,
#[doc = "High. The SSEL1 pin is active high."]
HIGH,
}
impl From<SPOL1_A> for bool {
#[inline(always)]
fn from(variant: SPOL1_A) -> Self {
match variant {
SPOL1_A::LOW => false,
SPOL1_A::HIGH => true,
}
}
}
#[doc = "Reader of field `SPOL1`"]
pub type SPOL1_R = crate::R<bool, SPOL1_A>;
impl SPOL1_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> SPOL1_A {
match self.bits {
false => SPOL1_A::LOW,
true => SPOL1_A::HIGH,
}
}
#[doc = "Checks if the value of the field is `LOW`"]
#[inline(always)]
pub fn is_low(&self) -> bool {
*self == SPOL1_A::LOW
}
#[doc = "Checks if the value of the field is `HIGH`"]
#[inline(always)]
pub fn is_high(&self) -> bool {
*self == SPOL1_A::HIGH
}
}
#[doc = "Write proxy for field `SPOL1`"]
pub struct SPOL1_W<'a> {
w: &'a mut W,
}
impl<'a> SPOL1_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: SPOL1_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Low. The SSEL1 pin is active low."]
#[inline(always)]
pub fn low(self) -> &'a mut W {
self.variant(SPOL1_A::LOW)
}
#[doc = "High. The SSEL1 pin is active high."]
#[inline(always)]
pub fn high(self) -> &'a mut W {
self.variant(SPOL1_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 << 9)) | (((value as u32) & 0x01) << 9);
self.w
}
}
#[doc = "Possible values of the field `SPOL2`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum SPOL2_A {
#[doc = "Low. The SSEL2 pin is active low."]
LOW,
#[doc = "High. The SSEL2 pin is active high."]
HIGH,
}
impl From<SPOL2_A> for bool {
#[inline(always)]
fn from(variant: SPOL2_A) -> Self {
match variant {
SPOL2_A::LOW => false,
SPOL2_A::HIGH => true,
}
}
}
#[doc = "Reader of field `SPOL2`"]
pub type SPOL2_R = crate::R<bool, SPOL2_A>;
impl SPOL2_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> SPOL2_A {
match self.bits {
false => SPOL2_A::LOW,
true => SPOL2_A::HIGH,
}
}
#[doc = "Checks if the value of the field is `LOW`"]
#[inline(always)]
pub fn is_low(&self) -> bool {
*self == SPOL2_A::LOW
}
#[doc = "Checks if the value of the field is `HIGH`"]
#[inline(always)]
pub fn is_high(&self) -> bool {
*self == SPOL2_A::HIGH
}
}
#[doc = "Write proxy for field `SPOL2`"]
pub struct SPOL2_W<'a> {
w: &'a mut W,
}
impl<'a> SPOL2_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: SPOL2_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Low. The SSEL2 pin is active low."]
#[inline(always)]
pub fn low(self) -> &'a mut W {
self.variant(SPOL2_A::LOW)
}
#[doc = "High. The SSEL2 pin is active high."]
#[inline(always)]
pub fn high(self) -> &'a mut W {
self.variant(SPOL2_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 = "Possible values of the field `SPOL3`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum SPOL3_A {
#[doc = "Low. The SSEL3 pin is active low."]
LOW,
#[doc = "High. The SSEL3 pin is active high."]
HIGH,
}
impl From<SPOL3_A> for bool {
#[inline(always)]
fn from(variant: SPOL3_A) -> Self {
match variant {
SPOL3_A::LOW => false,
SPOL3_A::HIGH => true,
}
}
}
#[doc = "Reader of field `SPOL3`"]
pub type SPOL3_R = crate::R<bool, SPOL3_A>;
impl SPOL3_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> SPOL3_A {
match self.bits {
false => SPOL3_A::LOW,
true => SPOL3_A::HIGH,
}
}
#[doc = "Checks if the value of the field is `LOW`"]
#[inline(always)]
pub fn is_low(&self) -> bool {
*self == SPOL3_A::LOW
}
#[doc = "Checks if the value of the field is `HIGH`"]
#[inline(always)]
pub fn is_high(&self) -> bool {
*self == SPOL3_A::HIGH
}
}
#[doc = "Write proxy for field `SPOL3`"]
pub struct SPOL3_W<'a> {
w: &'a mut W,
}
impl<'a> SPOL3_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: SPOL3_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Low. The SSEL3 pin is active low."]
#[inline(always)]
pub fn low(self) -> &'a mut W {
self.variant(SPOL3_A::LOW)
}
#[doc = "High. The SSEL3 pin is active high."]
#[inline(always)]
pub fn high(self) -> &'a mut W {
self.variant(SPOL3_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 << 11)) | (((value as u32) & 0x01) << 11);
self.w
}
}
impl R {
#[doc = "Bit 0 - SPI enable."]
#[inline(always)]
pub fn enable(&self) -> ENABLE_R {
ENABLE_R::new((self.bits & 0x01) != 0)
}
#[doc = "Bit 2 - Master mode select."]
#[inline(always)]
pub fn master(&self) -> MASTER_R {
MASTER_R::new(((self.bits >> 2) & 0x01) != 0)
}
#[doc = "Bit 3 - LSB First mode enable."]
#[inline(always)]
pub fn lsbf(&self) -> LSBF_R {
LSBF_R::new(((self.bits >> 3) & 0x01) != 0)
}
#[doc = "Bit 4 - Clock Phase select."]
#[inline(always)]
pub fn cpha(&self) -> CPHA_R {
CPHA_R::new(((self.bits >> 4) & 0x01) != 0)
}
#[doc = "Bit 5 - Clock Polarity select."]
#[inline(always)]
pub fn cpol(&self) -> CPOL_R {
CPOL_R::new(((self.bits >> 5) & 0x01) != 0)
}
#[doc = "Bit 7 - Loopback mode enable. Loopback mode applies only to Master mode, and connects transmit and receive data connected together to allow simple software testing."]
#[inline(always)]
pub fn loop_(&self) -> LOOP_R {
LOOP_R::new(((self.bits >> 7) & 0x01) != 0)
}
#[doc = "Bit 8 - SSEL0 Polarity select."]
#[inline(always)]
pub fn spol0(&self) -> SPOL0_R {
SPOL0_R::new(((self.bits >> 8) & 0x01) != 0)
}
#[doc = "Bit 9 - SSEL1 Polarity select."]
#[inline(always)]
pub fn spol1(&self) -> SPOL1_R {
SPOL1_R::new(((self.bits >> 9) & 0x01) != 0)
}
#[doc = "Bit 10 - SSEL2 Polarity select."]
#[inline(always)]
pub fn spol2(&self) -> SPOL2_R {
SPOL2_R::new(((self.bits >> 10) & 0x01) != 0)
}
#[doc = "Bit 11 - SSEL3 Polarity select."]
#[inline(always)]
pub fn spol3(&self) -> SPOL3_R {
SPOL3_R::new(((self.bits >> 11) & 0x01) != 0)
}
}
impl W {
#[doc = "Bit 0 - SPI enable."]
#[inline(always)]
pub fn enable(&mut self) -> ENABLE_W {
ENABLE_W { w: self }
}
#[doc = "Bit 2 - Master mode select."]
#[inline(always)]
pub fn master(&mut self) -> MASTER_W {
MASTER_W { w: self }
}
#[doc = "Bit 3 - LSB First mode enable."]
#[inline(always)]
pub fn lsbf(&mut self) -> LSBF_W {
LSBF_W { w: self }
}
#[doc = "Bit 4 - Clock Phase select."]
#[inline(always)]
pub fn cpha(&mut self) -> CPHA_W {
CPHA_W { w: self }
}
#[doc = "Bit 5 - Clock Polarity select."]
#[inline(always)]
pub fn cpol(&mut self) -> CPOL_W {
CPOL_W { w: self }
}
#[doc = "Bit 7 - Loopback mode enable. Loopback mode applies only to Master mode, and connects transmit and receive data connected together to allow simple software testing."]
#[inline(always)]
pub fn loop_(&mut self) -> LOOP_W {
LOOP_W { w: self }
}
#[doc = "Bit 8 - SSEL0 Polarity select."]
#[inline(always)]
pub fn spol0(&mut self) -> SPOL0_W {
SPOL0_W { w: self }
}
#[doc = "Bit 9 - SSEL1 Polarity select."]
#[inline(always)]
pub fn spol1(&mut self) -> SPOL1_W {
SPOL1_W { w: self }
}
#[doc = "Bit 10 - SSEL2 Polarity select."]
#[inline(always)]
pub fn spol2(&mut self) -> SPOL2_W {
SPOL2_W { w: self }
}
#[doc = "Bit 11 - SSEL3 Polarity select."]
#[inline(always)]
pub fn spol3(&mut self) -> SPOL3_W {
SPOL3_W { w: self }
}
}