Created
March 15, 2018 10:29
-
-
Save jamesmunns/6e40ef9b5bfe42d29c02e63d7e8684d9 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
# ! [ cfg_attr ( feature = "rt" , feature ( global_asm ) ) ] # ! [ cfg_attr ( feature = "rt" , feature ( macro_reexport ) ) ] # ! [ cfg_attr ( feature = "rt" , feature ( used ) ) ] # ! [ doc = "Peripheral access API for LPC43XX microcontrollers (generated using svd2rust v0.12.0)\n\nYou can find an overview of the API [here].\n\n[here]: https://docs.rs/svd2rust/0.12.0/svd2rust/#peripheral-api" ] # ! [ allow ( private_no_mangle_statics ) ] # ! [ deny ( missing_docs ) ] # ! [ deny ( warnings ) ] # ! [ allow ( non_camel_case_types ) ] # ! [ feature ( const_fn ) ] # ! [ feature ( try_from ) ] # ! [ no_std ] | |
extern crate bare_metal; | |
extern crate cortex_m; | |
#[macro_reexport(default_handler, exception)] | |
#[cfg(feature = "rt")] | |
extern crate cortex_m_rt; | |
extern crate vcell; | |
use core::ops::Deref; | |
use core::marker::PhantomData; | |
#[doc = r" Number available in the NVIC for configuring priority"] | |
pub const NVIC_PRIO_BITS: u8 = 3; | |
pub use cortex_m::peripheral::Peripherals as CorePeripherals; | |
pub use cortex_m::peripheral::CPUID; | |
pub use cortex_m::peripheral::DCB; | |
pub use cortex_m::peripheral::DWT; | |
pub use cortex_m::peripheral::MPU; | |
pub use cortex_m::peripheral::NVIC; | |
pub use cortex_m::peripheral::SCB; | |
pub use cortex_m::peripheral::SYST; | |
#[doc = "System Control Unit (SCU) I/O configuration"] | |
pub struct SCU { | |
_marker: PhantomData<*const ()>, | |
} | |
unsafe impl Send for SCU {} | |
impl SCU { | |
#[doc = r" Returns a pointer to the register block"] | |
pub fn ptr() -> *const scu::RegisterBlock { | |
0x4008_6000 as *const _ | |
} | |
} | |
impl Deref for SCU { | |
type Target = scu::RegisterBlock; | |
fn deref(&self) -> &scu::RegisterBlock { | |
unsafe { &*SCU::ptr() } | |
} | |
} | |
#[doc = "System Control Unit (SCU) I/O configuration"] | |
pub mod scu { | |
#[doc = r" Register block"] | |
#[repr(C)] | |
pub struct RegisterBlock { | |
#[doc = "0x00 - Pin configuration register for pins P0"] | |
pub sfsp0_: [SFSP0_; 2], | |
} | |
#[doc = "Pin configuration register for pins P0"] | |
pub struct SFSP0_ { | |
register: ::vcell::VolatileCell<u32>, | |
} | |
#[doc = "Pin configuration register for pins P0"] | |
pub mod sfsp0_ { | |
#[doc = r" Value read from the register"] | |
pub struct R { | |
bits: u32, | |
} | |
#[doc = r" Value to write to the register"] | |
pub struct W { | |
bits: u32, | |
} | |
impl super::SFSP0_ { | |
#[doc = r" Modifies the contents of the register"] | |
#[inline] | |
pub fn modify<F>(&self, f: F) | |
where | |
for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, | |
{ | |
let bits = self.register.get(); | |
let r = R { bits: bits }; | |
let mut w = W { bits: bits }; | |
f(&r, &mut w); | |
self.register.set(w.bits); | |
} | |
#[doc = r" Reads the contents of the register"] | |
#[inline] | |
pub fn read(&self) -> R { | |
R { | |
bits: self.register.get(), | |
} | |
} | |
#[doc = r" Writes to the register"] | |
#[inline] | |
pub fn write<F>(&self, f: F) | |
where | |
F: FnOnce(&mut W) -> &mut W, | |
{ | |
let mut w = W::reset_value(); | |
f(&mut w); | |
self.register.set(w.bits); | |
} | |
#[doc = r" Writes the reset value to the register"] | |
#[inline] | |
pub fn reset(&self) { | |
self.write(|w| w) | |
} | |
} | |
#[doc = "Possible values of the field `MODE`"] | |
#[derive(Clone, Copy, Debug, PartialEq)] | |
pub enum MODER { | |
#[doc = "Function 0 (default)"] | |
FUNCTION_0_DEFAULT, | |
#[doc = "Function 1"] | |
FUNCTION_1, | |
#[doc = "Function 2"] | |
FUNCTION_2, | |
#[doc = "Function 3"] | |
FUNCTION_3, | |
#[doc = "Function 4"] | |
FUNCTION_4, | |
#[doc = "Function 5"] | |
FUNCTION_5, | |
#[doc = "Function 6"] | |
FUNCTION_6, | |
#[doc = "Function 7"] | |
FUNCTION_7, | |
} | |
impl MODER { | |
#[doc = r" Value of the field as raw bits"] | |
#[inline] | |
pub fn bits(&self) -> u8 { | |
match *self { | |
MODER::FUNCTION_0_DEFAULT => 0, | |
MODER::FUNCTION_1 => 0x01, | |
MODER::FUNCTION_2 => 0x02, | |
MODER::FUNCTION_3 => 0x03, | |
MODER::FUNCTION_4 => 0x04, | |
MODER::FUNCTION_5 => 0x05, | |
MODER::FUNCTION_6 => 0x06, | |
MODER::FUNCTION_7 => 0x07, | |
} | |
} | |
#[allow(missing_docs)] | |
#[doc(hidden)] | |
#[inline] | |
pub fn _from(value: u8) -> MODER { | |
match value { | |
0 => MODER::FUNCTION_0_DEFAULT, | |
1 => MODER::FUNCTION_1, | |
2 => MODER::FUNCTION_2, | |
3 => MODER::FUNCTION_3, | |
4 => MODER::FUNCTION_4, | |
5 => MODER::FUNCTION_5, | |
6 => MODER::FUNCTION_6, | |
7 => MODER::FUNCTION_7, | |
_ => unreachable!(), | |
} | |
} | |
#[doc = "Checks if the value of the field is `FUNCTION_0_DEFAULT`"] | |
#[inline] | |
pub fn is_function_0_default(&self) -> bool { | |
*self == MODER::FUNCTION_0_DEFAULT | |
} | |
#[doc = "Checks if the value of the field is `FUNCTION_1`"] | |
#[inline] | |
pub fn is_function_1(&self) -> bool { | |
*self == MODER::FUNCTION_1 | |
} | |
#[doc = "Checks if the value of the field is `FUNCTION_2`"] | |
#[inline] | |
pub fn is_function_2(&self) -> bool { | |
*self == MODER::FUNCTION_2 | |
} | |
#[doc = "Checks if the value of the field is `FUNCTION_3`"] | |
#[inline] | |
pub fn is_function_3(&self) -> bool { | |
*self == MODER::FUNCTION_3 | |
} | |
#[doc = "Checks if the value of the field is `FUNCTION_4`"] | |
#[inline] | |
pub fn is_function_4(&self) -> bool { | |
*self == MODER::FUNCTION_4 | |
} | |
#[doc = "Checks if the value of the field is `FUNCTION_5`"] | |
#[inline] | |
pub fn is_function_5(&self) -> bool { | |
*self == MODER::FUNCTION_5 | |
} | |
#[doc = "Checks if the value of the field is `FUNCTION_6`"] | |
#[inline] | |
pub fn is_function_6(&self) -> bool { | |
*self == MODER::FUNCTION_6 | |
} | |
#[doc = "Checks if the value of the field is `FUNCTION_7`"] | |
#[inline] | |
pub fn is_function_7(&self) -> bool { | |
*self == MODER::FUNCTION_7 | |
} | |
} | |
#[doc = "Possible values of the field `EPD`"] | |
#[derive(Clone, Copy, Debug, PartialEq)] | |
pub enum EPDR {# [ doc = "Disable pull-down." ] DISABLE_PULL_DOWN , # [ doc = "Enable pull-down.Enable both pull-down resistor and pull-up resistor for repeater mode." ] ENABLE_PULL_DOWN} | |
impl EPDR { | |
#[doc = r" Returns `true` if the bit is clear (0)"] | |
#[inline] | |
pub fn bit_is_clear(&self) -> bool { | |
!self.bit() | |
} | |
#[doc = r" Returns `true` if the bit is set (1)"] | |
#[inline] | |
pub fn bit_is_set(&self) -> bool { | |
self.bit() | |
} | |
#[doc = r" Value of the field as raw bits"] | |
#[inline] | |
pub fn bit(&self) -> bool { | |
match *self { | |
EPDR::DISABLE_PULL_DOWN => false, | |
EPDR::ENABLE_PULL_DOWN => true, | |
} | |
} | |
#[allow(missing_docs)] | |
#[doc(hidden)] | |
#[inline] | |
pub fn _from(value: bool) -> EPDR { | |
match value { | |
false => EPDR::DISABLE_PULL_DOWN, | |
true => EPDR::ENABLE_PULL_DOWN, | |
} | |
} | |
#[doc = "Checks if the value of the field is `DISABLE_PULL_DOWN`"] | |
#[inline] | |
pub fn is_disable_pull_down(&self) -> bool { | |
*self == EPDR::DISABLE_PULL_DOWN | |
} | |
#[doc = "Checks if the value of the field is `ENABLE_PULL_DOWN`"] | |
#[inline] | |
pub fn is_enable_pull_down(&self) -> bool { | |
*self == EPDR::ENABLE_PULL_DOWN | |
} | |
} | |
#[doc = "Possible values of the field `EPUN`"] | |
#[derive(Clone, Copy, Debug, PartialEq)] | |
pub enum EPUNR {# [ doc = "Enable pull-up. Enable both pull-down resistor and pull-up resistor for repeater mode." ] ENABLE_PULL_UP , # [ doc = "Disable pull-up." ] DISABLE_PULL_UP} | |
impl EPUNR { | |
#[doc = r" Returns `true` if the bit is clear (0)"] | |
#[inline] | |
pub fn bit_is_clear(&self) -> bool { | |
!self.bit() | |
} | |
#[doc = r" Returns `true` if the bit is set (1)"] | |
#[inline] | |
pub fn bit_is_set(&self) -> bool { | |
self.bit() | |
} | |
#[doc = r" Value of the field as raw bits"] | |
#[inline] | |
pub fn bit(&self) -> bool { | |
match *self { | |
EPUNR::ENABLE_PULL_UP => false, | |
EPUNR::DISABLE_PULL_UP => true, | |
} | |
} | |
#[allow(missing_docs)] | |
#[doc(hidden)] | |
#[inline] | |
pub fn _from(value: bool) -> EPUNR { | |
match value { | |
false => EPUNR::ENABLE_PULL_UP, | |
true => EPUNR::DISABLE_PULL_UP, | |
} | |
} | |
#[doc = "Checks if the value of the field is `ENABLE_PULL_UP`"] | |
#[inline] | |
pub fn is_enable_pull_up(&self) -> bool { | |
*self == EPUNR::ENABLE_PULL_UP | |
} | |
#[doc = "Checks if the value of the field is `DISABLE_PULL_UP`"] | |
#[inline] | |
pub fn is_disable_pull_up(&self) -> bool { | |
*self == EPUNR::DISABLE_PULL_UP | |
} | |
} | |
#[doc = "Possible values of the field `EHS`"] | |
#[derive(Clone, Copy, Debug, PartialEq)] | |
pub enum EHSR { | |
#[doc = "Slow (low noise with medium speed)"] | |
SLOW_LOW_NOISE_WITH, | |
#[doc = "Fast (medium noise with fast speed)"] | |
FAST_MEDIUM_NOISE_W, | |
} | |
impl EHSR { | |
#[doc = r" Returns `true` if the bit is clear (0)"] | |
#[inline] | |
pub fn bit_is_clear(&self) -> bool { | |
!self.bit() | |
} | |
#[doc = r" Returns `true` if the bit is set (1)"] | |
#[inline] | |
pub fn bit_is_set(&self) -> bool { | |
self.bit() | |
} | |
#[doc = r" Value of the field as raw bits"] | |
#[inline] | |
pub fn bit(&self) -> bool { | |
match *self { | |
EHSR::SLOW_LOW_NOISE_WITH => false, | |
EHSR::FAST_MEDIUM_NOISE_W => true, | |
} | |
} | |
#[allow(missing_docs)] | |
#[doc(hidden)] | |
#[inline] | |
pub fn _from(value: bool) -> EHSR { | |
match value { | |
false => EHSR::SLOW_LOW_NOISE_WITH, | |
true => EHSR::FAST_MEDIUM_NOISE_W, | |
} | |
} | |
#[doc = "Checks if the value of the field is `SLOW_LOW_NOISE_WITH`"] | |
#[inline] | |
pub fn is_slow_low_noise_with(&self) -> bool { | |
*self == EHSR::SLOW_LOW_NOISE_WITH | |
} | |
#[doc = "Checks if the value of the field is `FAST_MEDIUM_NOISE_W`"] | |
#[inline] | |
pub fn is_fast_medium_noise_w(&self) -> bool { | |
*self == EHSR::FAST_MEDIUM_NOISE_W | |
} | |
} | |
#[doc = "Possible values of the field `EZI`"] | |
#[derive(Clone, Copy, Debug, PartialEq)] | |
pub enum EZIR { | |
#[doc = "Disable input buffer"] | |
DISABLE_INPUT_BUFFER, | |
#[doc = "Enable input buffer"] | |
ENABLE_INPUT_BUFFER, | |
} | |
impl EZIR { | |
#[doc = r" Returns `true` if the bit is clear (0)"] | |
#[inline] | |
pub fn bit_is_clear(&self) -> bool { | |
!self.bit() | |
} | |
#[doc = r" Returns `true` if the bit is set (1)"] | |
#[inline] | |
pub fn bit_is_set(&self) -> bool { | |
self.bit() | |
} | |
#[doc = r" Value of the field as raw bits"] | |
#[inline] | |
pub fn bit(&self) -> bool { | |
match *self { | |
EZIR::DISABLE_INPUT_BUFFER => false, | |
EZIR::ENABLE_INPUT_BUFFER => true, | |
} | |
} | |
#[allow(missing_docs)] | |
#[doc(hidden)] | |
#[inline] | |
pub fn _from(value: bool) -> EZIR { | |
match value { | |
false => EZIR::DISABLE_INPUT_BUFFER, | |
true => EZIR::ENABLE_INPUT_BUFFER, | |
} | |
} | |
#[doc = "Checks if the value of the field is `DISABLE_INPUT_BUFFER`"] | |
#[inline] | |
pub fn is_disable_input_buffer(&self) -> bool { | |
*self == EZIR::DISABLE_INPUT_BUFFER | |
} | |
#[doc = "Checks if the value of the field is `ENABLE_INPUT_BUFFER`"] | |
#[inline] | |
pub fn is_enable_input_buffer(&self) -> bool { | |
*self == EZIR::ENABLE_INPUT_BUFFER | |
} | |
} | |
#[doc = "Possible values of the field `ZIF`"] | |
#[derive(Clone, Copy, Debug, PartialEq)] | |
pub enum ZIFR { | |
#[doc = "Enable input glitch filter"] | |
ENABLE_INPUT_GLITCH, | |
#[doc = "Disable input glitch filter"] | |
DISABLE_INPUT_GLITCH, | |
} | |
impl ZIFR { | |
#[doc = r" Returns `true` if the bit is clear (0)"] | |
#[inline] | |
pub fn bit_is_clear(&self) -> bool { | |
!self.bit() | |
} | |
#[doc = r" Returns `true` if the bit is set (1)"] | |
#[inline] | |
pub fn bit_is_set(&self) -> bool { | |
self.bit() | |
} | |
#[doc = r" Value of the field as raw bits"] | |
#[inline] | |
pub fn bit(&self) -> bool { | |
match *self { | |
ZIFR::ENABLE_INPUT_GLITCH => false, | |
ZIFR::DISABLE_INPUT_GLITCH => true, | |
} | |
} | |
#[allow(missing_docs)] | |
#[doc(hidden)] | |
#[inline] | |
pub fn _from(value: bool) -> ZIFR { | |
match value { | |
false => ZIFR::ENABLE_INPUT_GLITCH, | |
true => ZIFR::DISABLE_INPUT_GLITCH, | |
} | |
} | |
#[doc = "Checks if the value of the field is `ENABLE_INPUT_GLITCH`"] | |
#[inline] | |
pub fn is_enable_input_glitch(&self) -> bool { | |
*self == ZIFR::ENABLE_INPUT_GLITCH | |
} | |
#[doc = "Checks if the value of the field is `DISABLE_INPUT_GLITCH`"] | |
#[inline] | |
pub fn is_disable_input_glitch(&self) -> bool { | |
*self == ZIFR::DISABLE_INPUT_GLITCH | |
} | |
} | |
#[doc = "Values that can be written to the field `MODE`"] | |
pub enum MODEW { | |
#[doc = "Function 0 (default)"] | |
FUNCTION_0_DEFAULT, | |
#[doc = "Function 1"] | |
FUNCTION_1, | |
#[doc = "Function 2"] | |
FUNCTION_2, | |
#[doc = "Function 3"] | |
FUNCTION_3, | |
#[doc = "Function 4"] | |
FUNCTION_4, | |
#[doc = "Function 5"] | |
FUNCTION_5, | |
#[doc = "Function 6"] | |
FUNCTION_6, | |
#[doc = "Function 7"] | |
FUNCTION_7, | |
} | |
impl MODEW { | |
#[allow(missing_docs)] | |
#[doc(hidden)] | |
#[inline] | |
pub fn _bits(&self) -> u8 { | |
match *self { | |
MODEW::FUNCTION_0_DEFAULT => 0, | |
MODEW::FUNCTION_1 => 1, | |
MODEW::FUNCTION_2 => 2, | |
MODEW::FUNCTION_3 => 3, | |
MODEW::FUNCTION_4 => 4, | |
MODEW::FUNCTION_5 => 5, | |
MODEW::FUNCTION_6 => 6, | |
MODEW::FUNCTION_7 => 7, | |
} | |
} | |
} | |
#[doc = r" Proxy"] | |
pub struct _MODEW<'a> { | |
w: &'a mut W, | |
} | |
impl<'a> _MODEW<'a> { | |
#[doc = r" Writes `variant` to the field"] | |
#[inline] | |
pub fn variant(self, variant: MODEW) -> &'a mut W { | |
{ | |
self.bits(variant._bits()) | |
} | |
} | |
#[doc = "Function 0 (default)"] | |
#[inline] | |
pub fn function_0_default(self) -> &'a mut W { | |
self.variant(MODEW::FUNCTION_0_DEFAULT) | |
} | |
#[doc = "Function 1"] | |
#[inline] | |
pub fn function_1(self) -> &'a mut W { | |
self.variant(MODEW::FUNCTION_1) | |
} | |
#[doc = "Function 2"] | |
#[inline] | |
pub fn function_2(self) -> &'a mut W { | |
self.variant(MODEW::FUNCTION_2) | |
} | |
#[doc = "Function 3"] | |
#[inline] | |
pub fn function_3(self) -> &'a mut W { | |
self.variant(MODEW::FUNCTION_3) | |
} | |
#[doc = "Function 4"] | |
#[inline] | |
pub fn function_4(self) -> &'a mut W { | |
self.variant(MODEW::FUNCTION_4) | |
} | |
#[doc = "Function 5"] | |
#[inline] | |
pub fn function_5(self) -> &'a mut W { | |
self.variant(MODEW::FUNCTION_5) | |
} | |
#[doc = "Function 6"] | |
#[inline] | |
pub fn function_6(self) -> &'a mut W { | |
self.variant(MODEW::FUNCTION_6) | |
} | |
#[doc = "Function 7"] | |
#[inline] | |
pub fn function_7(self) -> &'a mut W { | |
self.variant(MODEW::FUNCTION_7) | |
} | |
#[doc = r" Writes raw bits to the field"] | |
#[inline] | |
pub fn bits(self, value: u8) -> &'a mut W { | |
const MASK: u8 = 0x07; | |
const OFFSET: u8 = 0; | |
self.w.bits &= !((MASK as u32) << OFFSET); | |
self.w.bits |= ((value & MASK) as u32) << OFFSET; | |
self.w | |
} | |
} | |
#[doc = "Values that can be written to the field `EPD`"] | |
pub enum EPDW {# [ doc = "Disable pull-down." ] DISABLE_PULL_DOWN , # [ doc = "Enable pull-down.Enable both pull-down resistor and pull-up resistor for repeater mode." ] ENABLE_PULL_DOWN} | |
impl EPDW { | |
#[allow(missing_docs)] | |
#[doc(hidden)] | |
#[inline] | |
pub fn _bits(&self) -> bool { | |
match *self { | |
EPDW::DISABLE_PULL_DOWN => false, | |
EPDW::ENABLE_PULL_DOWN => true, | |
} | |
} | |
} | |
#[doc = r" Proxy"] | |
pub struct _EPDW<'a> { | |
w: &'a mut W, | |
} | |
impl<'a> _EPDW<'a> { | |
#[doc = r" Writes `variant` to the field"] | |
#[inline] | |
pub fn variant(self, variant: EPDW) -> &'a mut W { | |
{ | |
self.bit(variant._bits()) | |
} | |
} | |
#[doc = "Disable pull-down."] | |
#[inline] | |
pub fn disable_pull_down(self) -> &'a mut W { | |
self.variant(EPDW::DISABLE_PULL_DOWN) | |
} | |
# [ doc = "Enable pull-down.Enable both pull-down resistor and pull-up resistor for repeater mode." ] # [ inline ] | |
pub fn enable_pull_down(self) -> &'a mut W { | |
self.variant(EPDW::ENABLE_PULL_DOWN) | |
} | |
#[doc = r" Sets the field bit"] | |
pub fn set_bit(self) -> &'a mut W { | |
self.bit(true) | |
} | |
#[doc = r" Clears the field bit"] | |
pub fn clear_bit(self) -> &'a mut W { | |
self.bit(false) | |
} | |
#[doc = r" Writes raw bits to the field"] | |
#[inline] | |
pub fn bit(self, value: bool) -> &'a mut W { | |
const MASK: bool = true; | |
const OFFSET: u8 = 3; | |
self.w.bits &= !((MASK as u32) << OFFSET); | |
self.w.bits |= ((value & MASK) as u32) << OFFSET; | |
self.w | |
} | |
} | |
#[doc = "Values that can be written to the field `EPUN`"] | |
pub enum EPUNW {# [ doc = "Enable pull-up. Enable both pull-down resistor and pull-up resistor for repeater mode." ] ENABLE_PULL_UP , # [ doc = "Disable pull-up." ] DISABLE_PULL_UP} | |
impl EPUNW { | |
#[allow(missing_docs)] | |
#[doc(hidden)] | |
#[inline] | |
pub fn _bits(&self) -> bool { | |
match *self { | |
EPUNW::ENABLE_PULL_UP => false, | |
EPUNW::DISABLE_PULL_UP => true, | |
} | |
} | |
} | |
#[doc = r" Proxy"] | |
pub struct _EPUNW<'a> { | |
w: &'a mut W, | |
} | |
impl<'a> _EPUNW<'a> { | |
#[doc = r" Writes `variant` to the field"] | |
#[inline] | |
pub fn variant(self, variant: EPUNW) -> &'a mut W { | |
{ | |
self.bit(variant._bits()) | |
} | |
} | |
# [ doc = "Enable pull-up. Enable both pull-down resistor and pull-up resistor for repeater mode." ] # [ inline ] | |
pub fn enable_pull_up(self) -> &'a mut W { | |
self.variant(EPUNW::ENABLE_PULL_UP) | |
} | |
#[doc = "Disable pull-up."] | |
#[inline] | |
pub fn disable_pull_up(self) -> &'a mut W { | |
self.variant(EPUNW::DISABLE_PULL_UP) | |
} | |
#[doc = r" Sets the field bit"] | |
pub fn set_bit(self) -> &'a mut W { | |
self.bit(true) | |
} | |
#[doc = r" Clears the field bit"] | |
pub fn clear_bit(self) -> &'a mut W { | |
self.bit(false) | |
} | |
#[doc = r" Writes raw bits to the field"] | |
#[inline] | |
pub fn bit(self, value: bool) -> &'a mut W { | |
const MASK: bool = true; | |
const OFFSET: u8 = 4; | |
self.w.bits &= !((MASK as u32) << OFFSET); | |
self.w.bits |= ((value & MASK) as u32) << OFFSET; | |
self.w | |
} | |
} | |
#[doc = "Values that can be written to the field `EHS`"] | |
pub enum EHSW { | |
#[doc = "Slow (low noise with medium speed)"] | |
SLOW_LOW_NOISE_WITH, | |
#[doc = "Fast (medium noise with fast speed)"] | |
FAST_MEDIUM_NOISE_W, | |
} | |
impl EHSW { | |
#[allow(missing_docs)] | |
#[doc(hidden)] | |
#[inline] | |
pub fn _bits(&self) -> bool { | |
match *self { | |
EHSW::SLOW_LOW_NOISE_WITH => false, | |
EHSW::FAST_MEDIUM_NOISE_W => true, | |
} | |
} | |
} | |
#[doc = r" Proxy"] | |
pub struct _EHSW<'a> { | |
w: &'a mut W, | |
} | |
impl<'a> _EHSW<'a> { | |
#[doc = r" Writes `variant` to the field"] | |
#[inline] | |
pub fn variant(self, variant: EHSW) -> &'a mut W { | |
{ | |
self.bit(variant._bits()) | |
} | |
} | |
#[doc = "Slow (low noise with medium speed)"] | |
#[inline] | |
pub fn slow_low_noise_with(self) -> &'a mut W { | |
self.variant(EHSW::SLOW_LOW_NOISE_WITH) | |
} | |
#[doc = "Fast (medium noise with fast speed)"] | |
#[inline] | |
pub fn fast_medium_noise_w(self) -> &'a mut W { | |
self.variant(EHSW::FAST_MEDIUM_NOISE_W) | |
} | |
#[doc = r" Sets the field bit"] | |
pub fn set_bit(self) -> &'a mut W { | |
self.bit(true) | |
} | |
#[doc = r" Clears the field bit"] | |
pub fn clear_bit(self) -> &'a mut W { | |
self.bit(false) | |
} | |
#[doc = r" Writes raw bits to the field"] | |
#[inline] | |
pub fn bit(self, value: bool) -> &'a mut W { | |
const MASK: bool = true; | |
const OFFSET: u8 = 5; | |
self.w.bits &= !((MASK as u32) << OFFSET); | |
self.w.bits |= ((value & MASK) as u32) << OFFSET; | |
self.w | |
} | |
} | |
#[doc = "Values that can be written to the field `EZI`"] | |
pub enum EZIW { | |
#[doc = "Disable input buffer"] | |
DISABLE_INPUT_BUFFER, | |
#[doc = "Enable input buffer"] | |
ENABLE_INPUT_BUFFER, | |
} | |
impl EZIW { | |
#[allow(missing_docs)] | |
#[doc(hidden)] | |
#[inline] | |
pub fn _bits(&self) -> bool { | |
match *self { | |
EZIW::DISABLE_INPUT_BUFFER => false, | |
EZIW::ENABLE_INPUT_BUFFER => true, | |
} | |
} | |
} | |
#[doc = r" Proxy"] | |
pub struct _EZIW<'a> { | |
w: &'a mut W, | |
} | |
impl<'a> _EZIW<'a> { | |
#[doc = r" Writes `variant` to the field"] | |
#[inline] | |
pub fn variant(self, variant: EZIW) -> &'a mut W { | |
{ | |
self.bit(variant._bits()) | |
} | |
} | |
#[doc = "Disable input buffer"] | |
#[inline] | |
pub fn disable_input_buffer(self) -> &'a mut W { | |
self.variant(EZIW::DISABLE_INPUT_BUFFER) | |
} | |
#[doc = "Enable input buffer"] | |
#[inline] | |
pub fn enable_input_buffer(self) -> &'a mut W { | |
self.variant(EZIW::ENABLE_INPUT_BUFFER) | |
} | |
#[doc = r" Sets the field bit"] | |
pub fn set_bit(self) -> &'a mut W { | |
self.bit(true) | |
} | |
#[doc = r" Clears the field bit"] | |
pub fn clear_bit(self) -> &'a mut W { | |
self.bit(false) | |
} | |
#[doc = r" Writes raw bits to the field"] | |
#[inline] | |
pub fn bit(self, value: bool) -> &'a mut W { | |
const MASK: bool = true; | |
const OFFSET: u8 = 6; | |
self.w.bits &= !((MASK as u32) << OFFSET); | |
self.w.bits |= ((value & MASK) as u32) << OFFSET; | |
self.w | |
} | |
} | |
#[doc = "Values that can be written to the field `ZIF`"] | |
pub enum ZIFW { | |
#[doc = "Enable input glitch filter"] | |
ENABLE_INPUT_GLITCH, | |
#[doc = "Disable input glitch filter"] | |
DISABLE_INPUT_GLITCH, | |
} | |
impl ZIFW { | |
#[allow(missing_docs)] | |
#[doc(hidden)] | |
#[inline] | |
pub fn _bits(&self) -> bool { | |
match *self { | |
ZIFW::ENABLE_INPUT_GLITCH => false, | |
ZIFW::DISABLE_INPUT_GLITCH => true, | |
} | |
} | |
} | |
#[doc = r" Proxy"] | |
pub struct _ZIFW<'a> { | |
w: &'a mut W, | |
} | |
impl<'a> _ZIFW<'a> { | |
#[doc = r" Writes `variant` to the field"] | |
#[inline] | |
pub fn variant(self, variant: ZIFW) -> &'a mut W { | |
{ | |
self.bit(variant._bits()) | |
} | |
} | |
#[doc = "Enable input glitch filter"] | |
#[inline] | |
pub fn enable_input_glitch(self) -> &'a mut W { | |
self.variant(ZIFW::ENABLE_INPUT_GLITCH) | |
} | |
#[doc = "Disable input glitch filter"] | |
#[inline] | |
pub fn disable_input_glitch(self) -> &'a mut W { | |
self.variant(ZIFW::DISABLE_INPUT_GLITCH) | |
} | |
#[doc = r" Sets the field bit"] | |
pub fn set_bit(self) -> &'a mut W { | |
self.bit(true) | |
} | |
#[doc = r" Clears the field bit"] | |
pub fn clear_bit(self) -> &'a mut W { | |
self.bit(false) | |
} | |
#[doc = r" Writes raw bits to the field"] | |
#[inline] | |
pub fn bit(self, value: bool) -> &'a mut W { | |
const MASK: bool = true; | |
const OFFSET: u8 = 7; | |
self.w.bits &= !((MASK as u32) << OFFSET); | |
self.w.bits |= ((value & MASK) as u32) << OFFSET; | |
self.w | |
} | |
} | |
impl R { | |
#[doc = r" Value of the register as raw bits"] | |
#[inline] | |
pub fn bits(&self) -> u32 { | |
self.bits | |
} | |
#[doc = "Bits 0:2 - Select pin function."] | |
#[inline] | |
pub fn mode(&self) -> MODER { | |
MODER::_from({ | |
const MASK: u8 = 0x07; | |
const OFFSET: u8 = 0; | |
((self.bits >> OFFSET) & MASK as u32) as u8 | |
}) | |
} | |
#[doc = "Bit 3 - Enable pull-down resistor at pad."] | |
#[inline] | |
pub fn epd(&self) -> EPDR { | |
EPDR::_from({ | |
const MASK: bool = true; | |
const OFFSET: u8 = 3; | |
((self.bits >> OFFSET) & MASK as u32) != 0 | |
}) | |
} | |
# [ doc = "Bit 4 - Disable pull-up resistor at pad. By default, the pull-up resistor is enabled at reset." ] # [ inline ] | |
pub fn epun(&self) -> EPUNR { | |
EPUNR::_from({ | |
const MASK: bool = true; | |
const OFFSET: u8 = 4; | |
((self.bits >> OFFSET) & MASK as u32) != 0 | |
}) | |
} | |
#[doc = "Bit 5 - Select Slew rate."] | |
#[inline] | |
pub fn ehs(&self) -> EHSR { | |
EHSR::_from({ | |
const MASK: bool = true; | |
const OFFSET: u8 = 5; | |
((self.bits >> OFFSET) & MASK as u32) != 0 | |
}) | |
} | |
# [ doc = "Bit 6 - Input buffer enable. The input buffer is disabled by default at reset and must be enabled for receiving." ] # [ inline ] | |
pub fn ezi(&self) -> EZIR { | |
EZIR::_from({ | |
const MASK: bool = true; | |
const OFFSET: u8 = 6; | |
((self.bits >> OFFSET) & MASK as u32) != 0 | |
}) | |
} | |
# [ doc = "Bit 7 - Input glitch filter. Disable the input glitch filter for clocking signals higher than 30 MHz." ] # [ inline ] | |
pub fn zif(&self) -> ZIFR { | |
ZIFR::_from({ | |
const MASK: bool = true; | |
const OFFSET: u8 = 7; | |
((self.bits >> OFFSET) & MASK as u32) != 0 | |
}) | |
} | |
} | |
impl W { | |
#[doc = r" Reset value of the register"] | |
#[inline] | |
pub fn reset_value() -> W { | |
W { bits: 0 } | |
} | |
#[doc = r" Writes raw bits to the register"] | |
#[inline] | |
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { | |
self.bits = bits; | |
self | |
} | |
#[doc = "Bits 0:2 - Select pin function."] | |
#[inline] | |
pub fn mode(&mut self) -> _MODEW { | |
_MODEW { w: self } | |
} | |
#[doc = "Bit 3 - Enable pull-down resistor at pad."] | |
#[inline] | |
pub fn epd(&mut self) -> _EPDW { | |
_EPDW { w: self } | |
} | |
# [ doc = "Bit 4 - Disable pull-up resistor at pad. By default, the pull-up resistor is enabled at reset." ] # [ inline ] | |
pub fn epun(&mut self) -> _EPUNW { | |
_EPUNW { w: self } | |
} | |
#[doc = "Bit 5 - Select Slew rate."] | |
#[inline] | |
pub fn ehs(&mut self) -> _EHSW { | |
_EHSW { w: self } | |
} | |
# [ doc = "Bit 6 - Input buffer enable. The input buffer is disabled by default at reset and must be enabled for receiving." ] # [ inline ] | |
pub fn ezi(&mut self) -> _EZIW { | |
_EZIW { w: self } | |
} | |
# [ doc = "Bit 7 - Input glitch filter. Disable the input glitch filter for clocking signals higher than 30 MHz." ] # [ inline ] | |
pub fn zif(&mut self) -> _ZIFW { | |
_ZIFW { w: self } | |
} | |
} | |
} | |
} | |
#[no_mangle] | |
static mut DEVICE_PERIPHERALS: bool = false; | |
#[doc = r" All the peripherals"] | |
#[allow(non_snake_case)] | |
pub struct Peripherals { | |
#[doc = "SCU"] | |
pub SCU: SCU, | |
} | |
impl Peripherals { | |
#[doc = r" Returns all the peripherals *once*"] | |
#[inline] | |
pub fn take() -> Option<Self> { | |
cortex_m::interrupt::free(|_| { | |
if unsafe { DEVICE_PERIPHERALS } { | |
None | |
} else { | |
Some(unsafe { Peripherals::steal() }) | |
} | |
}) | |
} | |
#[doc = r" Unchecked version of `Peripherals::take`"] | |
pub unsafe fn steal() -> Self { | |
debug_assert!(!DEVICE_PERIPHERALS); | |
DEVICE_PERIPHERALS = true; | |
Peripherals { | |
SCU: SCU { | |
_marker: PhantomData, | |
}, | |
} | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment