12410 lines
553 KiB
Rust
12410 lines
553 KiB
Rust
|
#[cfg(feature = "device-selected")]
|
||
|
|
pub mod gpio {
|
||
|
|
//! General Purpose Input / Output
|
||
|
|
use core::convert::Infallible;
|
||
|
|
use core::marker::PhantomData;
|
||
|
|
use crate::rcc::Rcc;
|
||
|
|
/// Extension trait to split a GPIO peripheral in independent pins and registers
|
||
|
|
pub trait GpioExt {
|
||
|
|
/// The parts to split the GPIO into
|
||
|
|
type Parts;
|
||
|
|
/// Splits the GPIO block into independent pins and registers
|
||
|
|
fn split(self, rcc: &mut Rcc) -> Self::Parts;
|
||
|
|
}
|
||
|
|
trait GpioRegExt {
|
||
|
|
fn is_low(&self, pos: u8) -> bool;
|
||
|
|
fn is_set_low(&self, pos: u8) -> bool;
|
||
|
|
fn set_high(&self, pos: u8);
|
||
|
|
fn set_low(&self, pos: u8);
|
||
|
|
}
|
||
|
|
/// Alternate function 0
|
||
|
|
pub struct AF0;
|
||
|
|
/// Alternate function 1
|
||
|
|
pub struct AF1;
|
||
|
|
/// Alternate function 2
|
||
|
|
pub struct AF2;
|
||
|
|
/// Alternate function 3
|
||
|
|
pub struct AF3;
|
||
|
|
/// Alternate function 4
|
||
|
|
pub struct AF4;
|
||
|
|
/// Alternate function 5
|
||
|
|
pub struct AF5;
|
||
|
|
/// Alternate function 6
|
||
|
|
pub struct AF6;
|
||
|
|
/// Alternate function 7
|
||
|
|
pub struct AF7;
|
||
|
|
/// Alternate function mode (type state)
|
||
|
|
pub struct Alternate<AF> {
|
||
|
|
_mode: PhantomData<AF>,
|
||
|
|
}
|
||
|
|
/// Input mode (type state)
|
||
|
|
pub struct Input<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
/// Floating input (type state)
|
||
|
|
pub struct Floating;
|
||
|
|
/// Pulled down input (type state)
|
||
|
|
pub struct PullDown;
|
||
|
|
/// Pulled up input (type state)
|
||
|
|
pub struct PullUp;
|
||
|
|
/// Open drain input or output (type state)
|
||
|
|
pub struct OpenDrain;
|
||
|
|
/// Analog mode (type state)
|
||
|
|
pub struct Analog;
|
||
|
|
/// Output mode (type state)
|
||
|
|
pub struct Output<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
/// Push pull output (type state)
|
||
|
|
pub struct PushPull;
|
||
|
|
use embedded_hal::digital::v2::{toggleable, InputPin, OutputPin, StatefulOutputPin};
|
||
|
|
/// Fully erased pin
|
||
|
|
pub struct Pin<MODE> {
|
||
|
|
i: u8,
|
||
|
|
port: *const dyn GpioRegExt,
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
unsafe impl<MODE> Sync for Pin<MODE> {}
|
||
|
|
unsafe impl<MODE> Send for Pin<MODE> {}
|
||
|
|
impl<MODE> StatefulOutputPin for Pin<Output<MODE>> {
|
||
|
|
#[inline(always)]
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
#[inline(always)]
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*self.port).is_set_low(self.i) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for Pin<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
#[inline(always)]
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
unsafe { (*self.port).set_high(self.i) };
|
||
|
|
Ok(())
|
||
|
|
}
|
||
|
|
#[inline(always)]
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
unsafe { (*self.port).set_low(self.i) }
|
||
|
|
Ok(())
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for Pin<Output<MODE>> {}
|
||
|
|
impl InputPin for Pin<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
#[inline(always)]
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
#[inline(always)]
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*self.port).is_low(self.i) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for Pin<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
#[inline(always)]
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
#[inline(always)]
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*self.port).is_low(self.i) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl GpioRegExt for crate::pac::gpioa::RegisterBlock {
|
||
|
|
fn is_low(&self, pos: u8) -> bool {
|
||
|
|
self.idr.read().bits() & (1 << pos) == 0
|
||
|
|
}
|
||
|
|
fn is_set_low(&self, pos: u8) -> bool {
|
||
|
|
self.odr.read().bits() & (1 << pos) == 0
|
||
|
|
}
|
||
|
|
fn set_high(&self, pos: u8) {
|
||
|
|
unsafe { self.bsrr.write(|w| w.bits(1 << pos)) }
|
||
|
|
}
|
||
|
|
fn set_low(&self, pos: u8) {
|
||
|
|
unsafe { self.bsrr.write(|w| w.bits(1 << (pos + 16))) }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl GpioRegExt for crate::pac::gpiof::RegisterBlock {
|
||
|
|
fn is_low(&self, pos: u8) -> bool {
|
||
|
|
self.idr.read().bits() & (1 << pos) == 0
|
||
|
|
}
|
||
|
|
fn is_set_low(&self, pos: u8) -> bool {
|
||
|
|
self.odr.read().bits() & (1 << pos) == 0
|
||
|
|
}
|
||
|
|
fn set_high(&self, pos: u8) {
|
||
|
|
unsafe { self.bsrr.write(|w| w.bits(1 << pos)) }
|
||
|
|
}
|
||
|
|
fn set_low(&self, pos: u8) {
|
||
|
|
unsafe { self.bsrr.write(|w| w.bits(1 << (pos + 16))) }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// GPIO
|
||
|
|
#[cfg(any(feature = "device-selected"))]
|
||
|
|
pub mod gpioa {
|
||
|
|
use core::marker::PhantomData;
|
||
|
|
use core::convert::Infallible;
|
||
|
|
use embedded_hal::digital::v2::{InputPin, OutputPin, StatefulOutputPin, toggleable};
|
||
|
|
use crate::{rcc::Rcc, pac::GPIOA};
|
||
|
|
use cortex_m::interrupt::CriticalSection;
|
||
|
|
use super::{
|
||
|
|
Alternate, Analog, Floating, GpioExt, Input, OpenDrain, Output, PullDown, PullUp,
|
||
|
|
PushPull, AF0, AF1, AF2, AF3, AF4, AF5, AF6, AF7, Pin, GpioRegExt,
|
||
|
|
};
|
||
|
|
/// GPIO parts
|
||
|
|
pub struct Parts {
|
||
|
|
/// Pin
|
||
|
|
pub pa0: PA0<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pa1: PA1<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pa2: PA2<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pa3: PA3<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pa4: PA4<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pa5: PA5<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pa6: PA6<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pa7: PA7<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pa8: PA8<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pa9: PA9<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pa10: PA10<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pa11: PA11<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pa12: PA12<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pa13: PA13<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pa14: PA14<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pa15: PA15<Input<Floating>>,
|
||
|
|
}
|
||
|
|
impl GpioExt for GPIOA {
|
||
|
|
type Parts = Parts;
|
||
|
|
fn split(self, rcc: &mut Rcc) -> Parts {
|
||
|
|
rcc.regs.ahbenr.modify(|_, w| w.iopaen().set_bit());
|
||
|
|
Parts {
|
||
|
|
pa0: PA0 { _mode: PhantomData },
|
||
|
|
pa1: PA1 { _mode: PhantomData },
|
||
|
|
pa2: PA2 { _mode: PhantomData },
|
||
|
|
pa3: PA3 { _mode: PhantomData },
|
||
|
|
pa4: PA4 { _mode: PhantomData },
|
||
|
|
pa5: PA5 { _mode: PhantomData },
|
||
|
|
pa6: PA6 { _mode: PhantomData },
|
||
|
|
pa7: PA7 { _mode: PhantomData },
|
||
|
|
pa8: PA8 { _mode: PhantomData },
|
||
|
|
pa9: PA9 { _mode: PhantomData },
|
||
|
|
pa10: PA10 { _mode: PhantomData },
|
||
|
|
pa11: PA11 { _mode: PhantomData },
|
||
|
|
pa12: PA12 { _mode: PhantomData },
|
||
|
|
pa13: PA13 { _mode: PhantomData },
|
||
|
|
pa14: PA14 { _mode: PhantomData },
|
||
|
|
pa15: PA15 { _mode: PhantomData },
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
fn _set_alternate_mode(index: usize, mode: u32) {
|
||
|
|
let offset = 2 * index;
|
||
|
|
let offset2 = 4 * index;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
if offset2 < 32 {
|
||
|
|
reg.afrl.modify(|r, w| {
|
||
|
|
w.bits((r.bits() & !(0b1111 << offset2)) | (mode << offset2))
|
||
|
|
});
|
||
|
|
} else {
|
||
|
|
let offset2 = offset2 - 32;
|
||
|
|
reg.afrh.modify(|r, w| {
|
||
|
|
w.bits((r.bits() & !(0b1111 << offset2)) | (mode << offset2))
|
||
|
|
});
|
||
|
|
}
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PA0<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PA0<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PA0<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(0, 0);
|
||
|
|
PA0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PA0<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(0, 1);
|
||
|
|
PA0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PA0<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(0, 2);
|
||
|
|
PA0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PA0<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(0, 3);
|
||
|
|
PA0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PA0<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(0, 4);
|
||
|
|
PA0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PA0<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(0, 5);
|
||
|
|
PA0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PA0<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(0, 6);
|
||
|
|
PA0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PA0<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(0, 7);
|
||
|
|
PA0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PA0<Input<Floating>> {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PA0<Input<PullDown>> {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PA0<Input<PullUp>> {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PA0<Analog> {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PA0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PA0<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 0)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PA0<Output<PushPull>> {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 0)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PA0<Output<PushPull>> {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 0)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 0)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PA0<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PA0<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PA0<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 0;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PA0<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 0,
|
||
|
|
port: GPIOA::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PA0<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_set_low(0) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PA0<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).set_high(0) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).set_low(0) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PA0<Output<MODE>> {}
|
||
|
|
impl InputPin for PA0<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_low(0) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PA0<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 0,
|
||
|
|
port: GPIOA::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PA0<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_low(0) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PA1<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PA1<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PA1<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(1, 0);
|
||
|
|
PA1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PA1<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(1, 1);
|
||
|
|
PA1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PA1<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(1, 2);
|
||
|
|
PA1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PA1<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(1, 3);
|
||
|
|
PA1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PA1<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(1, 4);
|
||
|
|
PA1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PA1<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(1, 5);
|
||
|
|
PA1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PA1<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(1, 6);
|
||
|
|
PA1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PA1<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(1, 7);
|
||
|
|
PA1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PA1<Input<Floating>> {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PA1<Input<PullDown>> {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PA1<Input<PullUp>> {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PA1<Analog> {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PA1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PA1<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 1)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PA1<Output<PushPull>> {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 1)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PA1<Output<PushPull>> {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 1)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 1)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PA1<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PA1<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PA1<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 1;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PA1<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 1,
|
||
|
|
port: GPIOA::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PA1<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_set_low(1) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PA1<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).set_high(1) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).set_low(1) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PA1<Output<MODE>> {}
|
||
|
|
impl InputPin for PA1<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_low(1) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PA1<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 1,
|
||
|
|
port: GPIOA::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PA1<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_low(1) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PA2<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PA2<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PA2<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(2, 0);
|
||
|
|
PA2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PA2<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(2, 1);
|
||
|
|
PA2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PA2<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(2, 2);
|
||
|
|
PA2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PA2<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(2, 3);
|
||
|
|
PA2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PA2<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(2, 4);
|
||
|
|
PA2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PA2<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(2, 5);
|
||
|
|
PA2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PA2<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(2, 6);
|
||
|
|
PA2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PA2<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(2, 7);
|
||
|
|
PA2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PA2<Input<Floating>> {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PA2<Input<PullDown>> {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PA2<Input<PullUp>> {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PA2<Analog> {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PA2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PA2<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 2)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PA2<Output<PushPull>> {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 2)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PA2<Output<PushPull>> {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 2)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 2)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PA2<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PA2<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PA2<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 2;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PA2<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 2,
|
||
|
|
port: GPIOA::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PA2<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_set_low(2) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PA2<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).set_high(2) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).set_low(2) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PA2<Output<MODE>> {}
|
||
|
|
impl InputPin for PA2<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_low(2) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PA2<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 2,
|
||
|
|
port: GPIOA::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PA2<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_low(2) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PA3<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PA3<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PA3<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(3, 0);
|
||
|
|
PA3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PA3<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(3, 1);
|
||
|
|
PA3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PA3<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(3, 2);
|
||
|
|
PA3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PA3<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(3, 3);
|
||
|
|
PA3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PA3<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(3, 4);
|
||
|
|
PA3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PA3<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(3, 5);
|
||
|
|
PA3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PA3<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(3, 6);
|
||
|
|
PA3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PA3<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(3, 7);
|
||
|
|
PA3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PA3<Input<Floating>> {
|
||
|
|
let offset = 2 * 3;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PA3<Input<PullDown>> {
|
||
|
|
let offset = 2 * 3;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PA3<Input<PullUp>> {
|
||
|
|
let offset = 2 * 3;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PA3<Analog> {
|
||
|
|
let offset = 2 * 3;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PA3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PA3<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 3;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 3)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PA3<Output<PushPull>> {
|
||
|
|
let offset = 2 * 3;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 3)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PA3<Output<PushPull>> {
|
||
|
|
let offset = 2 * 3;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 3)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 3)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PA3<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 3;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PA3<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 3;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PA3<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 3;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PA3<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 3,
|
||
|
|
port: GPIOA::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PA3<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_set_low(3) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PA3<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).set_high(3) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).set_low(3) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PA3<Output<MODE>> {}
|
||
|
|
impl InputPin for PA3<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_low(3) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PA3<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 3,
|
||
|
|
port: GPIOA::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PA3<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_low(3) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PA4<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PA4<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PA4<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(4, 0);
|
||
|
|
PA4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PA4<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(4, 1);
|
||
|
|
PA4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PA4<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(4, 2);
|
||
|
|
PA4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PA4<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(4, 3);
|
||
|
|
PA4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PA4<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(4, 4);
|
||
|
|
PA4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PA4<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(4, 5);
|
||
|
|
PA4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PA4<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(4, 6);
|
||
|
|
PA4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PA4<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(4, 7);
|
||
|
|
PA4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PA4<Input<Floating>> {
|
||
|
|
let offset = 2 * 4;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PA4<Input<PullDown>> {
|
||
|
|
let offset = 2 * 4;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PA4<Input<PullUp>> {
|
||
|
|
let offset = 2 * 4;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PA4<Analog> {
|
||
|
|
let offset = 2 * 4;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PA4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PA4<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 4;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 4)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PA4<Output<PushPull>> {
|
||
|
|
let offset = 2 * 4;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 4)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PA4<Output<PushPull>> {
|
||
|
|
let offset = 2 * 4;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 4)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 4)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PA4<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 4;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PA4<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 4;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PA4<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 4;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PA4<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 4,
|
||
|
|
port: GPIOA::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PA4<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_set_low(4) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PA4<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).set_high(4) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).set_low(4) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PA4<Output<MODE>> {}
|
||
|
|
impl InputPin for PA4<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_low(4) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PA4<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 4,
|
||
|
|
port: GPIOA::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PA4<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_low(4) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PA5<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PA5<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PA5<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(5, 0);
|
||
|
|
PA5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PA5<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(5, 1);
|
||
|
|
PA5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PA5<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(5, 2);
|
||
|
|
PA5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PA5<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(5, 3);
|
||
|
|
PA5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PA5<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(5, 4);
|
||
|
|
PA5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PA5<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(5, 5);
|
||
|
|
PA5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PA5<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(5, 6);
|
||
|
|
PA5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PA5<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(5, 7);
|
||
|
|
PA5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PA5<Input<Floating>> {
|
||
|
|
let offset = 2 * 5;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PA5<Input<PullDown>> {
|
||
|
|
let offset = 2 * 5;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PA5<Input<PullUp>> {
|
||
|
|
let offset = 2 * 5;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PA5<Analog> {
|
||
|
|
let offset = 2 * 5;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PA5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PA5<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 5;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 5)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PA5<Output<PushPull>> {
|
||
|
|
let offset = 2 * 5;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 5)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PA5<Output<PushPull>> {
|
||
|
|
let offset = 2 * 5;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 5)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 5)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PA5<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 5;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PA5<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 5;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PA5<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 5;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PA5<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 5,
|
||
|
|
port: GPIOA::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PA5<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_set_low(5) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PA5<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).set_high(5) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).set_low(5) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PA5<Output<MODE>> {}
|
||
|
|
impl InputPin for PA5<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_low(5) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PA5<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 5,
|
||
|
|
port: GPIOA::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PA5<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_low(5) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PA6<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PA6<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PA6<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(6, 0);
|
||
|
|
PA6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PA6<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(6, 1);
|
||
|
|
PA6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PA6<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(6, 2);
|
||
|
|
PA6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PA6<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(6, 3);
|
||
|
|
PA6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PA6<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(6, 4);
|
||
|
|
PA6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PA6<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(6, 5);
|
||
|
|
PA6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PA6<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(6, 6);
|
||
|
|
PA6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PA6<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(6, 7);
|
||
|
|
PA6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PA6<Input<Floating>> {
|
||
|
|
let offset = 2 * 6;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PA6<Input<PullDown>> {
|
||
|
|
let offset = 2 * 6;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PA6<Input<PullUp>> {
|
||
|
|
let offset = 2 * 6;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PA6<Analog> {
|
||
|
|
let offset = 2 * 6;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PA6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PA6<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 6;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 6)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PA6<Output<PushPull>> {
|
||
|
|
let offset = 2 * 6;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 6)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PA6<Output<PushPull>> {
|
||
|
|
let offset = 2 * 6;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 6)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 6)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PA6<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 6;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PA6<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 6;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PA6<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 6;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PA6<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 6,
|
||
|
|
port: GPIOA::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PA6<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_set_low(6) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PA6<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).set_high(6) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).set_low(6) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PA6<Output<MODE>> {}
|
||
|
|
impl InputPin for PA6<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_low(6) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PA6<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 6,
|
||
|
|
port: GPIOA::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PA6<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_low(6) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PA7<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PA7<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PA7<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(7, 0);
|
||
|
|
PA7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PA7<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(7, 1);
|
||
|
|
PA7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PA7<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(7, 2);
|
||
|
|
PA7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PA7<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(7, 3);
|
||
|
|
PA7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PA7<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(7, 4);
|
||
|
|
PA7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PA7<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(7, 5);
|
||
|
|
PA7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PA7<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(7, 6);
|
||
|
|
PA7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PA7<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(7, 7);
|
||
|
|
PA7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PA7<Input<Floating>> {
|
||
|
|
let offset = 2 * 7;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PA7<Input<PullDown>> {
|
||
|
|
let offset = 2 * 7;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PA7<Input<PullUp>> {
|
||
|
|
let offset = 2 * 7;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PA7<Analog> {
|
||
|
|
let offset = 2 * 7;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PA7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PA7<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 7;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 7)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PA7<Output<PushPull>> {
|
||
|
|
let offset = 2 * 7;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 7)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PA7<Output<PushPull>> {
|
||
|
|
let offset = 2 * 7;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 7)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 7)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PA7<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 7;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PA7<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 7;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PA7<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 7;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PA7<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 7,
|
||
|
|
port: GPIOA::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PA7<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_set_low(7) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PA7<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).set_high(7) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).set_low(7) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PA7<Output<MODE>> {}
|
||
|
|
impl InputPin for PA7<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_low(7) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PA7<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 7,
|
||
|
|
port: GPIOA::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PA7<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_low(7) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PA8<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PA8<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PA8<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(8, 0);
|
||
|
|
PA8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PA8<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(8, 1);
|
||
|
|
PA8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PA8<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(8, 2);
|
||
|
|
PA8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PA8<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(8, 3);
|
||
|
|
PA8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PA8<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(8, 4);
|
||
|
|
PA8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PA8<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(8, 5);
|
||
|
|
PA8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PA8<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(8, 6);
|
||
|
|
PA8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PA8<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(8, 7);
|
||
|
|
PA8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PA8<Input<Floating>> {
|
||
|
|
let offset = 2 * 8;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PA8<Input<PullDown>> {
|
||
|
|
let offset = 2 * 8;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PA8<Input<PullUp>> {
|
||
|
|
let offset = 2 * 8;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PA8<Analog> {
|
||
|
|
let offset = 2 * 8;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PA8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PA8<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 8;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 8)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PA8<Output<PushPull>> {
|
||
|
|
let offset = 2 * 8;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 8)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PA8<Output<PushPull>> {
|
||
|
|
let offset = 2 * 8;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 8)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 8)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PA8<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 8;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PA8<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 8;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PA8<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 8;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PA8<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 8,
|
||
|
|
port: GPIOA::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PA8<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_set_low(8) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PA8<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).set_high(8) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).set_low(8) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PA8<Output<MODE>> {}
|
||
|
|
impl InputPin for PA8<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_low(8) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PA8<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 8,
|
||
|
|
port: GPIOA::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PA8<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_low(8) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PA9<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PA9<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PA9<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(9, 0);
|
||
|
|
PA9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PA9<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(9, 1);
|
||
|
|
PA9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PA9<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(9, 2);
|
||
|
|
PA9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PA9<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(9, 3);
|
||
|
|
PA9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PA9<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(9, 4);
|
||
|
|
PA9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PA9<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(9, 5);
|
||
|
|
PA9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PA9<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(9, 6);
|
||
|
|
PA9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PA9<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(9, 7);
|
||
|
|
PA9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PA9<Input<Floating>> {
|
||
|
|
let offset = 2 * 9;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PA9<Input<PullDown>> {
|
||
|
|
let offset = 2 * 9;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PA9<Input<PullUp>> {
|
||
|
|
let offset = 2 * 9;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PA9<Analog> {
|
||
|
|
let offset = 2 * 9;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PA9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PA9<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 9;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 9)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PA9<Output<PushPull>> {
|
||
|
|
let offset = 2 * 9;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 9)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PA9<Output<PushPull>> {
|
||
|
|
let offset = 2 * 9;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 9)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 9)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PA9<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 9;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PA9<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 9;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PA9<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 9;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PA9<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 9,
|
||
|
|
port: GPIOA::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PA9<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_set_low(9) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PA9<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).set_high(9) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).set_low(9) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PA9<Output<MODE>> {}
|
||
|
|
impl InputPin for PA9<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_low(9) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PA9<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 9,
|
||
|
|
port: GPIOA::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PA9<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_low(9) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PA10<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PA10<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PA10<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(10, 0);
|
||
|
|
PA10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PA10<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(10, 1);
|
||
|
|
PA10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PA10<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(10, 2);
|
||
|
|
PA10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PA10<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(10, 3);
|
||
|
|
PA10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PA10<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(10, 4);
|
||
|
|
PA10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PA10<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(10, 5);
|
||
|
|
PA10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PA10<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(10, 6);
|
||
|
|
PA10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PA10<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(10, 7);
|
||
|
|
PA10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PA10<Input<Floating>> {
|
||
|
|
let offset = 2 * 10;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PA10<Input<PullDown>> {
|
||
|
|
let offset = 2 * 10;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PA10<Input<PullUp>> {
|
||
|
|
let offset = 2 * 10;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PA10<Analog> {
|
||
|
|
let offset = 2 * 10;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PA10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PA10<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 10;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 10)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PA10<Output<PushPull>> {
|
||
|
|
let offset = 2 * 10;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 10)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PA10<Output<PushPull>> {
|
||
|
|
let offset = 2 * 10;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 10)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 10)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PA10<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 10;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PA10<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 10;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PA10<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 10;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PA10<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 10,
|
||
|
|
port: GPIOA::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PA10<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_set_low(10) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PA10<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).set_high(10) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).set_low(10) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PA10<Output<MODE>> {}
|
||
|
|
impl InputPin for PA10<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_low(10) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PA10<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 10,
|
||
|
|
port: GPIOA::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PA10<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_low(10) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PA11<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PA11<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PA11<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(11, 0);
|
||
|
|
PA11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PA11<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(11, 1);
|
||
|
|
PA11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PA11<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(11, 2);
|
||
|
|
PA11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PA11<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(11, 3);
|
||
|
|
PA11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PA11<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(11, 4);
|
||
|
|
PA11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PA11<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(11, 5);
|
||
|
|
PA11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PA11<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(11, 6);
|
||
|
|
PA11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PA11<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(11, 7);
|
||
|
|
PA11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PA11<Input<Floating>> {
|
||
|
|
let offset = 2 * 11;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PA11<Input<PullDown>> {
|
||
|
|
let offset = 2 * 11;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PA11<Input<PullUp>> {
|
||
|
|
let offset = 2 * 11;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PA11<Analog> {
|
||
|
|
let offset = 2 * 11;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PA11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PA11<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 11;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 11)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PA11<Output<PushPull>> {
|
||
|
|
let offset = 2 * 11;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 11)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PA11<Output<PushPull>> {
|
||
|
|
let offset = 2 * 11;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 11)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 11)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PA11<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 11;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PA11<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 11;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PA11<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 11;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PA11<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 11,
|
||
|
|
port: GPIOA::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PA11<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_set_low(11) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PA11<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).set_high(11) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).set_low(11) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PA11<Output<MODE>> {}
|
||
|
|
impl InputPin for PA11<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_low(11) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PA11<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 11,
|
||
|
|
port: GPIOA::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PA11<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_low(11) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PA12<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PA12<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PA12<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(12, 0);
|
||
|
|
PA12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PA12<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(12, 1);
|
||
|
|
PA12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PA12<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(12, 2);
|
||
|
|
PA12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PA12<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(12, 3);
|
||
|
|
PA12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PA12<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(12, 4);
|
||
|
|
PA12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PA12<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(12, 5);
|
||
|
|
PA12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PA12<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(12, 6);
|
||
|
|
PA12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PA12<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(12, 7);
|
||
|
|
PA12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PA12<Input<Floating>> {
|
||
|
|
let offset = 2 * 12;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PA12<Input<PullDown>> {
|
||
|
|
let offset = 2 * 12;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PA12<Input<PullUp>> {
|
||
|
|
let offset = 2 * 12;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PA12<Analog> {
|
||
|
|
let offset = 2 * 12;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PA12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PA12<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 12;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 12)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PA12<Output<PushPull>> {
|
||
|
|
let offset = 2 * 12;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 12)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PA12<Output<PushPull>> {
|
||
|
|
let offset = 2 * 12;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 12)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 12)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PA12<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 12;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PA12<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 12;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PA12<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 12;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PA12<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 12,
|
||
|
|
port: GPIOA::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PA12<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_set_low(12) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PA12<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).set_high(12) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).set_low(12) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PA12<Output<MODE>> {}
|
||
|
|
impl InputPin for PA12<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_low(12) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PA12<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 12,
|
||
|
|
port: GPIOA::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PA12<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_low(12) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PA13<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PA13<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PA13<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(13, 0);
|
||
|
|
PA13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PA13<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(13, 1);
|
||
|
|
PA13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PA13<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(13, 2);
|
||
|
|
PA13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PA13<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(13, 3);
|
||
|
|
PA13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PA13<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(13, 4);
|
||
|
|
PA13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PA13<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(13, 5);
|
||
|
|
PA13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PA13<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(13, 6);
|
||
|
|
PA13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PA13<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(13, 7);
|
||
|
|
PA13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PA13<Input<Floating>> {
|
||
|
|
let offset = 2 * 13;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PA13<Input<PullDown>> {
|
||
|
|
let offset = 2 * 13;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PA13<Input<PullUp>> {
|
||
|
|
let offset = 2 * 13;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PA13<Analog> {
|
||
|
|
let offset = 2 * 13;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PA13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PA13<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 13;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 13)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PA13<Output<PushPull>> {
|
||
|
|
let offset = 2 * 13;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 13)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PA13<Output<PushPull>> {
|
||
|
|
let offset = 2 * 13;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 13)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 13)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PA13<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 13;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PA13<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 13;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PA13<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 13;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PA13<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 13,
|
||
|
|
port: GPIOA::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PA13<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_set_low(13) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PA13<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).set_high(13) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).set_low(13) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PA13<Output<MODE>> {}
|
||
|
|
impl InputPin for PA13<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_low(13) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PA13<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 13,
|
||
|
|
port: GPIOA::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PA13<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_low(13) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PA14<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PA14<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PA14<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(14, 0);
|
||
|
|
PA14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PA14<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(14, 1);
|
||
|
|
PA14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PA14<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(14, 2);
|
||
|
|
PA14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PA14<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(14, 3);
|
||
|
|
PA14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PA14<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(14, 4);
|
||
|
|
PA14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PA14<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(14, 5);
|
||
|
|
PA14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PA14<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(14, 6);
|
||
|
|
PA14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PA14<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(14, 7);
|
||
|
|
PA14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PA14<Input<Floating>> {
|
||
|
|
let offset = 2 * 14;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PA14<Input<PullDown>> {
|
||
|
|
let offset = 2 * 14;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PA14<Input<PullUp>> {
|
||
|
|
let offset = 2 * 14;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PA14<Analog> {
|
||
|
|
let offset = 2 * 14;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PA14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PA14<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 14;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 14)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PA14<Output<PushPull>> {
|
||
|
|
let offset = 2 * 14;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 14)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PA14<Output<PushPull>> {
|
||
|
|
let offset = 2 * 14;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 14)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 14)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PA14<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 14;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PA14<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 14;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PA14<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 14;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PA14<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 14,
|
||
|
|
port: GPIOA::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PA14<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_set_low(14) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PA14<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).set_high(14) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).set_low(14) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PA14<Output<MODE>> {}
|
||
|
|
impl InputPin for PA14<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_low(14) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PA14<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 14,
|
||
|
|
port: GPIOA::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PA14<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_low(14) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PA15<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PA15<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PA15<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(15, 0);
|
||
|
|
PA15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PA15<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(15, 1);
|
||
|
|
PA15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PA15<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(15, 2);
|
||
|
|
PA15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PA15<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(15, 3);
|
||
|
|
PA15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PA15<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(15, 4);
|
||
|
|
PA15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PA15<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(15, 5);
|
||
|
|
PA15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PA15<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(15, 6);
|
||
|
|
PA15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PA15<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(15, 7);
|
||
|
|
PA15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PA15<Input<Floating>> {
|
||
|
|
let offset = 2 * 15;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PA15<Input<PullDown>> {
|
||
|
|
let offset = 2 * 15;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PA15<Input<PullUp>> {
|
||
|
|
let offset = 2 * 15;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PA15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PA15<Analog> {
|
||
|
|
let offset = 2 * 15;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PA15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PA15<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 15;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 15)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PA15<Output<PushPull>> {
|
||
|
|
let offset = 2 * 15;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 15)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PA15<Output<PushPull>> {
|
||
|
|
let offset = 2 * 15;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 15)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 15)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PA15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PA15<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 15;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PA15<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 15;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PA15<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 15;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOA::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PA15<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 15,
|
||
|
|
port: GPIOA::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PA15<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_set_low(15) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PA15<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).set_high(15) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).set_low(15) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PA15<Output<MODE>> {}
|
||
|
|
impl InputPin for PA15<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_low(15) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PA15<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 15,
|
||
|
|
port: GPIOA::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PA15<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOA::ptr()).is_low(15) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// GPIO
|
||
|
|
#[cfg(any(feature = "device-selected"))]
|
||
|
|
pub mod gpiob {
|
||
|
|
use core::marker::PhantomData;
|
||
|
|
use core::convert::Infallible;
|
||
|
|
use embedded_hal::digital::v2::{InputPin, OutputPin, StatefulOutputPin, toggleable};
|
||
|
|
use crate::{rcc::Rcc, pac::GPIOB};
|
||
|
|
use cortex_m::interrupt::CriticalSection;
|
||
|
|
use super::{
|
||
|
|
Alternate, Analog, Floating, GpioExt, Input, OpenDrain, Output, PullDown, PullUp,
|
||
|
|
PushPull, AF0, AF1, AF2, AF3, AF4, AF5, AF6, AF7, Pin, GpioRegExt,
|
||
|
|
};
|
||
|
|
/// GPIO parts
|
||
|
|
pub struct Parts {
|
||
|
|
/// Pin
|
||
|
|
pub pb0: PB0<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pb1: PB1<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pb2: PB2<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pb3: PB3<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pb4: PB4<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pb5: PB5<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pb6: PB6<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pb7: PB7<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pb8: PB8<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pb9: PB9<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pb10: PB10<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pb11: PB11<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pb12: PB12<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pb13: PB13<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pb14: PB14<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pb15: PB15<Input<Floating>>,
|
||
|
|
}
|
||
|
|
impl GpioExt for GPIOB {
|
||
|
|
type Parts = Parts;
|
||
|
|
fn split(self, rcc: &mut Rcc) -> Parts {
|
||
|
|
rcc.regs.ahbenr.modify(|_, w| w.iopben().set_bit());
|
||
|
|
Parts {
|
||
|
|
pb0: PB0 { _mode: PhantomData },
|
||
|
|
pb1: PB1 { _mode: PhantomData },
|
||
|
|
pb2: PB2 { _mode: PhantomData },
|
||
|
|
pb3: PB3 { _mode: PhantomData },
|
||
|
|
pb4: PB4 { _mode: PhantomData },
|
||
|
|
pb5: PB5 { _mode: PhantomData },
|
||
|
|
pb6: PB6 { _mode: PhantomData },
|
||
|
|
pb7: PB7 { _mode: PhantomData },
|
||
|
|
pb8: PB8 { _mode: PhantomData },
|
||
|
|
pb9: PB9 { _mode: PhantomData },
|
||
|
|
pb10: PB10 { _mode: PhantomData },
|
||
|
|
pb11: PB11 { _mode: PhantomData },
|
||
|
|
pb12: PB12 { _mode: PhantomData },
|
||
|
|
pb13: PB13 { _mode: PhantomData },
|
||
|
|
pb14: PB14 { _mode: PhantomData },
|
||
|
|
pb15: PB15 { _mode: PhantomData },
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
fn _set_alternate_mode(index: usize, mode: u32) {
|
||
|
|
let offset = 2 * index;
|
||
|
|
let offset2 = 4 * index;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
if offset2 < 32 {
|
||
|
|
reg.afrl.modify(|r, w| {
|
||
|
|
w.bits((r.bits() & !(0b1111 << offset2)) | (mode << offset2))
|
||
|
|
});
|
||
|
|
} else {
|
||
|
|
let offset2 = offset2 - 32;
|
||
|
|
reg.afrh.modify(|r, w| {
|
||
|
|
w.bits((r.bits() & !(0b1111 << offset2)) | (mode << offset2))
|
||
|
|
});
|
||
|
|
}
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PB0<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PB0<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PB0<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(0, 0);
|
||
|
|
PB0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PB0<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(0, 1);
|
||
|
|
PB0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PB0<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(0, 2);
|
||
|
|
PB0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PB0<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(0, 3);
|
||
|
|
PB0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PB0<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(0, 4);
|
||
|
|
PB0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PB0<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(0, 5);
|
||
|
|
PB0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PB0<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(0, 6);
|
||
|
|
PB0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PB0<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(0, 7);
|
||
|
|
PB0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PB0<Input<Floating>> {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PB0<Input<PullDown>> {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PB0<Input<PullUp>> {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PB0<Analog> {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PB0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PB0<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 0)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PB0<Output<PushPull>> {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 0)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PB0<Output<PushPull>> {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 0)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 0)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PB0<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PB0<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PB0<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 0;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PB0<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 0,
|
||
|
|
port: GPIOB::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PB0<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_set_low(0) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PB0<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).set_high(0) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).set_low(0) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PB0<Output<MODE>> {}
|
||
|
|
impl InputPin for PB0<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_low(0) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PB0<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 0,
|
||
|
|
port: GPIOB::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PB0<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_low(0) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PB1<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PB1<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PB1<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(1, 0);
|
||
|
|
PB1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PB1<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(1, 1);
|
||
|
|
PB1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PB1<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(1, 2);
|
||
|
|
PB1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PB1<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(1, 3);
|
||
|
|
PB1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PB1<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(1, 4);
|
||
|
|
PB1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PB1<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(1, 5);
|
||
|
|
PB1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PB1<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(1, 6);
|
||
|
|
PB1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PB1<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(1, 7);
|
||
|
|
PB1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PB1<Input<Floating>> {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PB1<Input<PullDown>> {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PB1<Input<PullUp>> {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PB1<Analog> {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PB1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PB1<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 1)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PB1<Output<PushPull>> {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 1)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PB1<Output<PushPull>> {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 1)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 1)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PB1<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PB1<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PB1<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 1;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PB1<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 1,
|
||
|
|
port: GPIOB::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PB1<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_set_low(1) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PB1<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).set_high(1) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).set_low(1) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PB1<Output<MODE>> {}
|
||
|
|
impl InputPin for PB1<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_low(1) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PB1<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 1,
|
||
|
|
port: GPIOB::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PB1<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_low(1) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PB2<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PB2<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PB2<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(2, 0);
|
||
|
|
PB2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PB2<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(2, 1);
|
||
|
|
PB2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PB2<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(2, 2);
|
||
|
|
PB2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PB2<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(2, 3);
|
||
|
|
PB2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PB2<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(2, 4);
|
||
|
|
PB2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PB2<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(2, 5);
|
||
|
|
PB2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PB2<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(2, 6);
|
||
|
|
PB2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PB2<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(2, 7);
|
||
|
|
PB2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PB2<Input<Floating>> {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PB2<Input<PullDown>> {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PB2<Input<PullUp>> {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PB2<Analog> {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PB2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PB2<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 2)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PB2<Output<PushPull>> {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 2)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PB2<Output<PushPull>> {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 2)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 2)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PB2<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PB2<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PB2<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 2;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PB2<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 2,
|
||
|
|
port: GPIOB::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PB2<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_set_low(2) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PB2<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).set_high(2) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).set_low(2) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PB2<Output<MODE>> {}
|
||
|
|
impl InputPin for PB2<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_low(2) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PB2<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 2,
|
||
|
|
port: GPIOB::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PB2<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_low(2) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PB3<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PB3<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PB3<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(3, 0);
|
||
|
|
PB3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PB3<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(3, 1);
|
||
|
|
PB3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PB3<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(3, 2);
|
||
|
|
PB3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PB3<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(3, 3);
|
||
|
|
PB3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PB3<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(3, 4);
|
||
|
|
PB3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PB3<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(3, 5);
|
||
|
|
PB3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PB3<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(3, 6);
|
||
|
|
PB3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PB3<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(3, 7);
|
||
|
|
PB3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PB3<Input<Floating>> {
|
||
|
|
let offset = 2 * 3;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PB3<Input<PullDown>> {
|
||
|
|
let offset = 2 * 3;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PB3<Input<PullUp>> {
|
||
|
|
let offset = 2 * 3;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PB3<Analog> {
|
||
|
|
let offset = 2 * 3;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PB3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PB3<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 3;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 3)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PB3<Output<PushPull>> {
|
||
|
|
let offset = 2 * 3;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 3)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PB3<Output<PushPull>> {
|
||
|
|
let offset = 2 * 3;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 3)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 3)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PB3<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 3;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PB3<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 3;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PB3<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 3;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PB3<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 3,
|
||
|
|
port: GPIOB::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PB3<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_set_low(3) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PB3<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).set_high(3) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).set_low(3) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PB3<Output<MODE>> {}
|
||
|
|
impl InputPin for PB3<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_low(3) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PB3<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 3,
|
||
|
|
port: GPIOB::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PB3<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_low(3) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PB4<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PB4<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PB4<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(4, 0);
|
||
|
|
PB4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PB4<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(4, 1);
|
||
|
|
PB4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PB4<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(4, 2);
|
||
|
|
PB4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PB4<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(4, 3);
|
||
|
|
PB4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PB4<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(4, 4);
|
||
|
|
PB4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PB4<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(4, 5);
|
||
|
|
PB4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PB4<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(4, 6);
|
||
|
|
PB4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PB4<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(4, 7);
|
||
|
|
PB4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PB4<Input<Floating>> {
|
||
|
|
let offset = 2 * 4;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PB4<Input<PullDown>> {
|
||
|
|
let offset = 2 * 4;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PB4<Input<PullUp>> {
|
||
|
|
let offset = 2 * 4;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PB4<Analog> {
|
||
|
|
let offset = 2 * 4;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PB4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PB4<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 4;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 4)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PB4<Output<PushPull>> {
|
||
|
|
let offset = 2 * 4;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 4)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PB4<Output<PushPull>> {
|
||
|
|
let offset = 2 * 4;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 4)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 4)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PB4<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 4;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PB4<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 4;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PB4<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 4;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PB4<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 4,
|
||
|
|
port: GPIOB::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PB4<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_set_low(4) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PB4<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).set_high(4) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).set_low(4) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PB4<Output<MODE>> {}
|
||
|
|
impl InputPin for PB4<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_low(4) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PB4<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 4,
|
||
|
|
port: GPIOB::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PB4<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_low(4) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PB5<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PB5<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PB5<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(5, 0);
|
||
|
|
PB5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PB5<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(5, 1);
|
||
|
|
PB5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PB5<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(5, 2);
|
||
|
|
PB5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PB5<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(5, 3);
|
||
|
|
PB5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PB5<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(5, 4);
|
||
|
|
PB5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PB5<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(5, 5);
|
||
|
|
PB5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PB5<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(5, 6);
|
||
|
|
PB5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PB5<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(5, 7);
|
||
|
|
PB5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PB5<Input<Floating>> {
|
||
|
|
let offset = 2 * 5;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PB5<Input<PullDown>> {
|
||
|
|
let offset = 2 * 5;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PB5<Input<PullUp>> {
|
||
|
|
let offset = 2 * 5;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PB5<Analog> {
|
||
|
|
let offset = 2 * 5;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PB5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PB5<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 5;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 5)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PB5<Output<PushPull>> {
|
||
|
|
let offset = 2 * 5;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 5)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PB5<Output<PushPull>> {
|
||
|
|
let offset = 2 * 5;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 5)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 5)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PB5<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 5;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PB5<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 5;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PB5<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 5;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PB5<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 5,
|
||
|
|
port: GPIOB::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PB5<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_set_low(5) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PB5<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).set_high(5) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).set_low(5) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PB5<Output<MODE>> {}
|
||
|
|
impl InputPin for PB5<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_low(5) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PB5<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 5,
|
||
|
|
port: GPIOB::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PB5<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_low(5) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PB6<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PB6<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PB6<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(6, 0);
|
||
|
|
PB6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PB6<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(6, 1);
|
||
|
|
PB6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PB6<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(6, 2);
|
||
|
|
PB6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PB6<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(6, 3);
|
||
|
|
PB6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PB6<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(6, 4);
|
||
|
|
PB6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PB6<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(6, 5);
|
||
|
|
PB6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PB6<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(6, 6);
|
||
|
|
PB6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PB6<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(6, 7);
|
||
|
|
PB6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PB6<Input<Floating>> {
|
||
|
|
let offset = 2 * 6;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PB6<Input<PullDown>> {
|
||
|
|
let offset = 2 * 6;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PB6<Input<PullUp>> {
|
||
|
|
let offset = 2 * 6;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PB6<Analog> {
|
||
|
|
let offset = 2 * 6;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PB6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PB6<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 6;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 6)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PB6<Output<PushPull>> {
|
||
|
|
let offset = 2 * 6;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 6)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PB6<Output<PushPull>> {
|
||
|
|
let offset = 2 * 6;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 6)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 6)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PB6<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 6;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PB6<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 6;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PB6<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 6;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PB6<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 6,
|
||
|
|
port: GPIOB::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PB6<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_set_low(6) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PB6<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).set_high(6) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).set_low(6) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PB6<Output<MODE>> {}
|
||
|
|
impl InputPin for PB6<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_low(6) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PB6<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 6,
|
||
|
|
port: GPIOB::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PB6<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_low(6) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PB7<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PB7<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PB7<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(7, 0);
|
||
|
|
PB7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PB7<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(7, 1);
|
||
|
|
PB7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PB7<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(7, 2);
|
||
|
|
PB7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PB7<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(7, 3);
|
||
|
|
PB7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PB7<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(7, 4);
|
||
|
|
PB7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PB7<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(7, 5);
|
||
|
|
PB7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PB7<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(7, 6);
|
||
|
|
PB7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PB7<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(7, 7);
|
||
|
|
PB7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PB7<Input<Floating>> {
|
||
|
|
let offset = 2 * 7;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PB7<Input<PullDown>> {
|
||
|
|
let offset = 2 * 7;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PB7<Input<PullUp>> {
|
||
|
|
let offset = 2 * 7;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PB7<Analog> {
|
||
|
|
let offset = 2 * 7;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PB7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PB7<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 7;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 7)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PB7<Output<PushPull>> {
|
||
|
|
let offset = 2 * 7;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 7)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PB7<Output<PushPull>> {
|
||
|
|
let offset = 2 * 7;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 7)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 7)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PB7<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 7;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PB7<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 7;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PB7<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 7;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PB7<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 7,
|
||
|
|
port: GPIOB::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PB7<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_set_low(7) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PB7<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).set_high(7) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).set_low(7) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PB7<Output<MODE>> {}
|
||
|
|
impl InputPin for PB7<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_low(7) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PB7<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 7,
|
||
|
|
port: GPIOB::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PB7<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_low(7) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PB8<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PB8<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PB8<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(8, 0);
|
||
|
|
PB8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PB8<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(8, 1);
|
||
|
|
PB8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PB8<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(8, 2);
|
||
|
|
PB8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PB8<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(8, 3);
|
||
|
|
PB8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PB8<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(8, 4);
|
||
|
|
PB8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PB8<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(8, 5);
|
||
|
|
PB8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PB8<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(8, 6);
|
||
|
|
PB8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PB8<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(8, 7);
|
||
|
|
PB8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PB8<Input<Floating>> {
|
||
|
|
let offset = 2 * 8;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PB8<Input<PullDown>> {
|
||
|
|
let offset = 2 * 8;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PB8<Input<PullUp>> {
|
||
|
|
let offset = 2 * 8;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PB8<Analog> {
|
||
|
|
let offset = 2 * 8;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PB8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PB8<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 8;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 8)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PB8<Output<PushPull>> {
|
||
|
|
let offset = 2 * 8;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 8)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PB8<Output<PushPull>> {
|
||
|
|
let offset = 2 * 8;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 8)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 8)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PB8<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 8;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PB8<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 8;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PB8<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 8;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PB8<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 8,
|
||
|
|
port: GPIOB::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PB8<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_set_low(8) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PB8<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).set_high(8) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).set_low(8) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PB8<Output<MODE>> {}
|
||
|
|
impl InputPin for PB8<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_low(8) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PB8<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 8,
|
||
|
|
port: GPIOB::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PB8<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_low(8) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PB9<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PB9<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PB9<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(9, 0);
|
||
|
|
PB9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PB9<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(9, 1);
|
||
|
|
PB9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PB9<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(9, 2);
|
||
|
|
PB9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PB9<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(9, 3);
|
||
|
|
PB9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PB9<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(9, 4);
|
||
|
|
PB9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PB9<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(9, 5);
|
||
|
|
PB9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PB9<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(9, 6);
|
||
|
|
PB9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PB9<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(9, 7);
|
||
|
|
PB9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PB9<Input<Floating>> {
|
||
|
|
let offset = 2 * 9;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PB9<Input<PullDown>> {
|
||
|
|
let offset = 2 * 9;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PB9<Input<PullUp>> {
|
||
|
|
let offset = 2 * 9;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PB9<Analog> {
|
||
|
|
let offset = 2 * 9;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PB9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PB9<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 9;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 9)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PB9<Output<PushPull>> {
|
||
|
|
let offset = 2 * 9;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 9)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PB9<Output<PushPull>> {
|
||
|
|
let offset = 2 * 9;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 9)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 9)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PB9<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 9;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PB9<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 9;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PB9<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 9;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PB9<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 9,
|
||
|
|
port: GPIOB::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PB9<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_set_low(9) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PB9<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).set_high(9) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).set_low(9) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PB9<Output<MODE>> {}
|
||
|
|
impl InputPin for PB9<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_low(9) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PB9<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 9,
|
||
|
|
port: GPIOB::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PB9<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_low(9) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PB10<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PB10<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PB10<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(10, 0);
|
||
|
|
PB10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PB10<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(10, 1);
|
||
|
|
PB10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PB10<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(10, 2);
|
||
|
|
PB10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PB10<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(10, 3);
|
||
|
|
PB10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PB10<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(10, 4);
|
||
|
|
PB10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PB10<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(10, 5);
|
||
|
|
PB10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PB10<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(10, 6);
|
||
|
|
PB10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PB10<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(10, 7);
|
||
|
|
PB10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PB10<Input<Floating>> {
|
||
|
|
let offset = 2 * 10;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PB10<Input<PullDown>> {
|
||
|
|
let offset = 2 * 10;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PB10<Input<PullUp>> {
|
||
|
|
let offset = 2 * 10;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PB10<Analog> {
|
||
|
|
let offset = 2 * 10;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PB10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PB10<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 10;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 10)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PB10<Output<PushPull>> {
|
||
|
|
let offset = 2 * 10;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 10)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PB10<Output<PushPull>> {
|
||
|
|
let offset = 2 * 10;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 10)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 10)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PB10<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 10;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PB10<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 10;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PB10<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 10;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PB10<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 10,
|
||
|
|
port: GPIOB::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PB10<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_set_low(10) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PB10<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).set_high(10) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).set_low(10) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PB10<Output<MODE>> {}
|
||
|
|
impl InputPin for PB10<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_low(10) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PB10<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 10,
|
||
|
|
port: GPIOB::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PB10<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_low(10) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PB11<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PB11<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PB11<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(11, 0);
|
||
|
|
PB11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PB11<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(11, 1);
|
||
|
|
PB11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PB11<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(11, 2);
|
||
|
|
PB11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PB11<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(11, 3);
|
||
|
|
PB11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PB11<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(11, 4);
|
||
|
|
PB11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PB11<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(11, 5);
|
||
|
|
PB11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PB11<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(11, 6);
|
||
|
|
PB11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PB11<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(11, 7);
|
||
|
|
PB11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PB11<Input<Floating>> {
|
||
|
|
let offset = 2 * 11;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PB11<Input<PullDown>> {
|
||
|
|
let offset = 2 * 11;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PB11<Input<PullUp>> {
|
||
|
|
let offset = 2 * 11;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PB11<Analog> {
|
||
|
|
let offset = 2 * 11;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PB11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PB11<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 11;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 11)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PB11<Output<PushPull>> {
|
||
|
|
let offset = 2 * 11;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 11)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PB11<Output<PushPull>> {
|
||
|
|
let offset = 2 * 11;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 11)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 11)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PB11<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 11;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PB11<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 11;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PB11<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 11;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PB11<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 11,
|
||
|
|
port: GPIOB::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PB11<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_set_low(11) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PB11<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).set_high(11) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).set_low(11) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PB11<Output<MODE>> {}
|
||
|
|
impl InputPin for PB11<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_low(11) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PB11<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 11,
|
||
|
|
port: GPIOB::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PB11<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_low(11) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PB12<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PB12<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PB12<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(12, 0);
|
||
|
|
PB12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PB12<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(12, 1);
|
||
|
|
PB12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PB12<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(12, 2);
|
||
|
|
PB12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PB12<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(12, 3);
|
||
|
|
PB12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PB12<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(12, 4);
|
||
|
|
PB12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PB12<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(12, 5);
|
||
|
|
PB12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PB12<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(12, 6);
|
||
|
|
PB12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PB12<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(12, 7);
|
||
|
|
PB12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PB12<Input<Floating>> {
|
||
|
|
let offset = 2 * 12;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PB12<Input<PullDown>> {
|
||
|
|
let offset = 2 * 12;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PB12<Input<PullUp>> {
|
||
|
|
let offset = 2 * 12;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PB12<Analog> {
|
||
|
|
let offset = 2 * 12;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PB12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PB12<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 12;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 12)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PB12<Output<PushPull>> {
|
||
|
|
let offset = 2 * 12;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 12)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PB12<Output<PushPull>> {
|
||
|
|
let offset = 2 * 12;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 12)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 12)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PB12<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 12;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PB12<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 12;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PB12<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 12;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PB12<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 12,
|
||
|
|
port: GPIOB::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PB12<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_set_low(12) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PB12<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).set_high(12) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).set_low(12) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PB12<Output<MODE>> {}
|
||
|
|
impl InputPin for PB12<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_low(12) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PB12<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 12,
|
||
|
|
port: GPIOB::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PB12<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_low(12) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PB13<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PB13<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PB13<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(13, 0);
|
||
|
|
PB13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PB13<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(13, 1);
|
||
|
|
PB13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PB13<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(13, 2);
|
||
|
|
PB13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PB13<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(13, 3);
|
||
|
|
PB13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PB13<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(13, 4);
|
||
|
|
PB13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PB13<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(13, 5);
|
||
|
|
PB13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PB13<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(13, 6);
|
||
|
|
PB13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PB13<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(13, 7);
|
||
|
|
PB13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PB13<Input<Floating>> {
|
||
|
|
let offset = 2 * 13;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PB13<Input<PullDown>> {
|
||
|
|
let offset = 2 * 13;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PB13<Input<PullUp>> {
|
||
|
|
let offset = 2 * 13;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PB13<Analog> {
|
||
|
|
let offset = 2 * 13;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PB13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PB13<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 13;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 13)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PB13<Output<PushPull>> {
|
||
|
|
let offset = 2 * 13;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 13)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PB13<Output<PushPull>> {
|
||
|
|
let offset = 2 * 13;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 13)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 13)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PB13<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 13;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PB13<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 13;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PB13<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 13;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PB13<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 13,
|
||
|
|
port: GPIOB::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PB13<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_set_low(13) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PB13<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).set_high(13) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).set_low(13) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PB13<Output<MODE>> {}
|
||
|
|
impl InputPin for PB13<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_low(13) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PB13<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 13,
|
||
|
|
port: GPIOB::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PB13<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_low(13) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PB14<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PB14<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PB14<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(14, 0);
|
||
|
|
PB14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PB14<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(14, 1);
|
||
|
|
PB14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PB14<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(14, 2);
|
||
|
|
PB14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PB14<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(14, 3);
|
||
|
|
PB14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PB14<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(14, 4);
|
||
|
|
PB14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PB14<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(14, 5);
|
||
|
|
PB14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PB14<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(14, 6);
|
||
|
|
PB14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PB14<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(14, 7);
|
||
|
|
PB14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PB14<Input<Floating>> {
|
||
|
|
let offset = 2 * 14;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PB14<Input<PullDown>> {
|
||
|
|
let offset = 2 * 14;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PB14<Input<PullUp>> {
|
||
|
|
let offset = 2 * 14;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PB14<Analog> {
|
||
|
|
let offset = 2 * 14;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PB14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PB14<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 14;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 14)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PB14<Output<PushPull>> {
|
||
|
|
let offset = 2 * 14;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 14)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PB14<Output<PushPull>> {
|
||
|
|
let offset = 2 * 14;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 14)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 14)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PB14<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 14;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PB14<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 14;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PB14<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 14;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PB14<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 14,
|
||
|
|
port: GPIOB::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PB14<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_set_low(14) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PB14<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).set_high(14) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).set_low(14) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PB14<Output<MODE>> {}
|
||
|
|
impl InputPin for PB14<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_low(14) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PB14<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 14,
|
||
|
|
port: GPIOB::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PB14<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_low(14) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PB15<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PB15<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PB15<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(15, 0);
|
||
|
|
PB15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PB15<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(15, 1);
|
||
|
|
PB15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PB15<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(15, 2);
|
||
|
|
PB15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PB15<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(15, 3);
|
||
|
|
PB15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PB15<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(15, 4);
|
||
|
|
PB15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PB15<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(15, 5);
|
||
|
|
PB15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PB15<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(15, 6);
|
||
|
|
PB15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PB15<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(15, 7);
|
||
|
|
PB15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PB15<Input<Floating>> {
|
||
|
|
let offset = 2 * 15;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PB15<Input<PullDown>> {
|
||
|
|
let offset = 2 * 15;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PB15<Input<PullUp>> {
|
||
|
|
let offset = 2 * 15;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PB15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PB15<Analog> {
|
||
|
|
let offset = 2 * 15;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PB15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PB15<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 15;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 15)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PB15<Output<PushPull>> {
|
||
|
|
let offset = 2 * 15;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 15)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PB15<Output<PushPull>> {
|
||
|
|
let offset = 2 * 15;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 15)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 15)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PB15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PB15<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 15;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PB15<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 15;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PB15<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 15;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOB::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PB15<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 15,
|
||
|
|
port: GPIOB::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PB15<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_set_low(15) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PB15<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).set_high(15) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).set_low(15) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PB15<Output<MODE>> {}
|
||
|
|
impl InputPin for PB15<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_low(15) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PB15<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 15,
|
||
|
|
port: GPIOB::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PB15<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOB::ptr()).is_low(15) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// GPIO
|
||
|
|
#[cfg(any(
|
||
|
|
feature = "stm32f030",
|
||
|
|
feature = "stm32f051",
|
||
|
|
feature = "stm32f058",
|
||
|
|
feature = "stm32f070",
|
||
|
|
feature = "stm32f071",
|
||
|
|
feature = "stm32f072",
|
||
|
|
feature = "stm32f078",
|
||
|
|
feature = "stm32f091",
|
||
|
|
feature = "stm32f098"
|
||
|
|
))]
|
||
|
|
pub mod gpioc {
|
||
|
|
use core::marker::PhantomData;
|
||
|
|
use core::convert::Infallible;
|
||
|
|
use embedded_hal::digital::v2::{InputPin, OutputPin, StatefulOutputPin, toggleable};
|
||
|
|
use crate::{rcc::Rcc, pac::GPIOC};
|
||
|
|
use cortex_m::interrupt::CriticalSection;
|
||
|
|
use super::{
|
||
|
|
Alternate, Analog, Floating, GpioExt, Input, OpenDrain, Output, PullDown, PullUp,
|
||
|
|
PushPull, AF0, AF1, AF2, AF3, AF4, AF5, AF6, AF7, Pin, GpioRegExt,
|
||
|
|
};
|
||
|
|
/// GPIO parts
|
||
|
|
pub struct Parts {
|
||
|
|
/// Pin
|
||
|
|
pub pc0: PC0<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pc1: PC1<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pc2: PC2<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pc3: PC3<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pc4: PC4<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pc5: PC5<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pc6: PC6<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pc7: PC7<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pc8: PC8<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pc9: PC9<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pc10: PC10<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pc11: PC11<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pc12: PC12<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pc13: PC13<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pc14: PC14<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pc15: PC15<Input<Floating>>,
|
||
|
|
}
|
||
|
|
impl GpioExt for GPIOC {
|
||
|
|
type Parts = Parts;
|
||
|
|
fn split(self, rcc: &mut Rcc) -> Parts {
|
||
|
|
rcc.regs.ahbenr.modify(|_, w| w.iopcen().set_bit());
|
||
|
|
Parts {
|
||
|
|
pc0: PC0 { _mode: PhantomData },
|
||
|
|
pc1: PC1 { _mode: PhantomData },
|
||
|
|
pc2: PC2 { _mode: PhantomData },
|
||
|
|
pc3: PC3 { _mode: PhantomData },
|
||
|
|
pc4: PC4 { _mode: PhantomData },
|
||
|
|
pc5: PC5 { _mode: PhantomData },
|
||
|
|
pc6: PC6 { _mode: PhantomData },
|
||
|
|
pc7: PC7 { _mode: PhantomData },
|
||
|
|
pc8: PC8 { _mode: PhantomData },
|
||
|
|
pc9: PC9 { _mode: PhantomData },
|
||
|
|
pc10: PC10 { _mode: PhantomData },
|
||
|
|
pc11: PC11 { _mode: PhantomData },
|
||
|
|
pc12: PC12 { _mode: PhantomData },
|
||
|
|
pc13: PC13 { _mode: PhantomData },
|
||
|
|
pc14: PC14 { _mode: PhantomData },
|
||
|
|
pc15: PC15 { _mode: PhantomData },
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
fn _set_alternate_mode(index: usize, mode: u32) {
|
||
|
|
let offset = 2 * index;
|
||
|
|
let offset2 = 4 * index;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
if offset2 < 32 {
|
||
|
|
reg.afrl.modify(|r, w| {
|
||
|
|
w.bits((r.bits() & !(0b1111 << offset2)) | (mode << offset2))
|
||
|
|
});
|
||
|
|
} else {
|
||
|
|
let offset2 = offset2 - 32;
|
||
|
|
reg.afrh.modify(|r, w| {
|
||
|
|
w.bits((r.bits() & !(0b1111 << offset2)) | (mode << offset2))
|
||
|
|
});
|
||
|
|
}
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PC0<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PC0<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PC0<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(0, 0);
|
||
|
|
PC0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PC0<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(0, 1);
|
||
|
|
PC0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PC0<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(0, 2);
|
||
|
|
PC0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PC0<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(0, 3);
|
||
|
|
PC0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PC0<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(0, 4);
|
||
|
|
PC0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PC0<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(0, 5);
|
||
|
|
PC0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PC0<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(0, 6);
|
||
|
|
PC0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PC0<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(0, 7);
|
||
|
|
PC0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PC0<Input<Floating>> {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PC0<Input<PullDown>> {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PC0<Input<PullUp>> {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PC0<Analog> {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PC0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PC0<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 0)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PC0<Output<PushPull>> {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 0)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PC0<Output<PushPull>> {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 0)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 0)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PC0<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PC0<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PC0<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 0;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PC0<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 0,
|
||
|
|
port: GPIOC::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PC0<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_set_low(0) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PC0<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).set_high(0) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).set_low(0) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PC0<Output<MODE>> {}
|
||
|
|
impl InputPin for PC0<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_low(0) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PC0<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 0,
|
||
|
|
port: GPIOC::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PC0<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_low(0) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PC1<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PC1<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PC1<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(1, 0);
|
||
|
|
PC1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PC1<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(1, 1);
|
||
|
|
PC1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PC1<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(1, 2);
|
||
|
|
PC1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PC1<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(1, 3);
|
||
|
|
PC1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PC1<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(1, 4);
|
||
|
|
PC1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PC1<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(1, 5);
|
||
|
|
PC1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PC1<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(1, 6);
|
||
|
|
PC1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PC1<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(1, 7);
|
||
|
|
PC1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PC1<Input<Floating>> {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PC1<Input<PullDown>> {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PC1<Input<PullUp>> {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PC1<Analog> {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PC1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PC1<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 1)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PC1<Output<PushPull>> {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 1)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PC1<Output<PushPull>> {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 1)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 1)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PC1<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PC1<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PC1<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 1;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PC1<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 1,
|
||
|
|
port: GPIOC::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PC1<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_set_low(1) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PC1<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).set_high(1) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).set_low(1) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PC1<Output<MODE>> {}
|
||
|
|
impl InputPin for PC1<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_low(1) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PC1<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 1,
|
||
|
|
port: GPIOC::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PC1<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_low(1) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PC2<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PC2<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PC2<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(2, 0);
|
||
|
|
PC2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PC2<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(2, 1);
|
||
|
|
PC2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PC2<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(2, 2);
|
||
|
|
PC2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PC2<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(2, 3);
|
||
|
|
PC2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PC2<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(2, 4);
|
||
|
|
PC2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PC2<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(2, 5);
|
||
|
|
PC2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PC2<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(2, 6);
|
||
|
|
PC2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PC2<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(2, 7);
|
||
|
|
PC2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PC2<Input<Floating>> {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PC2<Input<PullDown>> {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PC2<Input<PullUp>> {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PC2<Analog> {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PC2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PC2<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 2)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PC2<Output<PushPull>> {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 2)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PC2<Output<PushPull>> {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 2)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 2)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PC2<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PC2<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PC2<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 2;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PC2<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 2,
|
||
|
|
port: GPIOC::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PC2<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_set_low(2) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PC2<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).set_high(2) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).set_low(2) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PC2<Output<MODE>> {}
|
||
|
|
impl InputPin for PC2<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_low(2) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PC2<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 2,
|
||
|
|
port: GPIOC::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PC2<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_low(2) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PC3<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PC3<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PC3<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(3, 0);
|
||
|
|
PC3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PC3<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(3, 1);
|
||
|
|
PC3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PC3<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(3, 2);
|
||
|
|
PC3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PC3<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(3, 3);
|
||
|
|
PC3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PC3<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(3, 4);
|
||
|
|
PC3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PC3<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(3, 5);
|
||
|
|
PC3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PC3<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(3, 6);
|
||
|
|
PC3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PC3<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(3, 7);
|
||
|
|
PC3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PC3<Input<Floating>> {
|
||
|
|
let offset = 2 * 3;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PC3<Input<PullDown>> {
|
||
|
|
let offset = 2 * 3;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PC3<Input<PullUp>> {
|
||
|
|
let offset = 2 * 3;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PC3<Analog> {
|
||
|
|
let offset = 2 * 3;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PC3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PC3<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 3;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 3)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PC3<Output<PushPull>> {
|
||
|
|
let offset = 2 * 3;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 3)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PC3<Output<PushPull>> {
|
||
|
|
let offset = 2 * 3;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 3)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 3)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC3 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PC3<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 3;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PC3<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 3;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PC3<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 3;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PC3<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 3,
|
||
|
|
port: GPIOC::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PC3<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_set_low(3) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PC3<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).set_high(3) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).set_low(3) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PC3<Output<MODE>> {}
|
||
|
|
impl InputPin for PC3<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_low(3) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PC3<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 3,
|
||
|
|
port: GPIOC::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PC3<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_low(3) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PC4<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PC4<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PC4<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(4, 0);
|
||
|
|
PC4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PC4<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(4, 1);
|
||
|
|
PC4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PC4<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(4, 2);
|
||
|
|
PC4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PC4<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(4, 3);
|
||
|
|
PC4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PC4<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(4, 4);
|
||
|
|
PC4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PC4<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(4, 5);
|
||
|
|
PC4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PC4<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(4, 6);
|
||
|
|
PC4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PC4<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(4, 7);
|
||
|
|
PC4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PC4<Input<Floating>> {
|
||
|
|
let offset = 2 * 4;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PC4<Input<PullDown>> {
|
||
|
|
let offset = 2 * 4;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PC4<Input<PullUp>> {
|
||
|
|
let offset = 2 * 4;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PC4<Analog> {
|
||
|
|
let offset = 2 * 4;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PC4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PC4<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 4;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 4)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PC4<Output<PushPull>> {
|
||
|
|
let offset = 2 * 4;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 4)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PC4<Output<PushPull>> {
|
||
|
|
let offset = 2 * 4;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 4)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 4)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC4 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PC4<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 4;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PC4<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 4;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PC4<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 4;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PC4<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 4,
|
||
|
|
port: GPIOC::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PC4<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_set_low(4) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PC4<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).set_high(4) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).set_low(4) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PC4<Output<MODE>> {}
|
||
|
|
impl InputPin for PC4<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_low(4) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PC4<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 4,
|
||
|
|
port: GPIOC::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PC4<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_low(4) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PC5<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PC5<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PC5<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(5, 0);
|
||
|
|
PC5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PC5<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(5, 1);
|
||
|
|
PC5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PC5<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(5, 2);
|
||
|
|
PC5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PC5<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(5, 3);
|
||
|
|
PC5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PC5<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(5, 4);
|
||
|
|
PC5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PC5<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(5, 5);
|
||
|
|
PC5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PC5<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(5, 6);
|
||
|
|
PC5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PC5<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(5, 7);
|
||
|
|
PC5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PC5<Input<Floating>> {
|
||
|
|
let offset = 2 * 5;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PC5<Input<PullDown>> {
|
||
|
|
let offset = 2 * 5;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PC5<Input<PullUp>> {
|
||
|
|
let offset = 2 * 5;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PC5<Analog> {
|
||
|
|
let offset = 2 * 5;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PC5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PC5<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 5;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 5)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PC5<Output<PushPull>> {
|
||
|
|
let offset = 2 * 5;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 5)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PC5<Output<PushPull>> {
|
||
|
|
let offset = 2 * 5;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 5)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 5)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC5 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PC5<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 5;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PC5<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 5;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PC5<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 5;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PC5<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 5,
|
||
|
|
port: GPIOC::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PC5<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_set_low(5) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PC5<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).set_high(5) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).set_low(5) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PC5<Output<MODE>> {}
|
||
|
|
impl InputPin for PC5<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_low(5) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PC5<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 5,
|
||
|
|
port: GPIOC::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PC5<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_low(5) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PC6<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PC6<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PC6<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(6, 0);
|
||
|
|
PC6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PC6<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(6, 1);
|
||
|
|
PC6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PC6<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(6, 2);
|
||
|
|
PC6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PC6<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(6, 3);
|
||
|
|
PC6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PC6<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(6, 4);
|
||
|
|
PC6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PC6<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(6, 5);
|
||
|
|
PC6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PC6<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(6, 6);
|
||
|
|
PC6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PC6<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(6, 7);
|
||
|
|
PC6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PC6<Input<Floating>> {
|
||
|
|
let offset = 2 * 6;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PC6<Input<PullDown>> {
|
||
|
|
let offset = 2 * 6;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PC6<Input<PullUp>> {
|
||
|
|
let offset = 2 * 6;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PC6<Analog> {
|
||
|
|
let offset = 2 * 6;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PC6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PC6<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 6;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 6)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PC6<Output<PushPull>> {
|
||
|
|
let offset = 2 * 6;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 6)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PC6<Output<PushPull>> {
|
||
|
|
let offset = 2 * 6;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 6)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 6)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC6 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PC6<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 6;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PC6<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 6;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PC6<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 6;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PC6<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 6,
|
||
|
|
port: GPIOC::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PC6<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_set_low(6) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PC6<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).set_high(6) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).set_low(6) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PC6<Output<MODE>> {}
|
||
|
|
impl InputPin for PC6<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_low(6) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PC6<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 6,
|
||
|
|
port: GPIOC::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PC6<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_low(6) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PC7<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PC7<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PC7<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(7, 0);
|
||
|
|
PC7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PC7<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(7, 1);
|
||
|
|
PC7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PC7<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(7, 2);
|
||
|
|
PC7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PC7<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(7, 3);
|
||
|
|
PC7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PC7<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(7, 4);
|
||
|
|
PC7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PC7<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(7, 5);
|
||
|
|
PC7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PC7<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(7, 6);
|
||
|
|
PC7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PC7<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(7, 7);
|
||
|
|
PC7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PC7<Input<Floating>> {
|
||
|
|
let offset = 2 * 7;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PC7<Input<PullDown>> {
|
||
|
|
let offset = 2 * 7;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PC7<Input<PullUp>> {
|
||
|
|
let offset = 2 * 7;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PC7<Analog> {
|
||
|
|
let offset = 2 * 7;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PC7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PC7<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 7;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 7)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PC7<Output<PushPull>> {
|
||
|
|
let offset = 2 * 7;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 7)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PC7<Output<PushPull>> {
|
||
|
|
let offset = 2 * 7;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 7)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 7)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC7 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PC7<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 7;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PC7<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 7;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PC7<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 7;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PC7<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 7,
|
||
|
|
port: GPIOC::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PC7<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_set_low(7) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PC7<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).set_high(7) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).set_low(7) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PC7<Output<MODE>> {}
|
||
|
|
impl InputPin for PC7<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_low(7) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PC7<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 7,
|
||
|
|
port: GPIOC::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PC7<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_low(7) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PC8<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PC8<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PC8<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(8, 0);
|
||
|
|
PC8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PC8<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(8, 1);
|
||
|
|
PC8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PC8<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(8, 2);
|
||
|
|
PC8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PC8<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(8, 3);
|
||
|
|
PC8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PC8<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(8, 4);
|
||
|
|
PC8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PC8<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(8, 5);
|
||
|
|
PC8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PC8<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(8, 6);
|
||
|
|
PC8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PC8<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(8, 7);
|
||
|
|
PC8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PC8<Input<Floating>> {
|
||
|
|
let offset = 2 * 8;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PC8<Input<PullDown>> {
|
||
|
|
let offset = 2 * 8;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PC8<Input<PullUp>> {
|
||
|
|
let offset = 2 * 8;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PC8<Analog> {
|
||
|
|
let offset = 2 * 8;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PC8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PC8<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 8;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 8)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PC8<Output<PushPull>> {
|
||
|
|
let offset = 2 * 8;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 8)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PC8<Output<PushPull>> {
|
||
|
|
let offset = 2 * 8;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 8)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 8)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC8 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PC8<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 8;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PC8<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 8;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PC8<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 8;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PC8<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 8,
|
||
|
|
port: GPIOC::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PC8<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_set_low(8) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PC8<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).set_high(8) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).set_low(8) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PC8<Output<MODE>> {}
|
||
|
|
impl InputPin for PC8<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_low(8) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PC8<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 8,
|
||
|
|
port: GPIOC::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PC8<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_low(8) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PC9<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PC9<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PC9<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(9, 0);
|
||
|
|
PC9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PC9<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(9, 1);
|
||
|
|
PC9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PC9<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(9, 2);
|
||
|
|
PC9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PC9<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(9, 3);
|
||
|
|
PC9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PC9<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(9, 4);
|
||
|
|
PC9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PC9<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(9, 5);
|
||
|
|
PC9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PC9<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(9, 6);
|
||
|
|
PC9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PC9<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(9, 7);
|
||
|
|
PC9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PC9<Input<Floating>> {
|
||
|
|
let offset = 2 * 9;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PC9<Input<PullDown>> {
|
||
|
|
let offset = 2 * 9;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PC9<Input<PullUp>> {
|
||
|
|
let offset = 2 * 9;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PC9<Analog> {
|
||
|
|
let offset = 2 * 9;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PC9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PC9<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 9;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 9)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PC9<Output<PushPull>> {
|
||
|
|
let offset = 2 * 9;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 9)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PC9<Output<PushPull>> {
|
||
|
|
let offset = 2 * 9;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 9)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 9)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC9 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PC9<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 9;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PC9<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 9;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PC9<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 9;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PC9<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 9,
|
||
|
|
port: GPIOC::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PC9<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_set_low(9) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PC9<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).set_high(9) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).set_low(9) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PC9<Output<MODE>> {}
|
||
|
|
impl InputPin for PC9<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_low(9) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PC9<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 9,
|
||
|
|
port: GPIOC::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PC9<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_low(9) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PC10<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PC10<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PC10<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(10, 0);
|
||
|
|
PC10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PC10<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(10, 1);
|
||
|
|
PC10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PC10<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(10, 2);
|
||
|
|
PC10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PC10<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(10, 3);
|
||
|
|
PC10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PC10<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(10, 4);
|
||
|
|
PC10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PC10<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(10, 5);
|
||
|
|
PC10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PC10<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(10, 6);
|
||
|
|
PC10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PC10<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(10, 7);
|
||
|
|
PC10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PC10<Input<Floating>> {
|
||
|
|
let offset = 2 * 10;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PC10<Input<PullDown>> {
|
||
|
|
let offset = 2 * 10;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PC10<Input<PullUp>> {
|
||
|
|
let offset = 2 * 10;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PC10<Analog> {
|
||
|
|
let offset = 2 * 10;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PC10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PC10<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 10;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 10)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PC10<Output<PushPull>> {
|
||
|
|
let offset = 2 * 10;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 10)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PC10<Output<PushPull>> {
|
||
|
|
let offset = 2 * 10;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 10)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 10)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC10 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PC10<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 10;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PC10<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 10;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PC10<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 10;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PC10<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 10,
|
||
|
|
port: GPIOC::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PC10<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_set_low(10) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PC10<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).set_high(10) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).set_low(10) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PC10<Output<MODE>> {}
|
||
|
|
impl InputPin for PC10<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_low(10) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PC10<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 10,
|
||
|
|
port: GPIOC::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PC10<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_low(10) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PC11<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PC11<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PC11<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(11, 0);
|
||
|
|
PC11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PC11<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(11, 1);
|
||
|
|
PC11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PC11<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(11, 2);
|
||
|
|
PC11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PC11<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(11, 3);
|
||
|
|
PC11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PC11<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(11, 4);
|
||
|
|
PC11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PC11<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(11, 5);
|
||
|
|
PC11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PC11<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(11, 6);
|
||
|
|
PC11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PC11<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(11, 7);
|
||
|
|
PC11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PC11<Input<Floating>> {
|
||
|
|
let offset = 2 * 11;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PC11<Input<PullDown>> {
|
||
|
|
let offset = 2 * 11;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PC11<Input<PullUp>> {
|
||
|
|
let offset = 2 * 11;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PC11<Analog> {
|
||
|
|
let offset = 2 * 11;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PC11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PC11<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 11;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 11)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PC11<Output<PushPull>> {
|
||
|
|
let offset = 2 * 11;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 11)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PC11<Output<PushPull>> {
|
||
|
|
let offset = 2 * 11;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 11)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 11)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC11 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PC11<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 11;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PC11<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 11;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PC11<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 11;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PC11<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 11,
|
||
|
|
port: GPIOC::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PC11<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_set_low(11) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PC11<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).set_high(11) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).set_low(11) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PC11<Output<MODE>> {}
|
||
|
|
impl InputPin for PC11<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_low(11) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PC11<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 11,
|
||
|
|
port: GPIOC::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PC11<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_low(11) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PC12<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PC12<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PC12<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(12, 0);
|
||
|
|
PC12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PC12<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(12, 1);
|
||
|
|
PC12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PC12<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(12, 2);
|
||
|
|
PC12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PC12<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(12, 3);
|
||
|
|
PC12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PC12<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(12, 4);
|
||
|
|
PC12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PC12<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(12, 5);
|
||
|
|
PC12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PC12<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(12, 6);
|
||
|
|
PC12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PC12<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(12, 7);
|
||
|
|
PC12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PC12<Input<Floating>> {
|
||
|
|
let offset = 2 * 12;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PC12<Input<PullDown>> {
|
||
|
|
let offset = 2 * 12;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PC12<Input<PullUp>> {
|
||
|
|
let offset = 2 * 12;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PC12<Analog> {
|
||
|
|
let offset = 2 * 12;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PC12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PC12<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 12;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 12)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PC12<Output<PushPull>> {
|
||
|
|
let offset = 2 * 12;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 12)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PC12<Output<PushPull>> {
|
||
|
|
let offset = 2 * 12;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 12)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 12)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC12 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PC12<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 12;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PC12<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 12;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PC12<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 12;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PC12<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 12,
|
||
|
|
port: GPIOC::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PC12<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_set_low(12) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PC12<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).set_high(12) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).set_low(12) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PC12<Output<MODE>> {}
|
||
|
|
impl InputPin for PC12<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_low(12) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PC12<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 12,
|
||
|
|
port: GPIOC::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PC12<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_low(12) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PC13<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PC13<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PC13<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(13, 0);
|
||
|
|
PC13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PC13<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(13, 1);
|
||
|
|
PC13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PC13<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(13, 2);
|
||
|
|
PC13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PC13<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(13, 3);
|
||
|
|
PC13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PC13<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(13, 4);
|
||
|
|
PC13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PC13<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(13, 5);
|
||
|
|
PC13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PC13<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(13, 6);
|
||
|
|
PC13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PC13<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(13, 7);
|
||
|
|
PC13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PC13<Input<Floating>> {
|
||
|
|
let offset = 2 * 13;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PC13<Input<PullDown>> {
|
||
|
|
let offset = 2 * 13;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PC13<Input<PullUp>> {
|
||
|
|
let offset = 2 * 13;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PC13<Analog> {
|
||
|
|
let offset = 2 * 13;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PC13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PC13<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 13;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 13)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PC13<Output<PushPull>> {
|
||
|
|
let offset = 2 * 13;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 13)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PC13<Output<PushPull>> {
|
||
|
|
let offset = 2 * 13;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 13)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 13)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC13 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PC13<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 13;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PC13<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 13;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PC13<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 13;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PC13<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 13,
|
||
|
|
port: GPIOC::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PC13<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_set_low(13) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PC13<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).set_high(13) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).set_low(13) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PC13<Output<MODE>> {}
|
||
|
|
impl InputPin for PC13<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_low(13) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PC13<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 13,
|
||
|
|
port: GPIOC::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PC13<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_low(13) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PC14<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PC14<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PC14<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(14, 0);
|
||
|
|
PC14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PC14<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(14, 1);
|
||
|
|
PC14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PC14<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(14, 2);
|
||
|
|
PC14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PC14<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(14, 3);
|
||
|
|
PC14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PC14<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(14, 4);
|
||
|
|
PC14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PC14<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(14, 5);
|
||
|
|
PC14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PC14<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(14, 6);
|
||
|
|
PC14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PC14<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(14, 7);
|
||
|
|
PC14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PC14<Input<Floating>> {
|
||
|
|
let offset = 2 * 14;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PC14<Input<PullDown>> {
|
||
|
|
let offset = 2 * 14;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PC14<Input<PullUp>> {
|
||
|
|
let offset = 2 * 14;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PC14<Analog> {
|
||
|
|
let offset = 2 * 14;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PC14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PC14<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 14;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 14)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PC14<Output<PushPull>> {
|
||
|
|
let offset = 2 * 14;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 14)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PC14<Output<PushPull>> {
|
||
|
|
let offset = 2 * 14;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 14)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 14)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC14 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PC14<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 14;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PC14<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 14;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PC14<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 14;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PC14<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 14,
|
||
|
|
port: GPIOC::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PC14<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_set_low(14) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PC14<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).set_high(14) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).set_low(14) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PC14<Output<MODE>> {}
|
||
|
|
impl InputPin for PC14<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_low(14) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PC14<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 14,
|
||
|
|
port: GPIOC::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PC14<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_low(14) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PC15<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PC15<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PC15<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(15, 0);
|
||
|
|
PC15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PC15<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(15, 1);
|
||
|
|
PC15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PC15<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(15, 2);
|
||
|
|
PC15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PC15<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(15, 3);
|
||
|
|
PC15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PC15<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(15, 4);
|
||
|
|
PC15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PC15<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(15, 5);
|
||
|
|
PC15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PC15<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(15, 6);
|
||
|
|
PC15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PC15<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(15, 7);
|
||
|
|
PC15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PC15<Input<Floating>> {
|
||
|
|
let offset = 2 * 15;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PC15<Input<PullDown>> {
|
||
|
|
let offset = 2 * 15;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PC15<Input<PullUp>> {
|
||
|
|
let offset = 2 * 15;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PC15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PC15<Analog> {
|
||
|
|
let offset = 2 * 15;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PC15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PC15<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 15;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 15)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PC15<Output<PushPull>> {
|
||
|
|
let offset = 2 * 15;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 15)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PC15<Output<PushPull>> {
|
||
|
|
let offset = 2 * 15;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 15)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 15)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PC15 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PC15<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 15;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PC15<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 15;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PC15<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 15;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOC::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PC15<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 15,
|
||
|
|
port: GPIOC::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PC15<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_set_low(15) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PC15<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).set_high(15) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).set_low(15) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PC15<Output<MODE>> {}
|
||
|
|
impl InputPin for PC15<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_low(15) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PC15<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 15,
|
||
|
|
port: GPIOC::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PC15<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOC::ptr()).is_low(15) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// GPIO
|
||
|
|
#[cfg(any(
|
||
|
|
feature = "stm32f030",
|
||
|
|
feature = "stm32f051",
|
||
|
|
feature = "stm32f058",
|
||
|
|
feature = "stm32f070"
|
||
|
|
))]
|
||
|
|
pub mod gpiod {
|
||
|
|
use core::marker::PhantomData;
|
||
|
|
use core::convert::Infallible;
|
||
|
|
use embedded_hal::digital::v2::{InputPin, OutputPin, StatefulOutputPin, toggleable};
|
||
|
|
use crate::{rcc::Rcc, pac::GPIOD};
|
||
|
|
use cortex_m::interrupt::CriticalSection;
|
||
|
|
use super::{
|
||
|
|
Alternate, Analog, Floating, GpioExt, Input, OpenDrain, Output, PullDown, PullUp,
|
||
|
|
PushPull, AF0, AF1, AF2, AF3, AF4, AF5, AF6, AF7, Pin, GpioRegExt,
|
||
|
|
};
|
||
|
|
/// GPIO parts
|
||
|
|
pub struct Parts {
|
||
|
|
/// Pin
|
||
|
|
pub pd2: PD2<Input<Floating>>,
|
||
|
|
}
|
||
|
|
impl GpioExt for GPIOD {
|
||
|
|
type Parts = Parts;
|
||
|
|
fn split(self, rcc: &mut Rcc) -> Parts {
|
||
|
|
rcc.regs.ahbenr.modify(|_, w| w.iopden().set_bit());
|
||
|
|
Parts {
|
||
|
|
pd2: PD2 { _mode: PhantomData },
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
fn _set_alternate_mode(index: usize, mode: u32) {
|
||
|
|
let offset = 2 * index;
|
||
|
|
let offset2 = 4 * index;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOD::ptr());
|
||
|
|
if offset2 < 32 {
|
||
|
|
reg.afrl.modify(|r, w| {
|
||
|
|
w.bits((r.bits() & !(0b1111 << offset2)) | (mode << offset2))
|
||
|
|
});
|
||
|
|
} else {
|
||
|
|
let offset2 = offset2 - 32;
|
||
|
|
reg.afrh.modify(|r, w| {
|
||
|
|
w.bits((r.bits() & !(0b1111 << offset2)) | (mode << offset2))
|
||
|
|
});
|
||
|
|
}
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PD2<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PD2<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PD2<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(2, 0);
|
||
|
|
PD2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PD2<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(2, 1);
|
||
|
|
PD2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PD2<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(2, 2);
|
||
|
|
PD2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PD2<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(2, 3);
|
||
|
|
PD2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PD2<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(2, 4);
|
||
|
|
PD2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PD2<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(2, 5);
|
||
|
|
PD2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PD2<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(2, 6);
|
||
|
|
PD2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PD2<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(2, 7);
|
||
|
|
PD2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PD2<Input<Floating>> {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOD::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PD2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PD2<Input<PullDown>> {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOD::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PD2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PD2<Input<PullUp>> {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOD::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PD2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PD2<Analog> {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOD::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PD2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PD2<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOD::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 2)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PD2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PD2<Output<PushPull>> {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOD::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 2)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PD2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PD2<Output<PushPull>> {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOD::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 2)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 2)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PD2 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl PD2<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOD::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PD2<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 2;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOD::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PD2<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 2;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOD::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PD2<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 2,
|
||
|
|
port: GPIOD::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PD2<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOD::ptr()).is_set_low(2) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PD2<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOD::ptr()).set_high(2) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOD::ptr()).set_low(2) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PD2<Output<MODE>> {}
|
||
|
|
impl InputPin for PD2<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOD::ptr()).is_low(2) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PD2<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 2,
|
||
|
|
port: GPIOD::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PD2<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOD::ptr()).is_low(2) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// GPIO
|
||
|
|
#[cfg(any(feature = "stm32f030xc", feature = "stm32f070"))]
|
||
|
|
pub mod gpiof {
|
||
|
|
use core::marker::PhantomData;
|
||
|
|
use core::convert::Infallible;
|
||
|
|
use embedded_hal::digital::v2::{InputPin, OutputPin, StatefulOutputPin, toggleable};
|
||
|
|
use crate::{rcc::Rcc, pac::GPIOF};
|
||
|
|
use cortex_m::interrupt::CriticalSection;
|
||
|
|
use super::{
|
||
|
|
Alternate, Analog, Floating, GpioExt, Input, OpenDrain, Output, PullDown, PullUp,
|
||
|
|
PushPull, AF0, AF1, AF2, AF3, AF4, AF5, AF6, AF7, Pin, GpioRegExt,
|
||
|
|
};
|
||
|
|
/// GPIO parts
|
||
|
|
pub struct Parts {
|
||
|
|
/// Pin
|
||
|
|
pub pf0: PF0<Input<Floating>>,
|
||
|
|
/// Pin
|
||
|
|
pub pf1: PF1<Input<Floating>>,
|
||
|
|
}
|
||
|
|
impl GpioExt for GPIOF {
|
||
|
|
type Parts = Parts;
|
||
|
|
fn split(self, rcc: &mut Rcc) -> Parts {
|
||
|
|
rcc.regs.ahbenr.modify(|_, w| w.iopfen().set_bit());
|
||
|
|
Parts {
|
||
|
|
pf0: PF0 { _mode: PhantomData },
|
||
|
|
pf1: PF1 { _mode: PhantomData },
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
fn _set_alternate_mode(index: usize, mode: u32) {
|
||
|
|
let offset = 2 * index;
|
||
|
|
let offset2 = 4 * index;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOF::ptr());
|
||
|
|
if offset2 < 32 {
|
||
|
|
reg.afrl.modify(|r, w| {
|
||
|
|
w.bits((r.bits() & !(0b1111 << offset2)) | (mode << offset2))
|
||
|
|
});
|
||
|
|
} else {
|
||
|
|
let offset2 = offset2 - 32;
|
||
|
|
reg.afrh.modify(|r, w| {
|
||
|
|
w.bits((r.bits() & !(0b1111 << offset2)) | (mode << offset2))
|
||
|
|
});
|
||
|
|
}
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PF0<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PF0<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PF0<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(0, 0);
|
||
|
|
PF0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PF0<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(0, 1);
|
||
|
|
PF0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PF0<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(0, 2);
|
||
|
|
PF0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PF0<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(0, 3);
|
||
|
|
PF0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PF0<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(0, 4);
|
||
|
|
PF0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PF0<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(0, 5);
|
||
|
|
PF0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PF0<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(0, 6);
|
||
|
|
PF0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PF0<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(0, 7);
|
||
|
|
PF0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PF0<Input<Floating>> {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOF::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PF0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PF0<Input<PullDown>> {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOF::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PF0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PF0<Input<PullUp>> {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOF::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PF0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PF0<Analog> {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOF::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PF0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PF0<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOF::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 0)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PF0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PF0<Output<PushPull>> {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOF::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 0)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PF0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PF0<Output<PushPull>> {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOF::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 0)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 0)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PF0 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PF0<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOF::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PF0<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 0;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOF::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PF0<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 0;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOF::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PF0<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 0,
|
||
|
|
port: GPIOF::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PF0<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOF::ptr()).is_set_low(0) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PF0<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOF::ptr()).set_high(0) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOF::ptr()).set_low(0) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PF0<Output<MODE>> {}
|
||
|
|
impl InputPin for PF0<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOF::ptr()).is_low(0) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PF0<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 0,
|
||
|
|
port: GPIOF::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PF0<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOF::ptr()).is_low(0) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Pin
|
||
|
|
pub struct PF1<MODE> {
|
||
|
|
_mode: PhantomData<MODE>,
|
||
|
|
}
|
||
|
|
impl<MODE> PF1<MODE> {
|
||
|
|
/// Configures the pin to operate in AF0 mode
|
||
|
|
pub fn into_alternate_af0(self, _cs: &CriticalSection) -> PF1<Alternate<AF0>> {
|
||
|
|
_set_alternate_mode(1, 0);
|
||
|
|
PF1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF1 mode
|
||
|
|
pub fn into_alternate_af1(self, _cs: &CriticalSection) -> PF1<Alternate<AF1>> {
|
||
|
|
_set_alternate_mode(1, 1);
|
||
|
|
PF1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF2 mode
|
||
|
|
pub fn into_alternate_af2(self, _cs: &CriticalSection) -> PF1<Alternate<AF2>> {
|
||
|
|
_set_alternate_mode(1, 2);
|
||
|
|
PF1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF3 mode
|
||
|
|
pub fn into_alternate_af3(self, _cs: &CriticalSection) -> PF1<Alternate<AF3>> {
|
||
|
|
_set_alternate_mode(1, 3);
|
||
|
|
PF1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF4 mode
|
||
|
|
pub fn into_alternate_af4(self, _cs: &CriticalSection) -> PF1<Alternate<AF4>> {
|
||
|
|
_set_alternate_mode(1, 4);
|
||
|
|
PF1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF5 mode
|
||
|
|
pub fn into_alternate_af5(self, _cs: &CriticalSection) -> PF1<Alternate<AF5>> {
|
||
|
|
_set_alternate_mode(1, 5);
|
||
|
|
PF1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF6 mode
|
||
|
|
pub fn into_alternate_af6(self, _cs: &CriticalSection) -> PF1<Alternate<AF6>> {
|
||
|
|
_set_alternate_mode(1, 6);
|
||
|
|
PF1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate in AF7 mode
|
||
|
|
pub fn into_alternate_af7(self, _cs: &CriticalSection) -> PF1<Alternate<AF7>> {
|
||
|
|
_set_alternate_mode(1, 7);
|
||
|
|
PF1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a floating input pin
|
||
|
|
pub fn into_floating_input(self, _cs: &CriticalSection) -> PF1<Input<Floating>> {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOF::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PF1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled down input pin
|
||
|
|
pub fn into_pull_down_input(self, _cs: &CriticalSection) -> PF1<Input<PullDown>> {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOF::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PF1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as a pulled up input pin
|
||
|
|
pub fn into_pull_up_input(self, _cs: &CriticalSection) -> PF1<Input<PullUp>> {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOF::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
}
|
||
|
|
PF1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an analog pin
|
||
|
|
pub fn into_analog(self, _cs: &CriticalSection) -> PF1<Analog> {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOF::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset)));
|
||
|
|
}
|
||
|
|
PF1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an open drain output pin
|
||
|
|
pub fn into_open_drain_output(self, _cs: &CriticalSection) -> PF1<Output<OpenDrain>> {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOF::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (0b1 << 1)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PF1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin
|
||
|
|
pub fn into_push_pull_output(self, _cs: &CriticalSection) -> PF1<Output<PushPull>> {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOF::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 1)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PF1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
/// Configures the pin to operate as an push pull output pin with quick fall
|
||
|
|
/// and rise times
|
||
|
|
pub fn into_push_pull_output_hs(self, _cs: &CriticalSection) -> PF1<Output<PushPull>> {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOF::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b00 << offset)));
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() & !(0b1 << 1)));
|
||
|
|
reg.ospeedr.modify(|r, w| w.bits(r.bits() & !(0b1 << 1)));
|
||
|
|
reg.moder
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset)));
|
||
|
|
}
|
||
|
|
PF1 { _mode: PhantomData }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl PF1<Output<OpenDrain>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(&mut self, _cs: &CriticalSection, on: bool) {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOF::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PF1<Alternate<AF>> {
|
||
|
|
/// Enables / disables the internal pull up
|
||
|
|
pub fn internal_pull_up(self, _cs: &CriticalSection, on: bool) -> Self {
|
||
|
|
let offset = 2 * 1;
|
||
|
|
let value = if on { 0b01 } else { 0b00 };
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOF::ptr());
|
||
|
|
reg.pupdr
|
||
|
|
.modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (value << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<AF> PF1<Alternate<AF>> {
|
||
|
|
/// Turns pin alternate configuration pin into open drain
|
||
|
|
pub fn set_open_drain(self, _cs: &CriticalSection) -> Self {
|
||
|
|
let offset = 1;
|
||
|
|
unsafe {
|
||
|
|
let reg = &(*GPIOF::ptr());
|
||
|
|
reg.otyper.modify(|r, w| w.bits(r.bits() | (1 << offset)));
|
||
|
|
}
|
||
|
|
self
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PF1<Output<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Output<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 1,
|
||
|
|
port: GPIOF::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> StatefulOutputPin for PF1<Output<MODE>> {
|
||
|
|
fn is_set_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_set_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_set_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOF::ptr()).is_set_low(1) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> OutputPin for PF1<Output<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOF::ptr()).set_high(1) })
|
||
|
|
}
|
||
|
|
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOF::ptr()).set_low(1) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> toggleable::Default for PF1<Output<MODE>> {}
|
||
|
|
impl InputPin for PF1<Output<OpenDrain>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOF::ptr()).is_low(1) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> PF1<Input<MODE>> {
|
||
|
|
/// Erases the pin number from the type
|
||
|
|
///
|
||
|
|
/// This is useful when you want to collect the pins into an array where you
|
||
|
|
/// need all the elements to have the same type
|
||
|
|
pub fn downgrade(self) -> Pin<Input<MODE>> {
|
||
|
|
Pin {
|
||
|
|
i: 1,
|
||
|
|
port: GPIOF::ptr() as *const dyn GpioRegExt,
|
||
|
|
_mode: self._mode,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<MODE> InputPin for PF1<Input<MODE>> {
|
||
|
|
type Error = Infallible;
|
||
|
|
fn is_high(&self) -> Result<bool, Self::Error> {
|
||
|
|
self.is_low().map(|v| !v)
|
||
|
|
}
|
||
|
|
fn is_low(&self) -> Result<bool, Self::Error> {
|
||
|
|
Ok(unsafe { (*GPIOF::ptr()).is_low(1) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|