use core::marker::PhantomData;
use crate::rcc::APB2;
pub trait GpioExt {
type Parts;
fn split(self, apb2: &mut APB2) -> Self::Parts;
}
pub trait Mode<MODE> {}
pub trait Active {}
pub struct Input<MODE> {
_mode: PhantomData<MODE>,
}
impl<MODE> Active for Input<MODE> {}
pub struct Debugger;
pub struct Floating;
pub struct PullDown;
pub struct PullUp;
pub struct Output<MODE> {
_mode: PhantomData<MODE>,
}
impl<MODE> Active for Output<MODE> {}
pub struct PushPull;
pub struct OpenDrain;
pub struct Analog;
impl Active for Analog {}
pub struct Alternate<MODE> {
_mode: PhantomData<MODE>,
}
impl<MODE> Active for Alternate<MODE> {}
pub enum State {
High,
Low,
}
macro_rules! gpio {
($GPIOX:ident, $gpiox:ident, $gpioy:ident, $PXx:ident, [
$($PXi:ident: ($pxi:ident, $i:expr, $MODE:ty, $CR:ident),)+
]) => {
pub mod $gpiox {
use core::convert::Infallible;
use core::marker::PhantomData;
use crate::hal::digital::v2::{InputPin, OutputPin, StatefulOutputPin, toggleable};
use crate::pac::{$gpioy, $GPIOX};
use crate::rcc::{APB2, Enable, Reset};
use super::{
Alternate, Floating, GpioExt, Input,
OpenDrain,
Output,
PullDown,
PullUp,
PushPull,
Analog,
State,
Active,
Debugger,
Pxx,
Mode,
};
pub struct Parts {
pub crl: CRL,
pub crh: CRH,
$(
pub $pxi: $PXi<$MODE>,
)+
}
impl GpioExt for $GPIOX {
type Parts = Parts;
fn split(self, apb: &mut APB2) -> Parts {
$GPIOX::enable(apb);
$GPIOX::reset(apb);
Parts {
crl: CRL { _0: () },
crh: CRH { _0: () },
$(
$pxi: $PXi { _mode: PhantomData },
)+
}
}
}
pub struct CRL {
_0: (),
}
impl CRL {
#[allow(dead_code)]
pub(crate) fn cr(&mut self) -> &$gpioy::CRL {
unsafe { &(*$GPIOX::ptr()).crl }
}
}
pub struct CRH {
_0: (),
}
impl CRH {
pub(crate) fn cr(&mut self) -> &$gpioy::CRH {
unsafe { &(*$GPIOX::ptr()).crh }
}
}
pub struct Generic<MODE> {
i: u8,
_mode: PhantomData<MODE>,
}
impl<MODE> Generic<MODE> {
pub fn downgrade(self) -> Pxx<MODE> {
Pxx::$PXx(self)
}
}
impl<MODE> OutputPin for Generic<Output<MODE>> {
type Error = Infallible;
fn set_high(&mut self) -> Result<(), Self::Error> {
Ok(unsafe { (*$GPIOX::ptr()).bsrr.write(|w| w.bits(1 << self.i)) })
}
fn set_low(&mut self) -> Result<(), Self::Error> {
Ok(unsafe { (*$GPIOX::ptr()).bsrr.write(|w| w.bits(1 << (16 + self.i))) })
}
}
impl<MODE> InputPin for Generic<Input<MODE>> {
type Error = Infallible;
fn is_high(&self) -> Result<bool, Self::Error> {
self.is_low().map(|b| !b)
}
fn is_low(&self) -> Result<bool, Self::Error> {
Ok(unsafe { (*$GPIOX::ptr()).idr.read().bits() & (1 << self.i) == 0 })
}
}
impl <MODE> StatefulOutputPin for Generic<Output<MODE>> {
fn is_set_high(&self) -> Result<bool, Self::Error> {
self.is_set_low().map(|b| !b)
}
fn is_set_low(&self) -> Result<bool, Self::Error> {
Ok(unsafe { (*$GPIOX::ptr()).odr.read().bits() & (1 << self.i) == 0 })
}
}
impl <MODE> toggleable::Default for Generic<Output<MODE>> {}
impl InputPin for Generic<Output<OpenDrain>> {
type Error = Infallible;
fn is_high(&self) -> Result<bool, Self::Error> {
self.is_low().map(|b| !b)
}
fn is_low(&self) -> Result<bool, Self::Error> {
Ok(unsafe { (*$GPIOX::ptr()).idr.read().bits() & (1 << self.i) == 0 })
}
}
pub type $PXx<MODE> = Pxx<MODE>;
impl<MODE> Mode<MODE> for Generic<MODE> {}
$(
pub struct $PXi<MODE> {
_mode: PhantomData<MODE>,
}
impl<MODE> Mode<MODE> for $PXi<MODE> {}
impl $PXi<Debugger> {
#[allow(dead_code)]
pub(crate) unsafe fn activate(self) -> $PXi<Input<Floating>> {
$PXi { _mode: PhantomData }
}
}
impl<MODE> $PXi<MODE> where MODE: Active {
pub fn into_alternate_push_pull(
self,
cr: &mut $CR,
) -> $PXi<Alternate<PushPull>> {
const OFFSET: u32 = (4 * $i) % 32;
const CNF: u32 = 0b10;
const MODE: u32 = 0b11;
const BITS: u32 = (CNF << 2) | MODE;
cr
.cr()
.modify(|r, w| unsafe {
w.bits((r.bits() & !(0b1111 << OFFSET)) | (BITS << OFFSET))
});
$PXi { _mode: PhantomData }
}
pub fn into_alternate_open_drain(
self,
cr: &mut $CR,
) -> $PXi<Alternate<OpenDrain>> {
const OFFSET: u32 = (4 * $i) % 32;
const CNF: u32 = 0b11;
const MODE: u32 = 0b11;
const BITS: u32 = (CNF << 2) | MODE;
cr
.cr()
.modify(|r, w| unsafe {
w.bits((r.bits() & !(0b1111 << OFFSET)) | (BITS << OFFSET))
});
$PXi { _mode: PhantomData }
}
pub fn into_floating_input(
self,
cr: &mut $CR,
) -> $PXi<Input<Floating>> {
const OFFSET: u32 = (4 * $i) % 32;
const CNF: u32 = 0b01;
const MODE: u32 = 0b00;
const BITS: u32 = (CNF << 2) | MODE;
cr
.cr()
.modify(|r, w| unsafe {
w.bits((r.bits() & !(0b1111 << OFFSET)) | (BITS << OFFSET))
});
$PXi { _mode: PhantomData }
}
pub fn into_pull_down_input(
self,
cr: &mut $CR,
) -> $PXi<Input<PullDown>> {
const OFFSET: u32 = (4 * $i) % 32;
const CNF: u32 = 0b10;
const MODE: u32 = 0b00;
const BITS: u32 = (CNF << 2) | MODE;
unsafe { (*$GPIOX::ptr()).bsrr.write(|w| w.bits(1 << (16 + $i))) }
cr
.cr()
.modify(|r, w| unsafe {
w.bits((r.bits() & !(0b1111 << OFFSET)) | (BITS << OFFSET))
});
$PXi { _mode: PhantomData }
}
pub fn into_pull_up_input(
self,
cr: &mut $CR,
) -> $PXi<Input<PullUp>> {
const OFFSET: u32 = (4 * $i) % 32;
const CNF: u32 = 0b10;
const MODE: u32 = 0b00;
const BITS: u32 = (CNF << 2) | MODE;
unsafe { (*$GPIOX::ptr()).bsrr.write(|w| w.bits(1 << $i)) }
cr
.cr()
.modify(|r, w| unsafe {
w.bits((r.bits() & !(0b1111 << OFFSET)) | (BITS << OFFSET))
});
$PXi { _mode: PhantomData }
}
pub fn into_open_drain_output(
self,
cr: &mut $CR,
) -> $PXi<Output<OpenDrain>> {
self.into_open_drain_output_with_state(cr, State::Low)
}
pub fn into_open_drain_output_with_state(
self,
cr: &mut $CR,
initial_state: State,
) -> $PXi<Output<OpenDrain>> {
const OFFSET: u32 = (4 * $i) % 32;
const CNF: u32 = 0b01;
const MODE: u32 = 0b11;
const BITS: u32 = (CNF << 2) | MODE;
let mut res = $PXi { _mode: PhantomData };
match initial_state {
State::High => res.set_high(),
State::Low => res.set_low(),
}.unwrap();
cr
.cr()
.modify(|r, w| unsafe {
w.bits((r.bits() & !(0b1111 << OFFSET)) | (BITS << OFFSET))
});
res
}
pub fn into_push_pull_output(
self,
cr: &mut $CR,
) -> $PXi<Output<PushPull>> {
self.into_push_pull_output_with_state(cr, State::Low)
}
pub fn into_push_pull_output_with_state(
self,
cr: &mut $CR,
initial_state: State,
) -> $PXi<Output<PushPull>> {
const OFFSET: u32 = (4 * $i) % 32;
const CNF: u32 = 0b00;
const MODE: u32 = 0b11;
const BITS: u32 = (CNF << 2) | MODE;
let mut res = $PXi { _mode: PhantomData };
match initial_state {
State::High => res.set_high(),
State::Low => res.set_low(),
}.unwrap();
cr
.cr()
.modify(|r, w| unsafe {
w.bits((r.bits() & !(0b1111 << OFFSET)) | (BITS << OFFSET))
});
res
}
pub fn into_analog(self, cr: &mut $CR) -> $PXi<Analog> {
const OFFSET: u32 = (4 * $i) % 32;
const CNF: u32 = 0b00;
const MODE: u32 = 0b00;
const BITS: u32 = (CNF << 2) | MODE;
cr
.cr()
.modify(|r, w| unsafe {
w.bits((r.bits() & !(0b1111 << OFFSET)) | (BITS << OFFSET))
});
$PXi { _mode: PhantomData }
}
}
impl<MODE> $PXi<MODE> where MODE: Active {
fn into_generic(self) -> Generic<MODE> {
Generic {
i: $i,
_mode: self._mode,
}
}
pub fn downgrade(self) -> Pxx<MODE> {
self.into_generic().downgrade()
}
}
impl<MODE> OutputPin for $PXi<Output<MODE>> {
type Error = Infallible;
fn set_high(&mut self) -> Result<(), Self::Error> {
Ok(unsafe { (*$GPIOX::ptr()).bsrr.write(|w| w.bits(1 << $i)) })
}
fn set_low(&mut self) -> Result<(), Self::Error> {
Ok(unsafe { (*$GPIOX::ptr()).bsrr.write(|w| w.bits(1 << (16 + $i))) })
}
}
impl<MODE> StatefulOutputPin for $PXi<Output<MODE>> {
fn is_set_high(&self) -> Result<bool, Self::Error> {
self.is_set_low().map(|b| !b)
}
fn is_set_low(&self) -> Result<bool, Self::Error> {
Ok(unsafe { (*$GPIOX::ptr()).odr.read().bits() & (1 << $i) == 0 })
}
}
impl<MODE> toggleable::Default for $PXi<Output<MODE>> {}
impl<MODE> InputPin for $PXi<Input<MODE>> {
type Error = Infallible;
fn is_high(&self) -> Result<bool, Self::Error> {
self.is_low().map(|b| !b)
}
fn is_low(&self) -> Result<bool, Self::Error> {
Ok(unsafe { (*$GPIOX::ptr()).idr.read().bits() & (1 << $i) == 0 })
}
}
impl InputPin for $PXi<Output<OpenDrain>> {
type Error = Infallible;
fn is_high(&self) -> Result<bool, Self::Error> {
self.is_low().map(|b| !b)
}
fn is_low(&self) -> Result<bool, Self::Error> {
Ok(unsafe { (*$GPIOX::ptr()).idr.read().bits() & (1 << $i) == 0 })
}
}
)+
}
}
}
macro_rules! impl_pxx {
($(($port:ident :: $pin:ident)),*) => {
use embedded_hal::digital::v2::{InputPin, StatefulOutputPin, OutputPin};
use core::convert::Infallible;
pub enum Pxx<MODE> {
$(
$pin($port::Generic<MODE>)
),*
}
impl<MODE> OutputPin for Pxx<Output<MODE>> {
type Error = Infallible;
fn set_high(&mut self) -> Result<(), Infallible> {
match self {
$(Pxx::$pin(pin) => pin.set_high()),*
}
}
fn set_low(&mut self) -> Result<(), Infallible> {
match self {
$(Pxx::$pin(pin) => pin.set_low()),*
}
}
}
impl<MODE> StatefulOutputPin for Pxx<Output<MODE>> {
fn is_set_high(&self) -> Result<bool, Self::Error> {
match self {
$(Pxx::$pin(pin) => pin.is_set_high()),*
}
}
fn is_set_low(&self) -> Result<bool, Self::Error> {
match self {
$(Pxx::$pin(pin) => pin.is_set_low()),*
}
}
}
impl<MODE> InputPin for Pxx<Input<MODE>> {
type Error = Infallible;
fn is_high(&self) -> Result<bool, Infallible> {
match self {
$(Pxx::$pin(pin) => pin.is_high()),*
}
}
fn is_low(&self) -> Result<bool, Infallible> {
match self {
$(Pxx::$pin(pin) => pin.is_low()),*
}
}
}
}
}
impl_pxx!{
(gpioa::PAx),
(gpiob::PBx),
(gpioc::PCx),
(gpiod::PDx),
(gpioe::PEx)
}
gpio!(GPIOA, gpioa, gpioa, PAx, [
PA0: (pa0, 0, Input<Floating>, CRL),
PA1: (pa1, 1, Input<Floating>, CRL),
PA2: (pa2, 2, Input<Floating>, CRL),
PA3: (pa3, 3, Input<Floating>, CRL),
PA4: (pa4, 4, Input<Floating>, CRL),
PA5: (pa5, 5, Input<Floating>, CRL),
PA6: (pa6, 6, Input<Floating>, CRL),
PA7: (pa7, 7, Input<Floating>, CRL),
PA8: (pa8, 8, Input<Floating>, CRH),
PA9: (pa9, 9, Input<Floating>, CRH),
PA10: (pa10, 10, Input<Floating>, CRH),
PA11: (pa11, 11, Input<Floating>, CRH),
PA12: (pa12, 12, Input<Floating>, CRH),
PA13: (pa13, 13, Debugger, CRH),
PA14: (pa14, 14, Debugger, CRH),
PA15: (pa15, 15, Debugger, CRH),
]);
gpio!(GPIOB, gpiob, gpioa, PBx, [
PB0: (pb0, 0, Input<Floating>, CRL),
PB1: (pb1, 1, Input<Floating>, CRL),
PB2: (pb2, 2, Input<Floating>, CRL),
PB3: (pb3, 3, Debugger, CRL),
PB4: (pb4, 4, Debugger, CRL),
PB5: (pb5, 5, Input<Floating>, CRL),
PB6: (pb6, 6, Input<Floating>, CRL),
PB7: (pb7, 7, Input<Floating>, CRL),
PB8: (pb8, 8, Input<Floating>, CRH),
PB9: (pb9, 9, Input<Floating>, CRH),
PB10: (pb10, 10, Input<Floating>, CRH),
PB11: (pb11, 11, Input<Floating>, CRH),
PB12: (pb12, 12, Input<Floating>, CRH),
PB13: (pb13, 13, Input<Floating>, CRH),
PB14: (pb14, 14, Input<Floating>, CRH),
PB15: (pb15, 15, Input<Floating>, CRH),
]);
gpio!(GPIOC, gpioc, gpioa, PCx, [
PC0: (pc0, 0, Input<Floating>, CRL),
PC1: (pc1, 1, Input<Floating>, CRL),
PC2: (pc2, 2, Input<Floating>, CRL),
PC3: (pc3, 3, Input<Floating>, CRL),
PC4: (pc4, 4, Input<Floating>, CRL),
PC5: (pc5, 5, Input<Floating>, CRL),
PC6: (pc6, 6, Input<Floating>, CRL),
PC7: (pc7, 7, Input<Floating>, CRL),
PC8: (pc8, 8, Input<Floating>, CRH),
PC9: (pc9, 9, Input<Floating>, CRH),
PC10: (pc10, 10, Input<Floating>, CRH),
PC11: (pc11, 11, Input<Floating>, CRH),
PC12: (pc12, 12, Input<Floating>, CRH),
PC13: (pc13, 13, Input<Floating>, CRH),
PC14: (pc14, 14, Input<Floating>, CRH),
PC15: (pc15, 15, Input<Floating>, CRH),
]);
gpio!(GPIOD, gpiod, gpioa, PDx, [
PD0: (pd0, 0, Input<Floating>, CRL),
PD1: (pd1, 1, Input<Floating>, CRL),
PD2: (pd2, 2, Input<Floating>, CRL),
PD3: (pd3, 3, Input<Floating>, CRL),
PD4: (pd4, 4, Input<Floating>, CRL),
PD5: (pd5, 5, Input<Floating>, CRL),
PD6: (pd6, 6, Input<Floating>, CRL),
PD7: (pd7, 7, Input<Floating>, CRL),
PD8: (pd8, 8, Input<Floating>, CRH),
PD9: (pd9, 9, Input<Floating>, CRH),
PD10: (pd10, 10, Input<Floating>, CRH),
PD11: (pd11, 11, Input<Floating>, CRH),
PD12: (pd12, 12, Input<Floating>, CRH),
PD13: (pd13, 13, Input<Floating>, CRH),
PD14: (pd14, 14, Input<Floating>, CRH),
PD15: (pd15, 15, Input<Floating>, CRH),
]);
gpio!(GPIOE, gpioe, gpioa, PEx, [
PE0: (pe0, 0, Input<Floating>, CRL),
PE1: (pe1, 1, Input<Floating>, CRL),
PE2: (pe2, 2, Input<Floating>, CRL),
PE3: (pe3, 3, Input<Floating>, CRL),
PE4: (pe4, 4, Input<Floating>, CRL),
PE5: (pe5, 5, Input<Floating>, CRL),
PE6: (pe6, 6, Input<Floating>, CRL),
PE7: (pe7, 7, Input<Floating>, CRL),
PE8: (pe8, 8, Input<Floating>, CRH),
PE9: (pe9, 9, Input<Floating>, CRH),
PE10: (pe10, 10, Input<Floating>, CRH),
PE11: (pe11, 11, Input<Floating>, CRH),
PE12: (pe12, 12, Input<Floating>, CRH),
PE13: (pe13, 13, Input<Floating>, CRH),
PE14: (pe14, 14, Input<Floating>, CRH),
PE15: (pe15, 15, Input<Floating>, CRH),
]);