#[doc = "Register `RES_STATUS` reader"]
pub type R = crate::R<ResStatusSpec>;
#[doc = "Register `RES_STATUS` writer"]
pub type W = crate::W<ResStatusSpec>;
#[doc = "RES0 IEEE Inexact Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Res0Nx {
#[doc = "0: The result is not rounded."]
Res0NxNo = 0,
#[doc = "1: The result is rounded, and as a result some digits lost."]
Res0NxYes = 1,
}
impl From<Res0Nx> for bool {
#[inline(always)]
fn from(variant: Res0Nx) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `RES0_NX` reader - RES0 IEEE Inexact Flag"]
pub type Res0NxR = crate::BitReader<Res0Nx>;
impl Res0NxR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Res0Nx {
match self.bits {
false => Res0Nx::Res0NxNo,
true => Res0Nx::Res0NxYes,
}
}
#[doc = "The result is not rounded."]
#[inline(always)]
pub fn is_res0_nx_no(&self) -> bool {
*self == Res0Nx::Res0NxNo
}
#[doc = "The result is rounded, and as a result some digits lost."]
#[inline(always)]
pub fn is_res0_nx_yes(&self) -> bool {
*self == Res0Nx::Res0NxYes
}
}
#[doc = "Field `RES0_NX` writer - RES0 IEEE Inexact Flag"]
pub type Res0NxW<'a, REG> = crate::BitWriter<'a, REG, Res0Nx>;
impl<'a, REG> Res0NxW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "The result is not rounded."]
#[inline(always)]
pub fn res0_nx_no(self) -> &'a mut crate::W<REG> {
self.variant(Res0Nx::Res0NxNo)
}
#[doc = "The result is rounded, and as a result some digits lost."]
#[inline(always)]
pub fn res0_nx_yes(self) -> &'a mut crate::W<REG> {
self.variant(Res0Nx::Res0NxYes)
}
}
#[doc = "RES0 IEEE Underflow Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Res0Uf {
#[doc = "0: No tiny non-zero result is detected."]
Res0UfNo = 0,
#[doc = "1: A tiny non-zero result is detected."]
Res0UfYes = 1,
}
impl From<Res0Uf> for bool {
#[inline(always)]
fn from(variant: Res0Uf) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `RES0_UF` reader - RES0 IEEE Underflow Flag"]
pub type Res0UfR = crate::BitReader<Res0Uf>;
impl Res0UfR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Res0Uf {
match self.bits {
false => Res0Uf::Res0UfNo,
true => Res0Uf::Res0UfYes,
}
}
#[doc = "No tiny non-zero result is detected."]
#[inline(always)]
pub fn is_res0_uf_no(&self) -> bool {
*self == Res0Uf::Res0UfNo
}
#[doc = "A tiny non-zero result is detected."]
#[inline(always)]
pub fn is_res0_uf_yes(&self) -> bool {
*self == Res0Uf::Res0UfYes
}
}
#[doc = "Field `RES0_UF` writer - RES0 IEEE Underflow Flag"]
pub type Res0UfW<'a, REG> = crate::BitWriter<'a, REG, Res0Uf>;
impl<'a, REG> Res0UfW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "No tiny non-zero result is detected."]
#[inline(always)]
pub fn res0_uf_no(self) -> &'a mut crate::W<REG> {
self.variant(Res0Uf::Res0UfNo)
}
#[doc = "A tiny non-zero result is detected."]
#[inline(always)]
pub fn res0_uf_yes(self) -> &'a mut crate::W<REG> {
self.variant(Res0Uf::Res0UfYes)
}
}
#[doc = "RES0 IEEE Overflow Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Res0Of {
#[doc = "0: The result format's largest finite number is not exceeded."]
Res0OfNo = 0,
#[doc = "1: The result format's largest finite number is exceeded."]
Res0OfYes = 1,
}
impl From<Res0Of> for bool {
#[inline(always)]
fn from(variant: Res0Of) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `RES0_OF` reader - RES0 IEEE Overflow Flag"]
pub type Res0OfR = crate::BitReader<Res0Of>;
impl Res0OfR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Res0Of {
match self.bits {
false => Res0Of::Res0OfNo,
true => Res0Of::Res0OfYes,
}
}
#[doc = "The result format's largest finite number is not exceeded."]
#[inline(always)]
pub fn is_res0_of_no(&self) -> bool {
*self == Res0Of::Res0OfNo
}
#[doc = "The result format's largest finite number is exceeded."]
#[inline(always)]
pub fn is_res0_of_yes(&self) -> bool {
*self == Res0Of::Res0OfYes
}
}
#[doc = "Field `RES0_OF` writer - RES0 IEEE Overflow Flag"]
pub type Res0OfW<'a, REG> = crate::BitWriter<'a, REG, Res0Of>;
impl<'a, REG> Res0OfW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "The result format's largest finite number is not exceeded."]
#[inline(always)]
pub fn res0_of_no(self) -> &'a mut crate::W<REG> {
self.variant(Res0Of::Res0OfNo)
}
#[doc = "The result format's largest finite number is exceeded."]
#[inline(always)]
pub fn res0_of_yes(self) -> &'a mut crate::W<REG> {
self.variant(Res0Of::Res0OfYes)
}
}
#[doc = "RES0 IEEE Divide by Zero Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Res0Dz {
#[doc = "0: No exact infinite result is defined for an operation on finite operands."]
Res0DzNo = 0,
#[doc = "1: An exact infinite result is defined for an operation on finite operands."]
Res0DzYes = 1,
}
impl From<Res0Dz> for bool {
#[inline(always)]
fn from(variant: Res0Dz) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `RES0_DZ` reader - RES0 IEEE Divide by Zero Flag"]
pub type Res0DzR = crate::BitReader<Res0Dz>;
impl Res0DzR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Res0Dz {
match self.bits {
false => Res0Dz::Res0DzNo,
true => Res0Dz::Res0DzYes,
}
}
#[doc = "No exact infinite result is defined for an operation on finite operands."]
#[inline(always)]
pub fn is_res0_dz_no(&self) -> bool {
*self == Res0Dz::Res0DzNo
}
#[doc = "An exact infinite result is defined for an operation on finite operands."]
#[inline(always)]
pub fn is_res0_dz_yes(&self) -> bool {
*self == Res0Dz::Res0DzYes
}
}
#[doc = "Field `RES0_DZ` writer - RES0 IEEE Divide by Zero Flag"]
pub type Res0DzW<'a, REG> = crate::BitWriter<'a, REG, Res0Dz>;
impl<'a, REG> Res0DzW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "No exact infinite result is defined for an operation on finite operands."]
#[inline(always)]
pub fn res0_dz_no(self) -> &'a mut crate::W<REG> {
self.variant(Res0Dz::Res0DzNo)
}
#[doc = "An exact infinite result is defined for an operation on finite operands."]
#[inline(always)]
pub fn res0_dz_yes(self) -> &'a mut crate::W<REG> {
self.variant(Res0Dz::Res0DzYes)
}
}
#[doc = "RES0 IEEE Invalid Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Res0Nv {
#[doc = "0: There is usefully definable result."]
Res0NvNo = 0,
#[doc = "1: There is no usefully definable result."]
Res0NvYes = 1,
}
impl From<Res0Nv> for bool {
#[inline(always)]
fn from(variant: Res0Nv) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `RES0_NV` reader - RES0 IEEE Invalid Flag"]
pub type Res0NvR = crate::BitReader<Res0Nv>;
impl Res0NvR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Res0Nv {
match self.bits {
false => Res0Nv::Res0NvNo,
true => Res0Nv::Res0NvYes,
}
}
#[doc = "There is usefully definable result."]
#[inline(always)]
pub fn is_res0_nv_no(&self) -> bool {
*self == Res0Nv::Res0NvNo
}
#[doc = "There is no usefully definable result."]
#[inline(always)]
pub fn is_res0_nv_yes(&self) -> bool {
*self == Res0Nv::Res0NvYes
}
}
#[doc = "Field `RES0_NV` writer - RES0 IEEE Invalid Flag"]
pub type Res0NvW<'a, REG> = crate::BitWriter<'a, REG, Res0Nv>;
impl<'a, REG> Res0NvW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "There is usefully definable result."]
#[inline(always)]
pub fn res0_nv_no(self) -> &'a mut crate::W<REG> {
self.variant(Res0Nv::Res0NvNo)
}
#[doc = "There is no usefully definable result."]
#[inline(always)]
pub fn res0_nv_yes(self) -> &'a mut crate::W<REG> {
self.variant(Res0Nv::Res0NvYes)
}
}
#[doc = "RES0 Indirect Operation Error Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Res0Err {
#[doc = "0: No invalid indirect operation is detected."]
Res0ErrNo = 0,
#[doc = "1: An invalid indirect operation error is detected."]
Res0ErrYes = 1,
}
impl From<Res0Err> for bool {
#[inline(always)]
fn from(variant: Res0Err) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `RES0_ERR` reader - RES0 Indirect Operation Error Flag"]
pub type Res0ErrR = crate::BitReader<Res0Err>;
impl Res0ErrR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Res0Err {
match self.bits {
false => Res0Err::Res0ErrNo,
true => Res0Err::Res0ErrYes,
}
}
#[doc = "No invalid indirect operation is detected."]
#[inline(always)]
pub fn is_res0_err_no(&self) -> bool {
*self == Res0Err::Res0ErrNo
}
#[doc = "An invalid indirect operation error is detected."]
#[inline(always)]
pub fn is_res0_err_yes(&self) -> bool {
*self == Res0Err::Res0ErrYes
}
}
#[doc = "Field `RES0_ERR` writer - RES0 Indirect Operation Error Flag"]
pub type Res0ErrW<'a, REG> = crate::BitWriter<'a, REG, Res0Err>;
impl<'a, REG> Res0ErrW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "No invalid indirect operation is detected."]
#[inline(always)]
pub fn res0_err_no(self) -> &'a mut crate::W<REG> {
self.variant(Res0Err::Res0ErrNo)
}
#[doc = "An invalid indirect operation error is detected."]
#[inline(always)]
pub fn res0_err_yes(self) -> &'a mut crate::W<REG> {
self.variant(Res0Err::Res0ErrYes)
}
}
#[doc = "RES0 Overwrite Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Res0Ovwr {
#[doc = "0: The value of RES0 has been read."]
Res0OvwrNo = 0,
#[doc = "1: The value of RES0 has not been read yet and is overwritten by a new MAUWRAP result."]
Res0OvwrYes = 1,
}
impl From<Res0Ovwr> for bool {
#[inline(always)]
fn from(variant: Res0Ovwr) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `RES0_OVWR` reader - RES0 Overwrite Flag"]
pub type Res0OvwrR = crate::BitReader<Res0Ovwr>;
impl Res0OvwrR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Res0Ovwr {
match self.bits {
false => Res0Ovwr::Res0OvwrNo,
true => Res0Ovwr::Res0OvwrYes,
}
}
#[doc = "The value of RES0 has been read."]
#[inline(always)]
pub fn is_res0_ovwr_no(&self) -> bool {
*self == Res0Ovwr::Res0OvwrNo
}
#[doc = "The value of RES0 has not been read yet and is overwritten by a new MAUWRAP result."]
#[inline(always)]
pub fn is_res0_ovwr_yes(&self) -> bool {
*self == Res0Ovwr::Res0OvwrYes
}
}
#[doc = "Field `RES0_OVWR` writer - RES0 Overwrite Flag"]
pub type Res0OvwrW<'a, REG> = crate::BitWriter<'a, REG, Res0Ovwr>;
impl<'a, REG> Res0OvwrW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "The value of RES0 has been read."]
#[inline(always)]
pub fn res0_ovwr_no(self) -> &'a mut crate::W<REG> {
self.variant(Res0Ovwr::Res0OvwrNo)
}
#[doc = "The value of RES0 has not been read yet and is overwritten by a new MAUWRAP result."]
#[inline(always)]
pub fn res0_ovwr_yes(self) -> &'a mut crate::W<REG> {
self.variant(Res0Ovwr::Res0OvwrYes)
}
}
#[doc = "RES0 Full Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Res0Full {
#[doc = "0: RES0 has not updated and cannot be read."]
Res0FullNo = 0,
#[doc = "1: RES0 has updated and can be read."]
Res0FullYes = 1,
}
impl From<Res0Full> for bool {
#[inline(always)]
fn from(variant: Res0Full) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `RES0_FULL` reader - RES0 Full Flag"]
pub type Res0FullR = crate::BitReader<Res0Full>;
impl Res0FullR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Res0Full {
match self.bits {
false => Res0Full::Res0FullNo,
true => Res0Full::Res0FullYes,
}
}
#[doc = "RES0 has not updated and cannot be read."]
#[inline(always)]
pub fn is_res0_full_no(&self) -> bool {
*self == Res0Full::Res0FullNo
}
#[doc = "RES0 has updated and can be read."]
#[inline(always)]
pub fn is_res0_full_yes(&self) -> bool {
*self == Res0Full::Res0FullYes
}
}
#[doc = "Field `RES0_FULL` writer - RES0 Full Flag"]
pub type Res0FullW<'a, REG> = crate::BitWriter<'a, REG, Res0Full>;
impl<'a, REG> Res0FullW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "RES0 has not updated and cannot be read."]
#[inline(always)]
pub fn res0_full_no(self) -> &'a mut crate::W<REG> {
self.variant(Res0Full::Res0FullNo)
}
#[doc = "RES0 has updated and can be read."]
#[inline(always)]
pub fn res0_full_yes(self) -> &'a mut crate::W<REG> {
self.variant(Res0Full::Res0FullYes)
}
}
#[doc = "RES1 IEEE Inexact Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Res1Nx {
#[doc = "0: The result is not rounded."]
Res1NxNo = 0,
#[doc = "1: The result is rounded, and as a result some digits lost."]
Res1NxYes = 1,
}
impl From<Res1Nx> for bool {
#[inline(always)]
fn from(variant: Res1Nx) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `RES1_NX` reader - RES1 IEEE Inexact Flag"]
pub type Res1NxR = crate::BitReader<Res1Nx>;
impl Res1NxR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Res1Nx {
match self.bits {
false => Res1Nx::Res1NxNo,
true => Res1Nx::Res1NxYes,
}
}
#[doc = "The result is not rounded."]
#[inline(always)]
pub fn is_res1_nx_no(&self) -> bool {
*self == Res1Nx::Res1NxNo
}
#[doc = "The result is rounded, and as a result some digits lost."]
#[inline(always)]
pub fn is_res1_nx_yes(&self) -> bool {
*self == Res1Nx::Res1NxYes
}
}
#[doc = "Field `RES1_NX` writer - RES1 IEEE Inexact Flag"]
pub type Res1NxW<'a, REG> = crate::BitWriter<'a, REG, Res1Nx>;
impl<'a, REG> Res1NxW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "The result is not rounded."]
#[inline(always)]
pub fn res1_nx_no(self) -> &'a mut crate::W<REG> {
self.variant(Res1Nx::Res1NxNo)
}
#[doc = "The result is rounded, and as a result some digits lost."]
#[inline(always)]
pub fn res1_nx_yes(self) -> &'a mut crate::W<REG> {
self.variant(Res1Nx::Res1NxYes)
}
}
#[doc = "RES1 IEEE Underflow Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Res1Uf {
#[doc = "0: No tiny non-zero result is detected."]
Res1UfNo = 0,
#[doc = "1: A tiny non-zero result is detected."]
Res1UfYes = 1,
}
impl From<Res1Uf> for bool {
#[inline(always)]
fn from(variant: Res1Uf) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `RES1_UF` reader - RES1 IEEE Underflow Flag"]
pub type Res1UfR = crate::BitReader<Res1Uf>;
impl Res1UfR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Res1Uf {
match self.bits {
false => Res1Uf::Res1UfNo,
true => Res1Uf::Res1UfYes,
}
}
#[doc = "No tiny non-zero result is detected."]
#[inline(always)]
pub fn is_res1_uf_no(&self) -> bool {
*self == Res1Uf::Res1UfNo
}
#[doc = "A tiny non-zero result is detected."]
#[inline(always)]
pub fn is_res1_uf_yes(&self) -> bool {
*self == Res1Uf::Res1UfYes
}
}
#[doc = "Field `RES1_UF` writer - RES1 IEEE Underflow Flag"]
pub type Res1UfW<'a, REG> = crate::BitWriter<'a, REG, Res1Uf>;
impl<'a, REG> Res1UfW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "No tiny non-zero result is detected."]
#[inline(always)]
pub fn res1_uf_no(self) -> &'a mut crate::W<REG> {
self.variant(Res1Uf::Res1UfNo)
}
#[doc = "A tiny non-zero result is detected."]
#[inline(always)]
pub fn res1_uf_yes(self) -> &'a mut crate::W<REG> {
self.variant(Res1Uf::Res1UfYes)
}
}
#[doc = "RES1 IEEE Overflow Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Res1Of {
#[doc = "0: The result format's largest finite number is not exceeded."]
Res1OfNo = 0,
#[doc = "1: The result format's largest finite number is exceeded."]
Res1OfYes = 1,
}
impl From<Res1Of> for bool {
#[inline(always)]
fn from(variant: Res1Of) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `RES1_OF` reader - RES1 IEEE Overflow Flag"]
pub type Res1OfR = crate::BitReader<Res1Of>;
impl Res1OfR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Res1Of {
match self.bits {
false => Res1Of::Res1OfNo,
true => Res1Of::Res1OfYes,
}
}
#[doc = "The result format's largest finite number is not exceeded."]
#[inline(always)]
pub fn is_res1_of_no(&self) -> bool {
*self == Res1Of::Res1OfNo
}
#[doc = "The result format's largest finite number is exceeded."]
#[inline(always)]
pub fn is_res1_of_yes(&self) -> bool {
*self == Res1Of::Res1OfYes
}
}
#[doc = "Field `RES1_OF` writer - RES1 IEEE Overflow Flag"]
pub type Res1OfW<'a, REG> = crate::BitWriter<'a, REG, Res1Of>;
impl<'a, REG> Res1OfW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "The result format's largest finite number is not exceeded."]
#[inline(always)]
pub fn res1_of_no(self) -> &'a mut crate::W<REG> {
self.variant(Res1Of::Res1OfNo)
}
#[doc = "The result format's largest finite number is exceeded."]
#[inline(always)]
pub fn res1_of_yes(self) -> &'a mut crate::W<REG> {
self.variant(Res1Of::Res1OfYes)
}
}
#[doc = "RES1 IEEE Divide by Zero Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Res1Dz {
#[doc = "0: No exact infinite result is defined for an operation on finite operands."]
Res1DzNo = 0,
#[doc = "1: An exact infinite result is defined for an operation on finite operands."]
Res1DzYes = 1,
}
impl From<Res1Dz> for bool {
#[inline(always)]
fn from(variant: Res1Dz) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `RES1_DZ` reader - RES1 IEEE Divide by Zero Flag"]
pub type Res1DzR = crate::BitReader<Res1Dz>;
impl Res1DzR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Res1Dz {
match self.bits {
false => Res1Dz::Res1DzNo,
true => Res1Dz::Res1DzYes,
}
}
#[doc = "No exact infinite result is defined for an operation on finite operands."]
#[inline(always)]
pub fn is_res1_dz_no(&self) -> bool {
*self == Res1Dz::Res1DzNo
}
#[doc = "An exact infinite result is defined for an operation on finite operands."]
#[inline(always)]
pub fn is_res1_dz_yes(&self) -> bool {
*self == Res1Dz::Res1DzYes
}
}
#[doc = "Field `RES1_DZ` writer - RES1 IEEE Divide by Zero Flag"]
pub type Res1DzW<'a, REG> = crate::BitWriter<'a, REG, Res1Dz>;
impl<'a, REG> Res1DzW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "No exact infinite result is defined for an operation on finite operands."]
#[inline(always)]
pub fn res1_dz_no(self) -> &'a mut crate::W<REG> {
self.variant(Res1Dz::Res1DzNo)
}
#[doc = "An exact infinite result is defined for an operation on finite operands."]
#[inline(always)]
pub fn res1_dz_yes(self) -> &'a mut crate::W<REG> {
self.variant(Res1Dz::Res1DzYes)
}
}
#[doc = "RES1 IEEE Invalid Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Res1Nv {
#[doc = "0: There is usefully definable result."]
Res1NvNo = 0,
#[doc = "1: There is no usefully definable result."]
Res1NvYes = 1,
}
impl From<Res1Nv> for bool {
#[inline(always)]
fn from(variant: Res1Nv) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `RES1_NV` reader - RES1 IEEE Invalid Flag"]
pub type Res1NvR = crate::BitReader<Res1Nv>;
impl Res1NvR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Res1Nv {
match self.bits {
false => Res1Nv::Res1NvNo,
true => Res1Nv::Res1NvYes,
}
}
#[doc = "There is usefully definable result."]
#[inline(always)]
pub fn is_res1_nv_no(&self) -> bool {
*self == Res1Nv::Res1NvNo
}
#[doc = "There is no usefully definable result."]
#[inline(always)]
pub fn is_res1_nv_yes(&self) -> bool {
*self == Res1Nv::Res1NvYes
}
}
#[doc = "Field `RES1_NV` writer - RES1 IEEE Invalid Flag"]
pub type Res1NvW<'a, REG> = crate::BitWriter<'a, REG, Res1Nv>;
impl<'a, REG> Res1NvW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "There is usefully definable result."]
#[inline(always)]
pub fn res1_nv_no(self) -> &'a mut crate::W<REG> {
self.variant(Res1Nv::Res1NvNo)
}
#[doc = "There is no usefully definable result."]
#[inline(always)]
pub fn res1_nv_yes(self) -> &'a mut crate::W<REG> {
self.variant(Res1Nv::Res1NvYes)
}
}
#[doc = "RES1 Indirect Operation Error Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Res1Err {
#[doc = "0: No invalid indirect operation is detected."]
Res1ErrNo = 0,
#[doc = "1: An invalid indirect operation error is detected."]
Res1ErrYes = 1,
}
impl From<Res1Err> for bool {
#[inline(always)]
fn from(variant: Res1Err) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `RES1_ERR` reader - RES1 Indirect Operation Error Flag"]
pub type Res1ErrR = crate::BitReader<Res1Err>;
impl Res1ErrR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Res1Err {
match self.bits {
false => Res1Err::Res1ErrNo,
true => Res1Err::Res1ErrYes,
}
}
#[doc = "No invalid indirect operation is detected."]
#[inline(always)]
pub fn is_res1_err_no(&self) -> bool {
*self == Res1Err::Res1ErrNo
}
#[doc = "An invalid indirect operation error is detected."]
#[inline(always)]
pub fn is_res1_err_yes(&self) -> bool {
*self == Res1Err::Res1ErrYes
}
}
#[doc = "Field `RES1_ERR` writer - RES1 Indirect Operation Error Flag"]
pub type Res1ErrW<'a, REG> = crate::BitWriter<'a, REG, Res1Err>;
impl<'a, REG> Res1ErrW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "No invalid indirect operation is detected."]
#[inline(always)]
pub fn res1_err_no(self) -> &'a mut crate::W<REG> {
self.variant(Res1Err::Res1ErrNo)
}
#[doc = "An invalid indirect operation error is detected."]
#[inline(always)]
pub fn res1_err_yes(self) -> &'a mut crate::W<REG> {
self.variant(Res1Err::Res1ErrYes)
}
}
#[doc = "RES1 Overwrite Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Res1Ovwr {
#[doc = "0: The value of RES1 has been read."]
Res1OvwrNo = 0,
#[doc = "1: The value of RES1 has not been read yet and is overwritten by a new MAUWRAP result."]
Res1OvwrYes = 1,
}
impl From<Res1Ovwr> for bool {
#[inline(always)]
fn from(variant: Res1Ovwr) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `RES1_OVWR` reader - RES1 Overwrite Flag"]
pub type Res1OvwrR = crate::BitReader<Res1Ovwr>;
impl Res1OvwrR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Res1Ovwr {
match self.bits {
false => Res1Ovwr::Res1OvwrNo,
true => Res1Ovwr::Res1OvwrYes,
}
}
#[doc = "The value of RES1 has been read."]
#[inline(always)]
pub fn is_res1_ovwr_no(&self) -> bool {
*self == Res1Ovwr::Res1OvwrNo
}
#[doc = "The value of RES1 has not been read yet and is overwritten by a new MAUWRAP result."]
#[inline(always)]
pub fn is_res1_ovwr_yes(&self) -> bool {
*self == Res1Ovwr::Res1OvwrYes
}
}
#[doc = "Field `RES1_OVWR` writer - RES1 Overwrite Flag"]
pub type Res1OvwrW<'a, REG> = crate::BitWriter<'a, REG, Res1Ovwr>;
impl<'a, REG> Res1OvwrW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "The value of RES1 has been read."]
#[inline(always)]
pub fn res1_ovwr_no(self) -> &'a mut crate::W<REG> {
self.variant(Res1Ovwr::Res1OvwrNo)
}
#[doc = "The value of RES1 has not been read yet and is overwritten by a new MAUWRAP result."]
#[inline(always)]
pub fn res1_ovwr_yes(self) -> &'a mut crate::W<REG> {
self.variant(Res1Ovwr::Res1OvwrYes)
}
}
#[doc = "RES1 Full Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Res1Full {
#[doc = "0: RES1 has not updated and cannot be read."]
Res1FullNo = 0,
#[doc = "1: RES1 has updated and can be read."]
Res1FullYes = 1,
}
impl From<Res1Full> for bool {
#[inline(always)]
fn from(variant: Res1Full) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `RES1_FULL` reader - RES1 Full Flag"]
pub type Res1FullR = crate::BitReader<Res1Full>;
impl Res1FullR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Res1Full {
match self.bits {
false => Res1Full::Res1FullNo,
true => Res1Full::Res1FullYes,
}
}
#[doc = "RES1 has not updated and cannot be read."]
#[inline(always)]
pub fn is_res1_full_no(&self) -> bool {
*self == Res1Full::Res1FullNo
}
#[doc = "RES1 has updated and can be read."]
#[inline(always)]
pub fn is_res1_full_yes(&self) -> bool {
*self == Res1Full::Res1FullYes
}
}
#[doc = "Field `RES1_FULL` writer - RES1 Full Flag"]
pub type Res1FullW<'a, REG> = crate::BitWriter<'a, REG, Res1Full>;
impl<'a, REG> Res1FullW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "RES1 has not updated and cannot be read."]
#[inline(always)]
pub fn res1_full_no(self) -> &'a mut crate::W<REG> {
self.variant(Res1Full::Res1FullNo)
}
#[doc = "RES1 has updated and can be read."]
#[inline(always)]
pub fn res1_full_yes(self) -> &'a mut crate::W<REG> {
self.variant(Res1Full::Res1FullYes)
}
}
#[doc = "RES2 IEEE Inexact Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Res2Nx {
#[doc = "0: The result is not rounded."]
Res2NxNo = 0,
#[doc = "1: The result is rounded, and as a result some digits lost."]
Res2NxYes = 1,
}
impl From<Res2Nx> for bool {
#[inline(always)]
fn from(variant: Res2Nx) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `RES2_NX` reader - RES2 IEEE Inexact Flag"]
pub type Res2NxR = crate::BitReader<Res2Nx>;
impl Res2NxR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Res2Nx {
match self.bits {
false => Res2Nx::Res2NxNo,
true => Res2Nx::Res2NxYes,
}
}
#[doc = "The result is not rounded."]
#[inline(always)]
pub fn is_res2_nx_no(&self) -> bool {
*self == Res2Nx::Res2NxNo
}
#[doc = "The result is rounded, and as a result some digits lost."]
#[inline(always)]
pub fn is_res2_nx_yes(&self) -> bool {
*self == Res2Nx::Res2NxYes
}
}
#[doc = "Field `RES2_NX` writer - RES2 IEEE Inexact Flag"]
pub type Res2NxW<'a, REG> = crate::BitWriter<'a, REG, Res2Nx>;
impl<'a, REG> Res2NxW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "The result is not rounded."]
#[inline(always)]
pub fn res2_nx_no(self) -> &'a mut crate::W<REG> {
self.variant(Res2Nx::Res2NxNo)
}
#[doc = "The result is rounded, and as a result some digits lost."]
#[inline(always)]
pub fn res2_nx_yes(self) -> &'a mut crate::W<REG> {
self.variant(Res2Nx::Res2NxYes)
}
}
#[doc = "RES2 IEEE Underflow Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Res2Uf {
#[doc = "0: No tiny non-zero result is detected."]
Res2UfNo = 0,
#[doc = "1: A tiny non-zero result is detected."]
Res2UfYes = 1,
}
impl From<Res2Uf> for bool {
#[inline(always)]
fn from(variant: Res2Uf) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `RES2_UF` reader - RES2 IEEE Underflow Flag"]
pub type Res2UfR = crate::BitReader<Res2Uf>;
impl Res2UfR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Res2Uf {
match self.bits {
false => Res2Uf::Res2UfNo,
true => Res2Uf::Res2UfYes,
}
}
#[doc = "No tiny non-zero result is detected."]
#[inline(always)]
pub fn is_res2_uf_no(&self) -> bool {
*self == Res2Uf::Res2UfNo
}
#[doc = "A tiny non-zero result is detected."]
#[inline(always)]
pub fn is_res2_uf_yes(&self) -> bool {
*self == Res2Uf::Res2UfYes
}
}
#[doc = "Field `RES2_UF` writer - RES2 IEEE Underflow Flag"]
pub type Res2UfW<'a, REG> = crate::BitWriter<'a, REG, Res2Uf>;
impl<'a, REG> Res2UfW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "No tiny non-zero result is detected."]
#[inline(always)]
pub fn res2_uf_no(self) -> &'a mut crate::W<REG> {
self.variant(Res2Uf::Res2UfNo)
}
#[doc = "A tiny non-zero result is detected."]
#[inline(always)]
pub fn res2_uf_yes(self) -> &'a mut crate::W<REG> {
self.variant(Res2Uf::Res2UfYes)
}
}
#[doc = "RES2 IEEE Overflow Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Res2Of {
#[doc = "0: The result format's largest finite number is not exceeded."]
Res2OfNo = 0,
#[doc = "1: The result format's largest finite number is exceeded."]
Res2OfYes = 1,
}
impl From<Res2Of> for bool {
#[inline(always)]
fn from(variant: Res2Of) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `RES2_OF` reader - RES2 IEEE Overflow Flag"]
pub type Res2OfR = crate::BitReader<Res2Of>;
impl Res2OfR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Res2Of {
match self.bits {
false => Res2Of::Res2OfNo,
true => Res2Of::Res2OfYes,
}
}
#[doc = "The result format's largest finite number is not exceeded."]
#[inline(always)]
pub fn is_res2_of_no(&self) -> bool {
*self == Res2Of::Res2OfNo
}
#[doc = "The result format's largest finite number is exceeded."]
#[inline(always)]
pub fn is_res2_of_yes(&self) -> bool {
*self == Res2Of::Res2OfYes
}
}
#[doc = "Field `RES2_OF` writer - RES2 IEEE Overflow Flag"]
pub type Res2OfW<'a, REG> = crate::BitWriter<'a, REG, Res2Of>;
impl<'a, REG> Res2OfW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "The result format's largest finite number is not exceeded."]
#[inline(always)]
pub fn res2_of_no(self) -> &'a mut crate::W<REG> {
self.variant(Res2Of::Res2OfNo)
}
#[doc = "The result format's largest finite number is exceeded."]
#[inline(always)]
pub fn res2_of_yes(self) -> &'a mut crate::W<REG> {
self.variant(Res2Of::Res2OfYes)
}
}
#[doc = "RES2 IEEE Divide by Zero Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Res2Dz {
#[doc = "0: No exact infinite result is defined for an operation on finite operands."]
Res2DzNo = 0,
#[doc = "1: An exact infinite result is defined for an operation on finite operands."]
Res2DzYes = 1,
}
impl From<Res2Dz> for bool {
#[inline(always)]
fn from(variant: Res2Dz) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `RES2_DZ` reader - RES2 IEEE Divide by Zero Flag"]
pub type Res2DzR = crate::BitReader<Res2Dz>;
impl Res2DzR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Res2Dz {
match self.bits {
false => Res2Dz::Res2DzNo,
true => Res2Dz::Res2DzYes,
}
}
#[doc = "No exact infinite result is defined for an operation on finite operands."]
#[inline(always)]
pub fn is_res2_dz_no(&self) -> bool {
*self == Res2Dz::Res2DzNo
}
#[doc = "An exact infinite result is defined for an operation on finite operands."]
#[inline(always)]
pub fn is_res2_dz_yes(&self) -> bool {
*self == Res2Dz::Res2DzYes
}
}
#[doc = "Field `RES2_DZ` writer - RES2 IEEE Divide by Zero Flag"]
pub type Res2DzW<'a, REG> = crate::BitWriter<'a, REG, Res2Dz>;
impl<'a, REG> Res2DzW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "No exact infinite result is defined for an operation on finite operands."]
#[inline(always)]
pub fn res2_dz_no(self) -> &'a mut crate::W<REG> {
self.variant(Res2Dz::Res2DzNo)
}
#[doc = "An exact infinite result is defined for an operation on finite operands."]
#[inline(always)]
pub fn res2_dz_yes(self) -> &'a mut crate::W<REG> {
self.variant(Res2Dz::Res2DzYes)
}
}
#[doc = "RES2 IEEE Invalid Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Res2Nv {
#[doc = "0: There is usefully definable result."]
Res2NvNo = 0,
#[doc = "1: There is no usefully definable result."]
Res2NvYes = 1,
}
impl From<Res2Nv> for bool {
#[inline(always)]
fn from(variant: Res2Nv) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `RES2_NV` reader - RES2 IEEE Invalid Flag"]
pub type Res2NvR = crate::BitReader<Res2Nv>;
impl Res2NvR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Res2Nv {
match self.bits {
false => Res2Nv::Res2NvNo,
true => Res2Nv::Res2NvYes,
}
}
#[doc = "There is usefully definable result."]
#[inline(always)]
pub fn is_res2_nv_no(&self) -> bool {
*self == Res2Nv::Res2NvNo
}
#[doc = "There is no usefully definable result."]
#[inline(always)]
pub fn is_res2_nv_yes(&self) -> bool {
*self == Res2Nv::Res2NvYes
}
}
#[doc = "Field `RES2_NV` writer - RES2 IEEE Invalid Flag"]
pub type Res2NvW<'a, REG> = crate::BitWriter<'a, REG, Res2Nv>;
impl<'a, REG> Res2NvW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "There is usefully definable result."]
#[inline(always)]
pub fn res2_nv_no(self) -> &'a mut crate::W<REG> {
self.variant(Res2Nv::Res2NvNo)
}
#[doc = "There is no usefully definable result."]
#[inline(always)]
pub fn res2_nv_yes(self) -> &'a mut crate::W<REG> {
self.variant(Res2Nv::Res2NvYes)
}
}
#[doc = "RES2 Indirect Operation Error Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Res2Err {
#[doc = "0: No invalid indirect operation is detected."]
Res2ErrNo = 0,
#[doc = "1: An invalid indirect operation error is detected."]
Res2ErrYes = 1,
}
impl From<Res2Err> for bool {
#[inline(always)]
fn from(variant: Res2Err) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `RES2_ERR` reader - RES2 Indirect Operation Error Flag"]
pub type Res2ErrR = crate::BitReader<Res2Err>;
impl Res2ErrR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Res2Err {
match self.bits {
false => Res2Err::Res2ErrNo,
true => Res2Err::Res2ErrYes,
}
}
#[doc = "No invalid indirect operation is detected."]
#[inline(always)]
pub fn is_res2_err_no(&self) -> bool {
*self == Res2Err::Res2ErrNo
}
#[doc = "An invalid indirect operation error is detected."]
#[inline(always)]
pub fn is_res2_err_yes(&self) -> bool {
*self == Res2Err::Res2ErrYes
}
}
#[doc = "Field `RES2_ERR` writer - RES2 Indirect Operation Error Flag"]
pub type Res2ErrW<'a, REG> = crate::BitWriter<'a, REG, Res2Err>;
impl<'a, REG> Res2ErrW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "No invalid indirect operation is detected."]
#[inline(always)]
pub fn res2_err_no(self) -> &'a mut crate::W<REG> {
self.variant(Res2Err::Res2ErrNo)
}
#[doc = "An invalid indirect operation error is detected."]
#[inline(always)]
pub fn res2_err_yes(self) -> &'a mut crate::W<REG> {
self.variant(Res2Err::Res2ErrYes)
}
}
#[doc = "RES2 Overwrite Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Res2Ovwr {
#[doc = "0: The value of RES2 has been read."]
Res2OvwrNo = 0,
#[doc = "1: The value of RES2 has not been read yet and is overwritten by a new MAUWRAP result."]
Res2OvwrYes = 1,
}
impl From<Res2Ovwr> for bool {
#[inline(always)]
fn from(variant: Res2Ovwr) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `RES2_OVWR` reader - RES2 Overwrite Flag"]
pub type Res2OvwrR = crate::BitReader<Res2Ovwr>;
impl Res2OvwrR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Res2Ovwr {
match self.bits {
false => Res2Ovwr::Res2OvwrNo,
true => Res2Ovwr::Res2OvwrYes,
}
}
#[doc = "The value of RES2 has been read."]
#[inline(always)]
pub fn is_res2_ovwr_no(&self) -> bool {
*self == Res2Ovwr::Res2OvwrNo
}
#[doc = "The value of RES2 has not been read yet and is overwritten by a new MAUWRAP result."]
#[inline(always)]
pub fn is_res2_ovwr_yes(&self) -> bool {
*self == Res2Ovwr::Res2OvwrYes
}
}
#[doc = "Field `RES2_OVWR` writer - RES2 Overwrite Flag"]
pub type Res2OvwrW<'a, REG> = crate::BitWriter<'a, REG, Res2Ovwr>;
impl<'a, REG> Res2OvwrW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "The value of RES2 has been read."]
#[inline(always)]
pub fn res2_ovwr_no(self) -> &'a mut crate::W<REG> {
self.variant(Res2Ovwr::Res2OvwrNo)
}
#[doc = "The value of RES2 has not been read yet and is overwritten by a new MAUWRAP result."]
#[inline(always)]
pub fn res2_ovwr_yes(self) -> &'a mut crate::W<REG> {
self.variant(Res2Ovwr::Res2OvwrYes)
}
}
#[doc = "RES2 Full Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Res2Full {
#[doc = "0: RES2 has not updated and cannot be read."]
Res2FullNo = 0,
#[doc = "1: RES2 has updated and can be read."]
Res2FullYes = 1,
}
impl From<Res2Full> for bool {
#[inline(always)]
fn from(variant: Res2Full) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `RES2_FULL` reader - RES2 Full Flag"]
pub type Res2FullR = crate::BitReader<Res2Full>;
impl Res2FullR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Res2Full {
match self.bits {
false => Res2Full::Res2FullNo,
true => Res2Full::Res2FullYes,
}
}
#[doc = "RES2 has not updated and cannot be read."]
#[inline(always)]
pub fn is_res2_full_no(&self) -> bool {
*self == Res2Full::Res2FullNo
}
#[doc = "RES2 has updated and can be read."]
#[inline(always)]
pub fn is_res2_full_yes(&self) -> bool {
*self == Res2Full::Res2FullYes
}
}
#[doc = "Field `RES2_FULL` writer - RES2 Full Flag"]
pub type Res2FullW<'a, REG> = crate::BitWriter<'a, REG, Res2Full>;
impl<'a, REG> Res2FullW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "RES2 has not updated and cannot be read."]
#[inline(always)]
pub fn res2_full_no(self) -> &'a mut crate::W<REG> {
self.variant(Res2Full::Res2FullNo)
}
#[doc = "RES2 has updated and can be read."]
#[inline(always)]
pub fn res2_full_yes(self) -> &'a mut crate::W<REG> {
self.variant(Res2Full::Res2FullYes)
}
}
#[doc = "RES3 IEEE Inexact Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Res3Nx {
#[doc = "0: The result is not rounded."]
Res3NxNo = 0,
#[doc = "1: The result is rounded, and as a result some digits lost."]
Res3NxYes = 1,
}
impl From<Res3Nx> for bool {
#[inline(always)]
fn from(variant: Res3Nx) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `RES3_NX` reader - RES3 IEEE Inexact Flag"]
pub type Res3NxR = crate::BitReader<Res3Nx>;
impl Res3NxR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Res3Nx {
match self.bits {
false => Res3Nx::Res3NxNo,
true => Res3Nx::Res3NxYes,
}
}
#[doc = "The result is not rounded."]
#[inline(always)]
pub fn is_res3_nx_no(&self) -> bool {
*self == Res3Nx::Res3NxNo
}
#[doc = "The result is rounded, and as a result some digits lost."]
#[inline(always)]
pub fn is_res3_nx_yes(&self) -> bool {
*self == Res3Nx::Res3NxYes
}
}
#[doc = "Field `RES3_NX` writer - RES3 IEEE Inexact Flag"]
pub type Res3NxW<'a, REG> = crate::BitWriter<'a, REG, Res3Nx>;
impl<'a, REG> Res3NxW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "The result is not rounded."]
#[inline(always)]
pub fn res3_nx_no(self) -> &'a mut crate::W<REG> {
self.variant(Res3Nx::Res3NxNo)
}
#[doc = "The result is rounded, and as a result some digits lost."]
#[inline(always)]
pub fn res3_nx_yes(self) -> &'a mut crate::W<REG> {
self.variant(Res3Nx::Res3NxYes)
}
}
#[doc = "RES3 IEEE Underflow Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Res3Uf {
#[doc = "0: No tiny non-zero result is detected."]
Res3UfNo = 0,
#[doc = "1: A tiny non-zero result is detected."]
Res3UfYes = 1,
}
impl From<Res3Uf> for bool {
#[inline(always)]
fn from(variant: Res3Uf) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `RES3_UF` reader - RES3 IEEE Underflow Flag"]
pub type Res3UfR = crate::BitReader<Res3Uf>;
impl Res3UfR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Res3Uf {
match self.bits {
false => Res3Uf::Res3UfNo,
true => Res3Uf::Res3UfYes,
}
}
#[doc = "No tiny non-zero result is detected."]
#[inline(always)]
pub fn is_res3_uf_no(&self) -> bool {
*self == Res3Uf::Res3UfNo
}
#[doc = "A tiny non-zero result is detected."]
#[inline(always)]
pub fn is_res3_uf_yes(&self) -> bool {
*self == Res3Uf::Res3UfYes
}
}
#[doc = "Field `RES3_UF` writer - RES3 IEEE Underflow Flag"]
pub type Res3UfW<'a, REG> = crate::BitWriter<'a, REG, Res3Uf>;
impl<'a, REG> Res3UfW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "No tiny non-zero result is detected."]
#[inline(always)]
pub fn res3_uf_no(self) -> &'a mut crate::W<REG> {
self.variant(Res3Uf::Res3UfNo)
}
#[doc = "A tiny non-zero result is detected."]
#[inline(always)]
pub fn res3_uf_yes(self) -> &'a mut crate::W<REG> {
self.variant(Res3Uf::Res3UfYes)
}
}
#[doc = "RES3 IEEE Overflow Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Res3Of {
#[doc = "0: The result format's largest finite number is not exceeded."]
Res3OfNo = 0,
#[doc = "1: The result format's largest finite number is exceeded."]
Res3OfYes = 1,
}
impl From<Res3Of> for bool {
#[inline(always)]
fn from(variant: Res3Of) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `RES3_OF` reader - RES3 IEEE Overflow Flag"]
pub type Res3OfR = crate::BitReader<Res3Of>;
impl Res3OfR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Res3Of {
match self.bits {
false => Res3Of::Res3OfNo,
true => Res3Of::Res3OfYes,
}
}
#[doc = "The result format's largest finite number is not exceeded."]
#[inline(always)]
pub fn is_res3_of_no(&self) -> bool {
*self == Res3Of::Res3OfNo
}
#[doc = "The result format's largest finite number is exceeded."]
#[inline(always)]
pub fn is_res3_of_yes(&self) -> bool {
*self == Res3Of::Res3OfYes
}
}
#[doc = "Field `RES3_OF` writer - RES3 IEEE Overflow Flag"]
pub type Res3OfW<'a, REG> = crate::BitWriter<'a, REG, Res3Of>;
impl<'a, REG> Res3OfW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "The result format's largest finite number is not exceeded."]
#[inline(always)]
pub fn res3_of_no(self) -> &'a mut crate::W<REG> {
self.variant(Res3Of::Res3OfNo)
}
#[doc = "The result format's largest finite number is exceeded."]
#[inline(always)]
pub fn res3_of_yes(self) -> &'a mut crate::W<REG> {
self.variant(Res3Of::Res3OfYes)
}
}
#[doc = "RES3 IEEE Divide by Zero Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Res3Dz {
#[doc = "0: No exact infinite result is defined for an operation on finite operands."]
Res3DzNo = 0,
#[doc = "1: An exact infinite result is defined for an operation on finite operands."]
Res3DzYes = 1,
}
impl From<Res3Dz> for bool {
#[inline(always)]
fn from(variant: Res3Dz) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `RES3_DZ` reader - RES3 IEEE Divide by Zero Flag"]
pub type Res3DzR = crate::BitReader<Res3Dz>;
impl Res3DzR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Res3Dz {
match self.bits {
false => Res3Dz::Res3DzNo,
true => Res3Dz::Res3DzYes,
}
}
#[doc = "No exact infinite result is defined for an operation on finite operands."]
#[inline(always)]
pub fn is_res3_dz_no(&self) -> bool {
*self == Res3Dz::Res3DzNo
}
#[doc = "An exact infinite result is defined for an operation on finite operands."]
#[inline(always)]
pub fn is_res3_dz_yes(&self) -> bool {
*self == Res3Dz::Res3DzYes
}
}
#[doc = "Field `RES3_DZ` writer - RES3 IEEE Divide by Zero Flag"]
pub type Res3DzW<'a, REG> = crate::BitWriter<'a, REG, Res3Dz>;
impl<'a, REG> Res3DzW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "No exact infinite result is defined for an operation on finite operands."]
#[inline(always)]
pub fn res3_dz_no(self) -> &'a mut crate::W<REG> {
self.variant(Res3Dz::Res3DzNo)
}
#[doc = "An exact infinite result is defined for an operation on finite operands."]
#[inline(always)]
pub fn res3_dz_yes(self) -> &'a mut crate::W<REG> {
self.variant(Res3Dz::Res3DzYes)
}
}
#[doc = "RES3 IEEE Invalid Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Res3Nv {
#[doc = "0: There is usefully definable result."]
Res3NvNo = 0,
#[doc = "1: There is no usefully definable result."]
Res3NvYes = 1,
}
impl From<Res3Nv> for bool {
#[inline(always)]
fn from(variant: Res3Nv) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `RES3_NV` reader - RES3 IEEE Invalid Flag"]
pub type Res3NvR = crate::BitReader<Res3Nv>;
impl Res3NvR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Res3Nv {
match self.bits {
false => Res3Nv::Res3NvNo,
true => Res3Nv::Res3NvYes,
}
}
#[doc = "There is usefully definable result."]
#[inline(always)]
pub fn is_res3_nv_no(&self) -> bool {
*self == Res3Nv::Res3NvNo
}
#[doc = "There is no usefully definable result."]
#[inline(always)]
pub fn is_res3_nv_yes(&self) -> bool {
*self == Res3Nv::Res3NvYes
}
}
#[doc = "Field `RES3_NV` writer - RES3 IEEE Invalid Flag"]
pub type Res3NvW<'a, REG> = crate::BitWriter<'a, REG, Res3Nv>;
impl<'a, REG> Res3NvW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "There is usefully definable result."]
#[inline(always)]
pub fn res3_nv_no(self) -> &'a mut crate::W<REG> {
self.variant(Res3Nv::Res3NvNo)
}
#[doc = "There is no usefully definable result."]
#[inline(always)]
pub fn res3_nv_yes(self) -> &'a mut crate::W<REG> {
self.variant(Res3Nv::Res3NvYes)
}
}
#[doc = "RES3 Indirect Operation Error Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Res3Err {
#[doc = "0: No invalid indirect operation is detected."]
Res3ErrNo = 0,
#[doc = "1: An invalid indirect operation error is detected."]
Res3ErrYes = 1,
}
impl From<Res3Err> for bool {
#[inline(always)]
fn from(variant: Res3Err) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `RES3_ERR` reader - RES3 Indirect Operation Error Flag"]
pub type Res3ErrR = crate::BitReader<Res3Err>;
impl Res3ErrR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Res3Err {
match self.bits {
false => Res3Err::Res3ErrNo,
true => Res3Err::Res3ErrYes,
}
}
#[doc = "No invalid indirect operation is detected."]
#[inline(always)]
pub fn is_res3_err_no(&self) -> bool {
*self == Res3Err::Res3ErrNo
}
#[doc = "An invalid indirect operation error is detected."]
#[inline(always)]
pub fn is_res3_err_yes(&self) -> bool {
*self == Res3Err::Res3ErrYes
}
}
#[doc = "Field `RES3_ERR` writer - RES3 Indirect Operation Error Flag"]
pub type Res3ErrW<'a, REG> = crate::BitWriter<'a, REG, Res3Err>;
impl<'a, REG> Res3ErrW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "No invalid indirect operation is detected."]
#[inline(always)]
pub fn res3_err_no(self) -> &'a mut crate::W<REG> {
self.variant(Res3Err::Res3ErrNo)
}
#[doc = "An invalid indirect operation error is detected."]
#[inline(always)]
pub fn res3_err_yes(self) -> &'a mut crate::W<REG> {
self.variant(Res3Err::Res3ErrYes)
}
}
#[doc = "RES3 Overwrite Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Res3Ovwr {
#[doc = "0: The value of RES3 has been read."]
Res3OvwrNo = 0,
#[doc = "1: The value of RES3 has not been read yet and is overwritten by a new MAUWRAP result."]
Res3OvwrYes = 1,
}
impl From<Res3Ovwr> for bool {
#[inline(always)]
fn from(variant: Res3Ovwr) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `RES3_OVWR` reader - RES3 Overwrite Flag"]
pub type Res3OvwrR = crate::BitReader<Res3Ovwr>;
impl Res3OvwrR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Res3Ovwr {
match self.bits {
false => Res3Ovwr::Res3OvwrNo,
true => Res3Ovwr::Res3OvwrYes,
}
}
#[doc = "The value of RES3 has been read."]
#[inline(always)]
pub fn is_res3_ovwr_no(&self) -> bool {
*self == Res3Ovwr::Res3OvwrNo
}
#[doc = "The value of RES3 has not been read yet and is overwritten by a new MAUWRAP result."]
#[inline(always)]
pub fn is_res3_ovwr_yes(&self) -> bool {
*self == Res3Ovwr::Res3OvwrYes
}
}
#[doc = "Field `RES3_OVWR` writer - RES3 Overwrite Flag"]
pub type Res3OvwrW<'a, REG> = crate::BitWriter<'a, REG, Res3Ovwr>;
impl<'a, REG> Res3OvwrW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "The value of RES3 has been read."]
#[inline(always)]
pub fn res3_ovwr_no(self) -> &'a mut crate::W<REG> {
self.variant(Res3Ovwr::Res3OvwrNo)
}
#[doc = "The value of RES3 has not been read yet and is overwritten by a new MAUWRAP result."]
#[inline(always)]
pub fn res3_ovwr_yes(self) -> &'a mut crate::W<REG> {
self.variant(Res3Ovwr::Res3OvwrYes)
}
}
#[doc = "RES3 Full Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Res3Full {
#[doc = "0: RES3 has not updated and cannot be read."]
Res3FullNo = 0,
#[doc = "1: RES3 has updated and can be read."]
Res3FullYes = 1,
}
impl From<Res3Full> for bool {
#[inline(always)]
fn from(variant: Res3Full) -> Self {
variant as u8 != 0
}
}
#[doc = "Field `RES3_FULL` reader - RES3 Full Flag"]
pub type Res3FullR = crate::BitReader<Res3Full>;
impl Res3FullR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Res3Full {
match self.bits {
false => Res3Full::Res3FullNo,
true => Res3Full::Res3FullYes,
}
}
#[doc = "RES3 has not updated and cannot be read."]
#[inline(always)]
pub fn is_res3_full_no(&self) -> bool {
*self == Res3Full::Res3FullNo
}
#[doc = "RES3 has updated and can be read."]
#[inline(always)]
pub fn is_res3_full_yes(&self) -> bool {
*self == Res3Full::Res3FullYes
}
}
#[doc = "Field `RES3_FULL` writer - RES3 Full Flag"]
pub type Res3FullW<'a, REG> = crate::BitWriter<'a, REG, Res3Full>;
impl<'a, REG> Res3FullW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "RES3 has not updated and cannot be read."]
#[inline(always)]
pub fn res3_full_no(self) -> &'a mut crate::W<REG> {
self.variant(Res3Full::Res3FullNo)
}
#[doc = "RES3 has updated and can be read."]
#[inline(always)]
pub fn res3_full_yes(self) -> &'a mut crate::W<REG> {
self.variant(Res3Full::Res3FullYes)
}
}
impl R {
#[doc = "Bit 0 - RES0 IEEE Inexact Flag"]
#[inline(always)]
pub fn res0_nx(&self) -> Res0NxR {
Res0NxR::new((self.bits & 1) != 0)
}
#[doc = "Bit 1 - RES0 IEEE Underflow Flag"]
#[inline(always)]
pub fn res0_uf(&self) -> Res0UfR {
Res0UfR::new(((self.bits >> 1) & 1) != 0)
}
#[doc = "Bit 2 - RES0 IEEE Overflow Flag"]
#[inline(always)]
pub fn res0_of(&self) -> Res0OfR {
Res0OfR::new(((self.bits >> 2) & 1) != 0)
}
#[doc = "Bit 3 - RES0 IEEE Divide by Zero Flag"]
#[inline(always)]
pub fn res0_dz(&self) -> Res0DzR {
Res0DzR::new(((self.bits >> 3) & 1) != 0)
}
#[doc = "Bit 4 - RES0 IEEE Invalid Flag"]
#[inline(always)]
pub fn res0_nv(&self) -> Res0NvR {
Res0NvR::new(((self.bits >> 4) & 1) != 0)
}
#[doc = "Bit 5 - RES0 Indirect Operation Error Flag"]
#[inline(always)]
pub fn res0_err(&self) -> Res0ErrR {
Res0ErrR::new(((self.bits >> 5) & 1) != 0)
}
#[doc = "Bit 6 - RES0 Overwrite Flag"]
#[inline(always)]
pub fn res0_ovwr(&self) -> Res0OvwrR {
Res0OvwrR::new(((self.bits >> 6) & 1) != 0)
}
#[doc = "Bit 7 - RES0 Full Flag"]
#[inline(always)]
pub fn res0_full(&self) -> Res0FullR {
Res0FullR::new(((self.bits >> 7) & 1) != 0)
}
#[doc = "Bit 8 - RES1 IEEE Inexact Flag"]
#[inline(always)]
pub fn res1_nx(&self) -> Res1NxR {
Res1NxR::new(((self.bits >> 8) & 1) != 0)
}
#[doc = "Bit 9 - RES1 IEEE Underflow Flag"]
#[inline(always)]
pub fn res1_uf(&self) -> Res1UfR {
Res1UfR::new(((self.bits >> 9) & 1) != 0)
}
#[doc = "Bit 10 - RES1 IEEE Overflow Flag"]
#[inline(always)]
pub fn res1_of(&self) -> Res1OfR {
Res1OfR::new(((self.bits >> 10) & 1) != 0)
}
#[doc = "Bit 11 - RES1 IEEE Divide by Zero Flag"]
#[inline(always)]
pub fn res1_dz(&self) -> Res1DzR {
Res1DzR::new(((self.bits >> 11) & 1) != 0)
}
#[doc = "Bit 12 - RES1 IEEE Invalid Flag"]
#[inline(always)]
pub fn res1_nv(&self) -> Res1NvR {
Res1NvR::new(((self.bits >> 12) & 1) != 0)
}
#[doc = "Bit 13 - RES1 Indirect Operation Error Flag"]
#[inline(always)]
pub fn res1_err(&self) -> Res1ErrR {
Res1ErrR::new(((self.bits >> 13) & 1) != 0)
}
#[doc = "Bit 14 - RES1 Overwrite Flag"]
#[inline(always)]
pub fn res1_ovwr(&self) -> Res1OvwrR {
Res1OvwrR::new(((self.bits >> 14) & 1) != 0)
}
#[doc = "Bit 15 - RES1 Full Flag"]
#[inline(always)]
pub fn res1_full(&self) -> Res1FullR {
Res1FullR::new(((self.bits >> 15) & 1) != 0)
}
#[doc = "Bit 16 - RES2 IEEE Inexact Flag"]
#[inline(always)]
pub fn res2_nx(&self) -> Res2NxR {
Res2NxR::new(((self.bits >> 16) & 1) != 0)
}
#[doc = "Bit 17 - RES2 IEEE Underflow Flag"]
#[inline(always)]
pub fn res2_uf(&self) -> Res2UfR {
Res2UfR::new(((self.bits >> 17) & 1) != 0)
}
#[doc = "Bit 18 - RES2 IEEE Overflow Flag"]
#[inline(always)]
pub fn res2_of(&self) -> Res2OfR {
Res2OfR::new(((self.bits >> 18) & 1) != 0)
}
#[doc = "Bit 19 - RES2 IEEE Divide by Zero Flag"]
#[inline(always)]
pub fn res2_dz(&self) -> Res2DzR {
Res2DzR::new(((self.bits >> 19) & 1) != 0)
}
#[doc = "Bit 20 - RES2 IEEE Invalid Flag"]
#[inline(always)]
pub fn res2_nv(&self) -> Res2NvR {
Res2NvR::new(((self.bits >> 20) & 1) != 0)
}
#[doc = "Bit 21 - RES2 Indirect Operation Error Flag"]
#[inline(always)]
pub fn res2_err(&self) -> Res2ErrR {
Res2ErrR::new(((self.bits >> 21) & 1) != 0)
}
#[doc = "Bit 22 - RES2 Overwrite Flag"]
#[inline(always)]
pub fn res2_ovwr(&self) -> Res2OvwrR {
Res2OvwrR::new(((self.bits >> 22) & 1) != 0)
}
#[doc = "Bit 23 - RES2 Full Flag"]
#[inline(always)]
pub fn res2_full(&self) -> Res2FullR {
Res2FullR::new(((self.bits >> 23) & 1) != 0)
}
#[doc = "Bit 24 - RES3 IEEE Inexact Flag"]
#[inline(always)]
pub fn res3_nx(&self) -> Res3NxR {
Res3NxR::new(((self.bits >> 24) & 1) != 0)
}
#[doc = "Bit 25 - RES3 IEEE Underflow Flag"]
#[inline(always)]
pub fn res3_uf(&self) -> Res3UfR {
Res3UfR::new(((self.bits >> 25) & 1) != 0)
}
#[doc = "Bit 26 - RES3 IEEE Overflow Flag"]
#[inline(always)]
pub fn res3_of(&self) -> Res3OfR {
Res3OfR::new(((self.bits >> 26) & 1) != 0)
}
#[doc = "Bit 27 - RES3 IEEE Divide by Zero Flag"]
#[inline(always)]
pub fn res3_dz(&self) -> Res3DzR {
Res3DzR::new(((self.bits >> 27) & 1) != 0)
}
#[doc = "Bit 28 - RES3 IEEE Invalid Flag"]
#[inline(always)]
pub fn res3_nv(&self) -> Res3NvR {
Res3NvR::new(((self.bits >> 28) & 1) != 0)
}
#[doc = "Bit 29 - RES3 Indirect Operation Error Flag"]
#[inline(always)]
pub fn res3_err(&self) -> Res3ErrR {
Res3ErrR::new(((self.bits >> 29) & 1) != 0)
}
#[doc = "Bit 30 - RES3 Overwrite Flag"]
#[inline(always)]
pub fn res3_ovwr(&self) -> Res3OvwrR {
Res3OvwrR::new(((self.bits >> 30) & 1) != 0)
}
#[doc = "Bit 31 - RES3 Full Flag"]
#[inline(always)]
pub fn res3_full(&self) -> Res3FullR {
Res3FullR::new(((self.bits >> 31) & 1) != 0)
}
}
#[cfg(feature = "debug")]
impl core::fmt::Debug for R {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("RES_STATUS")
.field("res0_nx", &self.res0_nx())
.field("res0_uf", &self.res0_uf())
.field("res0_of", &self.res0_of())
.field("res0_dz", &self.res0_dz())
.field("res0_nv", &self.res0_nv())
.field("res0_err", &self.res0_err())
.field("res0_ovwr", &self.res0_ovwr())
.field("res0_full", &self.res0_full())
.field("res1_nx", &self.res1_nx())
.field("res1_uf", &self.res1_uf())
.field("res1_of", &self.res1_of())
.field("res1_dz", &self.res1_dz())
.field("res1_nv", &self.res1_nv())
.field("res1_err", &self.res1_err())
.field("res1_ovwr", &self.res1_ovwr())
.field("res1_full", &self.res1_full())
.field("res2_nx", &self.res2_nx())
.field("res2_uf", &self.res2_uf())
.field("res2_of", &self.res2_of())
.field("res2_dz", &self.res2_dz())
.field("res2_nv", &self.res2_nv())
.field("res2_err", &self.res2_err())
.field("res2_ovwr", &self.res2_ovwr())
.field("res2_full", &self.res2_full())
.field("res3_nx", &self.res3_nx())
.field("res3_uf", &self.res3_uf())
.field("res3_of", &self.res3_of())
.field("res3_dz", &self.res3_dz())
.field("res3_nv", &self.res3_nv())
.field("res3_err", &self.res3_err())
.field("res3_ovwr", &self.res3_ovwr())
.field("res3_full", &self.res3_full())
.finish()
}
}
impl W {
#[doc = "Bit 0 - RES0 IEEE Inexact Flag"]
#[inline(always)]
pub fn res0_nx(&mut self) -> Res0NxW<'_, ResStatusSpec> {
Res0NxW::new(self, 0)
}
#[doc = "Bit 1 - RES0 IEEE Underflow Flag"]
#[inline(always)]
pub fn res0_uf(&mut self) -> Res0UfW<'_, ResStatusSpec> {
Res0UfW::new(self, 1)
}
#[doc = "Bit 2 - RES0 IEEE Overflow Flag"]
#[inline(always)]
pub fn res0_of(&mut self) -> Res0OfW<'_, ResStatusSpec> {
Res0OfW::new(self, 2)
}
#[doc = "Bit 3 - RES0 IEEE Divide by Zero Flag"]
#[inline(always)]
pub fn res0_dz(&mut self) -> Res0DzW<'_, ResStatusSpec> {
Res0DzW::new(self, 3)
}
#[doc = "Bit 4 - RES0 IEEE Invalid Flag"]
#[inline(always)]
pub fn res0_nv(&mut self) -> Res0NvW<'_, ResStatusSpec> {
Res0NvW::new(self, 4)
}
#[doc = "Bit 5 - RES0 Indirect Operation Error Flag"]
#[inline(always)]
pub fn res0_err(&mut self) -> Res0ErrW<'_, ResStatusSpec> {
Res0ErrW::new(self, 5)
}
#[doc = "Bit 6 - RES0 Overwrite Flag"]
#[inline(always)]
pub fn res0_ovwr(&mut self) -> Res0OvwrW<'_, ResStatusSpec> {
Res0OvwrW::new(self, 6)
}
#[doc = "Bit 7 - RES0 Full Flag"]
#[inline(always)]
pub fn res0_full(&mut self) -> Res0FullW<'_, ResStatusSpec> {
Res0FullW::new(self, 7)
}
#[doc = "Bit 8 - RES1 IEEE Inexact Flag"]
#[inline(always)]
pub fn res1_nx(&mut self) -> Res1NxW<'_, ResStatusSpec> {
Res1NxW::new(self, 8)
}
#[doc = "Bit 9 - RES1 IEEE Underflow Flag"]
#[inline(always)]
pub fn res1_uf(&mut self) -> Res1UfW<'_, ResStatusSpec> {
Res1UfW::new(self, 9)
}
#[doc = "Bit 10 - RES1 IEEE Overflow Flag"]
#[inline(always)]
pub fn res1_of(&mut self) -> Res1OfW<'_, ResStatusSpec> {
Res1OfW::new(self, 10)
}
#[doc = "Bit 11 - RES1 IEEE Divide by Zero Flag"]
#[inline(always)]
pub fn res1_dz(&mut self) -> Res1DzW<'_, ResStatusSpec> {
Res1DzW::new(self, 11)
}
#[doc = "Bit 12 - RES1 IEEE Invalid Flag"]
#[inline(always)]
pub fn res1_nv(&mut self) -> Res1NvW<'_, ResStatusSpec> {
Res1NvW::new(self, 12)
}
#[doc = "Bit 13 - RES1 Indirect Operation Error Flag"]
#[inline(always)]
pub fn res1_err(&mut self) -> Res1ErrW<'_, ResStatusSpec> {
Res1ErrW::new(self, 13)
}
#[doc = "Bit 14 - RES1 Overwrite Flag"]
#[inline(always)]
pub fn res1_ovwr(&mut self) -> Res1OvwrW<'_, ResStatusSpec> {
Res1OvwrW::new(self, 14)
}
#[doc = "Bit 15 - RES1 Full Flag"]
#[inline(always)]
pub fn res1_full(&mut self) -> Res1FullW<'_, ResStatusSpec> {
Res1FullW::new(self, 15)
}
#[doc = "Bit 16 - RES2 IEEE Inexact Flag"]
#[inline(always)]
pub fn res2_nx(&mut self) -> Res2NxW<'_, ResStatusSpec> {
Res2NxW::new(self, 16)
}
#[doc = "Bit 17 - RES2 IEEE Underflow Flag"]
#[inline(always)]
pub fn res2_uf(&mut self) -> Res2UfW<'_, ResStatusSpec> {
Res2UfW::new(self, 17)
}
#[doc = "Bit 18 - RES2 IEEE Overflow Flag"]
#[inline(always)]
pub fn res2_of(&mut self) -> Res2OfW<'_, ResStatusSpec> {
Res2OfW::new(self, 18)
}
#[doc = "Bit 19 - RES2 IEEE Divide by Zero Flag"]
#[inline(always)]
pub fn res2_dz(&mut self) -> Res2DzW<'_, ResStatusSpec> {
Res2DzW::new(self, 19)
}
#[doc = "Bit 20 - RES2 IEEE Invalid Flag"]
#[inline(always)]
pub fn res2_nv(&mut self) -> Res2NvW<'_, ResStatusSpec> {
Res2NvW::new(self, 20)
}
#[doc = "Bit 21 - RES2 Indirect Operation Error Flag"]
#[inline(always)]
pub fn res2_err(&mut self) -> Res2ErrW<'_, ResStatusSpec> {
Res2ErrW::new(self, 21)
}
#[doc = "Bit 22 - RES2 Overwrite Flag"]
#[inline(always)]
pub fn res2_ovwr(&mut self) -> Res2OvwrW<'_, ResStatusSpec> {
Res2OvwrW::new(self, 22)
}
#[doc = "Bit 23 - RES2 Full Flag"]
#[inline(always)]
pub fn res2_full(&mut self) -> Res2FullW<'_, ResStatusSpec> {
Res2FullW::new(self, 23)
}
#[doc = "Bit 24 - RES3 IEEE Inexact Flag"]
#[inline(always)]
pub fn res3_nx(&mut self) -> Res3NxW<'_, ResStatusSpec> {
Res3NxW::new(self, 24)
}
#[doc = "Bit 25 - RES3 IEEE Underflow Flag"]
#[inline(always)]
pub fn res3_uf(&mut self) -> Res3UfW<'_, ResStatusSpec> {
Res3UfW::new(self, 25)
}
#[doc = "Bit 26 - RES3 IEEE Overflow Flag"]
#[inline(always)]
pub fn res3_of(&mut self) -> Res3OfW<'_, ResStatusSpec> {
Res3OfW::new(self, 26)
}
#[doc = "Bit 27 - RES3 IEEE Divide by Zero Flag"]
#[inline(always)]
pub fn res3_dz(&mut self) -> Res3DzW<'_, ResStatusSpec> {
Res3DzW::new(self, 27)
}
#[doc = "Bit 28 - RES3 IEEE Invalid Flag"]
#[inline(always)]
pub fn res3_nv(&mut self) -> Res3NvW<'_, ResStatusSpec> {
Res3NvW::new(self, 28)
}
#[doc = "Bit 29 - RES3 Indirect Operation Error Flag"]
#[inline(always)]
pub fn res3_err(&mut self) -> Res3ErrW<'_, ResStatusSpec> {
Res3ErrW::new(self, 29)
}
#[doc = "Bit 30 - RES3 Overwrite Flag"]
#[inline(always)]
pub fn res3_ovwr(&mut self) -> Res3OvwrW<'_, ResStatusSpec> {
Res3OvwrW::new(self, 30)
}
#[doc = "Bit 31 - RES3 Full Flag"]
#[inline(always)]
pub fn res3_full(&mut self) -> Res3FullW<'_, ResStatusSpec> {
Res3FullW::new(self, 31)
}
}
#[doc = "Result Status\n\nYou can [`read`](crate::Reg::read) this register and get [`res_status::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`res_status::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct ResStatusSpec;
impl crate::RegisterSpec for ResStatusSpec {
type Ux = u32;
}
#[doc = "`read()` method returns [`res_status::R`](R) reader structure"]
impl crate::Readable for ResStatusSpec {}
#[doc = "`write(|w| ..)` method takes [`res_status::W`](W) writer structure"]
impl crate::Writable for ResStatusSpec {
type Safety = crate::Unsafe;
}
#[doc = "`reset()` method sets RES_STATUS to value 0"]
impl crate::Resettable for ResStatusSpec {}