#[doc = "Reader of register SYST_CSR"]
pub type R = crate::R<u32, super::SYST_CSR>;
#[doc = "Writer for register SYST_CSR"]
pub type W = crate::W<u32, super::SYST_CSR>;
#[doc = "Register SYST_CSR `reset()`'s with value 0"]
impl crate::ResetValue for super::SYST_CSR {
type Type = u32;
#[inline(always)]
fn reset_value() -> Self::Type {
0
}
}
#[doc = "Counter Enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ENABLE_A {
#[doc = "0: Counter disabled."]
VALUE1,
#[doc = "1: Counter enabled."]
VALUE2,
}
impl From<ENABLE_A> for bool {
#[inline(always)]
fn from(variant: ENABLE_A) -> Self {
match variant {
ENABLE_A::VALUE1 => false,
ENABLE_A::VALUE2 => 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::VALUE1,
true => ENABLE_A::VALUE2,
}
}
#[doc = "Checks if the value of the field is `VALUE1`"]
#[inline(always)]
pub fn is_value1(&self) -> bool {
*self == ENABLE_A::VALUE1
}
#[doc = "Checks if the value of the field is `VALUE2`"]
#[inline(always)]
pub fn is_value2(&self) -> bool {
*self == ENABLE_A::VALUE2
}
}
#[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 = "Counter disabled."]
#[inline(always)]
pub fn value1(self) -> &'a mut W {
self.variant(ENABLE_A::VALUE1)
}
#[doc = "Counter enabled."]
#[inline(always)]
pub fn value2(self) -> &'a mut W {
self.variant(ENABLE_A::VALUE2)
}
#[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 = "SysTick Exception Request\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TICKINT_A {
#[doc = "0: Counting down to zero does not assert the SysTick exception request."]
VALUE1,
#[doc = "1: Counting down to zero to assert the SysTick exception request."]
VALUE2,
}
impl From<TICKINT_A> for bool {
#[inline(always)]
fn from(variant: TICKINT_A) -> Self {
match variant {
TICKINT_A::VALUE1 => false,
TICKINT_A::VALUE2 => true,
}
}
}
#[doc = "Reader of field `TICKINT`"]
pub type TICKINT_R = crate::R<bool, TICKINT_A>;
impl TICKINT_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> TICKINT_A {
match self.bits {
false => TICKINT_A::VALUE1,
true => TICKINT_A::VALUE2,
}
}
#[doc = "Checks if the value of the field is `VALUE1`"]
#[inline(always)]
pub fn is_value1(&self) -> bool {
*self == TICKINT_A::VALUE1
}
#[doc = "Checks if the value of the field is `VALUE2`"]
#[inline(always)]
pub fn is_value2(&self) -> bool {
*self == TICKINT_A::VALUE2
}
}
#[doc = "Write proxy for field `TICKINT`"]
pub struct TICKINT_W<'a> {
w: &'a mut W,
}
impl<'a> TICKINT_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: TICKINT_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Counting down to zero does not assert the SysTick exception request."]
#[inline(always)]
pub fn value1(self) -> &'a mut W {
self.variant(TICKINT_A::VALUE1)
}
#[doc = "Counting down to zero to assert the SysTick exception request."]
#[inline(always)]
pub fn value2(self) -> &'a mut W {
self.variant(TICKINT_A::VALUE2)
}
#[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 = "Clock Source\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CLKSOURCE_A {
#[doc = "0: External clock."]
VALUE1,
#[doc = "1: Processor clock."]
VALUE2,
}
impl From<CLKSOURCE_A> for bool {
#[inline(always)]
fn from(variant: CLKSOURCE_A) -> Self {
match variant {
CLKSOURCE_A::VALUE1 => false,
CLKSOURCE_A::VALUE2 => true,
}
}
}
#[doc = "Reader of field `CLKSOURCE`"]
pub type CLKSOURCE_R = crate::R<bool, CLKSOURCE_A>;
impl CLKSOURCE_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CLKSOURCE_A {
match self.bits {
false => CLKSOURCE_A::VALUE1,
true => CLKSOURCE_A::VALUE2,
}
}
#[doc = "Checks if the value of the field is `VALUE1`"]
#[inline(always)]
pub fn is_value1(&self) -> bool {
*self == CLKSOURCE_A::VALUE1
}
#[doc = "Checks if the value of the field is `VALUE2`"]
#[inline(always)]
pub fn is_value2(&self) -> bool {
*self == CLKSOURCE_A::VALUE2
}
}
#[doc = "Write proxy for field `CLKSOURCE`"]
pub struct CLKSOURCE_W<'a> {
w: &'a mut W,
}
impl<'a> CLKSOURCE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: CLKSOURCE_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "External clock."]
#[inline(always)]
pub fn value1(self) -> &'a mut W {
self.variant(CLKSOURCE_A::VALUE1)
}
#[doc = "Processor clock."]
#[inline(always)]
pub fn value2(self) -> &'a mut W {
self.variant(CLKSOURCE_A::VALUE2)
}
#[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 = "Reader of field `COUNTFLAG`"]
pub type COUNTFLAG_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `COUNTFLAG`"]
pub struct COUNTFLAG_W<'a> {
w: &'a mut W,
}
impl<'a> COUNTFLAG_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
}
}
impl R {
#[doc = "Bit 0 - Counter Enable"]
#[inline(always)]
pub fn enable(&self) -> ENABLE_R {
ENABLE_R::new((self.bits & 0x01) != 0)
}
#[doc = "Bit 1 - SysTick Exception Request"]
#[inline(always)]
pub fn tickint(&self) -> TICKINT_R {
TICKINT_R::new(((self.bits >> 1) & 0x01) != 0)
}
#[doc = "Bit 2 - Clock Source"]
#[inline(always)]
pub fn clksource(&self) -> CLKSOURCE_R {
CLKSOURCE_R::new(((self.bits >> 2) & 0x01) != 0)
}
#[doc = "Bit 16 - Counter Flag"]
#[inline(always)]
pub fn countflag(&self) -> COUNTFLAG_R {
COUNTFLAG_R::new(((self.bits >> 16) & 0x01) != 0)
}
}
impl W {
#[doc = "Bit 0 - Counter Enable"]
#[inline(always)]
pub fn enable(&mut self) -> ENABLE_W {
ENABLE_W { w: self }
}
#[doc = "Bit 1 - SysTick Exception Request"]
#[inline(always)]
pub fn tickint(&mut self) -> TICKINT_W {
TICKINT_W { w: self }
}
#[doc = "Bit 2 - Clock Source"]
#[inline(always)]
pub fn clksource(&mut self) -> CLKSOURCE_W {
CLKSOURCE_W { w: self }
}
#[doc = "Bit 16 - Counter Flag"]
#[inline(always)]
pub fn countflag(&mut self) -> COUNTFLAG_W {
COUNTFLAG_W { w: self }
}
}