max/embassy
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

nrf/gpiote: new api: switch to owned structs, implement WaitForHigh/WaitForLow.

Browse Source
This commit is contained in:
Dario Nieuwenhuis 2021-02-04 23:56:17 +01:00
parent 1879703153
commit a7797a918d
3 changed files with 324 additions and 329 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
embassy-nrf-examples/src/bin/gpiote.rs → embassy-nrf-examples/src/bin/gpiote_channel.rs
View File

@ -12,7 +12,7 @@ use nrf52840_hal::gpio;
use embassy::executor::{task, Executor};
use embassy::util::Forever;
use embassy_nrf::gpiote;
use embassy_nrf::gpiote::{Channels, Gpiote, InputChannel, InputChannelPolarity};
use embassy_nrf::interrupt;
#[task]
@ -20,46 +20,44 @@ async fn run() {
let p = unwrap!(embassy_nrf::pac::Peripherals::take());
let port0 = gpio::p0::Parts::new(p.P0);
let g = gpiote::Gpiote::new(p.GPIOTE, interrupt::take!(GPIOTE));
let (g, chs) = Gpiote::new(p.GPIOTE, interrupt::take!(GPIOTE));
info!("Starting!");
let pin1 = port0.p0_11.into_pullup_input().degrade();
let button1 = async {
let ch = unwrap!(g.new_input_channel(pin1, gpiote::InputChannelPolarity::HiToLo));
let pin2 = port0.p0_12.into_pullup_input().degrade();
let pin3 = port0.p0_24.into_pullup_input().degrade();
let pin4 = port0.p0_25.into_pullup_input().degrade();
let ch1 = InputChannel::new(g, chs.ch0, pin1, InputChannelPolarity::HiToLo);
let ch2 = InputChannel::new(g, chs.ch1, pin2, InputChannelPolarity::LoToHi);
let ch3 = InputChannel::new(g, chs.ch2, pin3, InputChannelPolarity::Toggle);
let ch4 = InputChannel::new(g, chs.ch3, pin4, InputChannelPolarity::Toggle);
let button1 = async {
loop {
ch.wait().await;
ch1.wait().await;
info!("Button 1 pressed")
}
};
let pin2 = port0.p0_12.into_pullup_input().degrade();
let button2 = async {
let ch = unwrap!(g.new_input_channel(pin2, gpiote::InputChannelPolarity::LoToHi));
loop {
ch.wait().await;
ch2.wait().await;
info!("Button 2 released")
}
};
let pin3 = port0.p0_24.into_pullup_input().degrade();
let button3 = async {
let ch = unwrap!(g.new_input_channel(pin3, gpiote::InputChannelPolarity::Toggle));
loop {
ch.wait().await;
ch3.wait().await;
info!("Button 3 toggled")
}
};
let pin4 = port0.p0_25.into_pullup_input().degrade();
let button4 = async {
let ch = unwrap!(g.new_input_channel(pin4, gpiote::InputChannelPolarity::Toggle));
loop {
ch.wait().await;
ch4.wait().await;
info!("Button 4 toggled")
}
};

39
embassy-nrf-examples/src/bin/gpiote_port.rs
View File

@ -7,20 +7,22 @@ mod example_common;
use example_common::*;
use core::mem;
use core::pin::Pin;
use cortex_m_rt::entry;
use defmt::panic;
use nrf52840_hal::gpio;
use embassy::executor::{task, Executor};
use embassy::gpio::{WaitForHigh, WaitForLow};
use embassy::util::Forever;
use embassy_nrf::gpiote::{Gpiote, PortInputPolarity};
use embassy_nrf::gpiote::{Gpiote, GpiotePin};
use embassy_nrf::interrupt;
async fn button(g: &Gpiote, n: usize, pin: gpio::Pin<gpio::Input<gpio::PullUp>>) {
async fn button(n: usize, mut pin: GpiotePin<gpio::PullUp>) {
loop {
g.wait_port_input(&pin, PortInputPolarity::Low).await;
Pin::new(&mut pin).wait_for_low().await;
info!("Button {:?} pressed!", n);
g.wait_port_input(&pin, PortInputPolarity::High).await;
Pin::new(&mut pin).wait_for_high().await;
info!("Button {:?} released!", n);
}
}
@ -30,19 +32,24 @@ async fn run() {
let p = unwrap!(embassy_nrf::pac::Peripherals::take());
let port0 = gpio::p0::Parts::new(p.P0);
let g = Gpiote::new(p.GPIOTE, interrupt::take!(GPIOTE));
info!(
"sizeof Signal<()> = {:usize}",
mem::size_of::<embassy::util::Signal<()>>()
let (g, _) = Gpiote::new(p.GPIOTE, interrupt::take!(GPIOTE));
let button1 = button(
1,
GpiotePin::new(g, port0.p0_11.into_pullup_input().degrade()),
);
let button2 = button(
2,
GpiotePin::new(g, port0.p0_12.into_pullup_input().degrade()),
);
let button3 = button(
3,
GpiotePin::new(g, port0.p0_24.into_pullup_input().degrade()),
);
let button4 = button(
4,
GpiotePin::new(g, port0.p0_25.into_pullup_input().degrade()),
);
info!("sizeof gpiote = {:usize}", mem::size_of::<Gpiote>());
info!("Starting!");
let button1 = button(&g, 1, port0.p0_11.into_pullup_input().degrade());
let button2 = button(&g, 2, port0.p0_12.into_pullup_input().degrade());
let button3 = button(&g, 3, port0.p0_24.into_pullup_input().degrade());
let button4 = button(&g, 4, port0.p0_25.into_pullup_input().degrade());
futures::join!(button1, button2, button3, button4);
}

600
embassy-nrf/src/gpiote.rs
View File

@ -1,18 +1,20 @@
use crate::fmt::{panic, *};
use core::cell::Cell;
use core::future::Future;
use core::mem::ManuallyDrop;
use core::ops::Deref;
use core::pin::Pin;
use core::ptr;
use core::task::{Context, Poll};
use embassy::gpio::{WaitForHigh, WaitForLow};
use embassy::util::Signal;
use crate::hal::gpio::{Input, Level, Output, Pin, Port};
use crate::fmt::{panic, *};
use crate::hal::gpio::{Input, Level, Output, Pin as GpioPin, Port};
use crate::interrupt;
use crate::interrupt::OwnedInterrupt;
use crate::pac;
use crate::pac::generic::Reg;
use crate::pac::gpiote::_TASKS_OUT;
#[cfg(any(feature = "52833", feature = "52840"))]
use crate::pac::P1;
use crate::pac::{p0 as gpio, GPIOTE, P0};
use crate::pac::{p0 as pac_gpio, GPIOTE};
#[cfg(not(feature = "51"))]
use crate::pac::gpiote::{_TASKS_CLR, _TASKS_SET};
@ -24,20 +26,51 @@ pub const PIN_COUNT: usize = 48;
#[cfg(not(any(feature = "52833", feature = "52840")))]
pub const PIN_COUNT: usize = 32;
pub struct Gpiote {
inner: GPIOTE,
free_channels: Cell<u8>, // 0 = used, 1 = free. 8 bits for 8 channelself.
channel_signals: [Signal<()>; CHANNEL_COUNT],
port_signals: [Signal<()>; PIN_COUNT],
pub trait ChannelID {
fn number(&self) -> usize;
}
static mut INSTANCE: *const Gpiote = ptr::null_mut();
macro_rules! impl_channel {
($ChX:ident, $n:expr) => {
pub struct $ChX(());
impl $ChX {
pub fn degrade(self) -> ChAny {
ChAny($n)
}
}
pub enum PortInputPolarity {
High,
Low,
impl ChannelID for $ChX {
fn number(&self) -> usize {
$n
}
}
};
}
impl_channel!(Ch0, 0);
impl_channel!(Ch1, 1);
impl_channel!(Ch2, 2);
impl_channel!(Ch3, 3);
impl_channel!(Ch4, 4);
impl_channel!(Ch5, 5);
impl_channel!(Ch6, 6);
impl_channel!(Ch7, 7);
pub struct ChAny(u8);
impl ChannelID for ChAny {
fn number(&self) -> usize {
self.0 as usize
}
}
#[derive(Clone, Copy)]
pub struct Gpiote(());
const NEW_SIGNAL: Signal<()> = Signal::new();
static CHANNEL_SIGNALS: [Signal<()>; CHANNEL_COUNT] = [NEW_SIGNAL; CHANNEL_COUNT];
static PORT_SIGNALS: [Signal<()>; PIN_COUNT] = [NEW_SIGNAL; PIN_COUNT];
pub enum InputChannelPolarity {
None,
HiToLo,
@ -58,12 +91,23 @@ pub enum NewChannelError {
NoFreeChannels,
}
pub struct Channels {
pub ch0: Ch0,
pub ch1: Ch1,
pub ch2: Ch2,
pub ch3: Ch3,
pub ch4: Ch4,
pub ch5: Ch5,
pub ch6: Ch6,
pub ch7: Ch7,
}
impl Gpiote {
pub fn new(gpiote: GPIOTE, irq: interrupt::GPIOTEInterrupt) -> Self {
pub fn new(gpiote: GPIOTE, irq: interrupt::GPIOTEInterrupt) -> (Self, Channels) {
#[cfg(any(feature = "52833", feature = "52840"))]
let ports = unsafe { &[&*P0::ptr(), &*P1::ptr()] };
let ports = unsafe { &[&*pac::P0::ptr(), &*pac::P1::ptr()] };
#[cfg(not(any(feature = "52833", feature = "52840")))]
let ports = unsafe { &[&*P0::ptr()] };
let ports = unsafe { &[&*pac::P0::ptr()] };
for &p in ports {
// Enable latched detection
@ -79,158 +123,104 @@ impl Gpiote {
irq.unpend();
irq.enable();
Self {
inner: gpiote,
free_channels: Cell::new(0xFF), // all 8 channels free
channel_signals: [
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
],
// This is just horrible
(
Self(()),
Channels {
ch0: Ch0(()),
ch1: Ch1(()),
ch2: Ch2(()),
ch3: Ch3(()),
ch4: Ch4(()),
ch5: Ch5(()),
ch6: Ch6(()),
ch7: Ch7(()),
},
)
}
unsafe fn on_irq(_ctx: *mut ()) {
let g = &*GPIOTE::ptr();
for i in 0..8 {
if g.events_in[i].read().bits() != 0 {
g.events_in[i].write(|w| w);
CHANNEL_SIGNALS[i].signal(());
}
}
if g.events_port.read().bits() != 0 {
g.events_port.write(|w| w);
#[cfg(any(feature = "52833", feature = "52840"))]
port_signals: [
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
],
let ports = &[&*pac::P0::ptr(), &*pac::P1::ptr()];
#[cfg(not(any(feature = "52833", feature = "52840")))]
port_signals: [
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
Signal::new(),
],
}
}
let ports = &[&*pac::P0::ptr()];
fn allocate_channel(&self) -> Result<u8, NewChannelError> {
interrupt::free(|_| {
let chs = self.free_channels.get();
let index = chs.trailing_zeros() as usize;
if index == 8 {
return Err(NewChannelError::NoFreeChannels);
let mut work = true;
while work {
work = false;
for (port, &p) in ports.iter().enumerate() {
for pin in BitIter(p.latch.read().bits()) {
work = true;
p.pin_cnf[pin as usize].modify(|_, w| w.sense().disabled());
p.latch.write(|w| w.bits(1 << pin));
PORT_SIGNALS[port * 32 + pin as usize].signal(());
}
self.free_channels.set(chs & !(1 << index));
Ok(index as u8)
})
}
}
}
}
}
fn free_channel(&self, index: u8) {
interrupt::free(|_| {
self.inner.config[index as usize].write(|w| w.mode().disabled());
self.inner.intenclr.write(|w| unsafe { w.bits(1 << index) });
fn pin_num<T>(pin: &GpioPin<T>) -> usize {
let port = match pin.port() {
Port::Port0 => 0,
#[cfg(any(feature = "52833", feature = "52840"))]
Port::Port1 => 32,
};
self.free_channels
.set(self.free_channels.get() | 1 << index);
trace!("freed ch {:?}", index);
})
}
port + pin.pin() as usize
}
pub fn wait_port_input<'a, T>(
&'a self,
pin: &'a Pin<Input<T>>,
polarity: PortInputPolarity,
) -> PortInputFuture<'a, T> {
interrupt::free(|_| {
unsafe { INSTANCE = self };
PortInputFuture {
gpiote: self,
pin,
polarity,
}
})
}
fn pin_block<T>(pin: &GpioPin<T>) -> &pac_gpio::RegisterBlock {
let ptr = match pin.port() {
Port::Port0 => pac::P0::ptr(),
#[cfg(any(feature = "52833", feature = "52840"))]
Port::Port1 => pac::P1::ptr(),
};
pub fn new_input_channel<'a, T>(
&'a self,
pin: Pin<Input<T>>,
unsafe { &*ptr }
}
fn pin_conf<T>(pin: &GpioPin<T>) -> &pac_gpio::PIN_CNF {
&pin_block(pin).pin_cnf[pin.pin() as usize]
}
pub struct InputChannel<C: ChannelID, T> {
ch: C,
pin: GpioPin<Input<T>>,
}
impl<C: ChannelID, T> Drop for InputChannel<C, T> {
fn drop(&mut self) {
let g = unsafe { &*GPIOTE::ptr() };
let index = self.ch.number();
g.config[index].write(|w| w.mode().disabled());
g.intenclr.write(|w| unsafe { w.bits(1 << index) });
}
}
impl<C: ChannelID, T> InputChannel<C, T> {
pub fn new(
_gpiote: Gpiote,
ch: C,
pin: GpioPin<Input<T>>,
polarity: InputChannelPolarity,
) -> Result<InputChannel<'a, T>, NewChannelError> {
interrupt::free(|_| {
unsafe { INSTANCE = self };
let index = self.allocate_channel()?;
trace!("allocated in ch {:?}", index as u8);
) -> Self {
let g = unsafe { &*GPIOTE::ptr() };
let index = ch.number();
self.inner.config[index as usize].write(|w| {
g.config[index].write(|w| {
match polarity {
InputChannelPolarity::HiToLo => w.mode().event().polarity().hi_to_lo(),
InputChannelPolarity::LoToHi => w.mode().event().polarity().lo_to_hi(),
@ -245,29 +235,57 @@ impl Gpiote {
unsafe { w.psel().bits(pin.pin()) }
});
// Enable interrupt
self.inner.intenset.write(|w| unsafe { w.bits(1 << index) });
CHANNEL_SIGNALS[index].reset();
Ok(InputChannel {
gpiote: self,
index,
pin,
})
})
// Enable interrupt
g.intenset.write(|w| unsafe { w.bits(1 << index) });
InputChannel { ch, pin }
}
pub fn new_output_channel<'a, T>(
&'a self,
pin: Pin<Output<T>>,
pub fn free(self) -> (C, GpioPin<Input<T>>) {
let m = ManuallyDrop::new(self);
let ch = unsafe { ptr::read(&m.ch) };
let pin = unsafe { ptr::read(&m.pin) };
(ch, pin)
}
pub async fn wait(&self) {
let index = self.ch.number();
CHANNEL_SIGNALS[index].wait().await;
}
pub fn pin(&self) -> &GpioPin<Input<T>> {
&self.pin
}
}
pub struct OutputChannel<C: ChannelID, T> {
ch: C,
pin: GpioPin<Output<T>>,
}
impl<C: ChannelID, T> Drop for OutputChannel<C, T> {
fn drop(&mut self) {
let g = unsafe { &*GPIOTE::ptr() };
let index = self.ch.number();
g.config[index].write(|w| w.mode().disabled());
g.intenclr.write(|w| unsafe { w.bits(1 << index) });
}
}
impl<C: ChannelID, T> OutputChannel<C, T> {
pub fn new(
_gpiote: Gpiote,
ch: C,
pin: GpioPin<Output<T>>,
level: Level,
polarity: OutputChannelPolarity,
) -> Result<OutputChannel<'a>, NewChannelError> {
interrupt::free(|_| {
unsafe { INSTANCE = self };
let index = self.allocate_channel()?;
trace!("allocated out ch {:?}", index);
) -> Self {
let g = unsafe { &*GPIOTE::ptr() };
let index = ch.number();
self.inner.config[index as usize].write(|w| {
g.config[index].write(|w| {
w.mode().task();
match level {
Level::High => w.outinit().high(),
@ -287,164 +305,66 @@ impl Gpiote {
});
// Enable interrupt
self.inner.intenset.write(|w| unsafe { w.bits(1 << index) });
g.intenset.write(|w| unsafe { w.bits(1 << index) });
Ok(OutputChannel {
gpiote: self,
index,
})
})
OutputChannel { ch, pin }
}
unsafe fn on_irq(_ctx: *mut ()) {
let s = &(*INSTANCE);
for i in 0..8 {
if s.inner.events_in[i].read().bits() != 0 {
s.inner.events_in[i].write(|w| w);
s.channel_signals[i].signal(());
}
pub fn free(self) -> (C, GpioPin<Output<T>>) {
let m = ManuallyDrop::new(self);
let ch = unsafe { ptr::read(&m.ch) };
let pin = unsafe { ptr::read(&m.pin) };
(ch, pin)
}
if s.inner.events_port.read().bits() != 0 {
s.inner.events_port.write(|w| w);
#[cfg(any(feature = "52833", feature = "52840"))]
let ports = &[&*P0::ptr(), &*P1::ptr()];
#[cfg(not(any(feature = "52833", feature = "52840")))]
let ports = &[&*P0::ptr()];
let mut work = true;
while work {
work = false;
for (port, &p) in ports.iter().enumerate() {
for pin in BitIter(p.latch.read().bits()) {
work = true;
p.pin_cnf[pin as usize].modify(|_, w| w.sense().disabled());
p.latch.write(|w| w.bits(1 << pin));
s.port_signals[port * 32 + pin as usize].signal(());
}
}
}
}
}
}
pub struct PortInputFuture<'a, T> {
gpiote: &'a Gpiote,
pin: &'a Pin<Input<T>>,
polarity: PortInputPolarity,
}
impl<'a, T> Drop for PortInputFuture<'a, T> {
fn drop(&mut self) {
pin_conf(&self.pin).modify(|_, w| w.sense().disabled());
self.gpiote.port_signals[pin_num(&self.pin)].reset();
}
}
impl<'a, T> Future for PortInputFuture<'a, T> {
type Output = ();
fn poll(self: core::pin::Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
pin_conf(&self.pin).modify(|_, w| match self.polarity {
PortInputPolarity::Low => w.sense().low(),
PortInputPolarity::High => w.sense().high(),
});
self.gpiote.port_signals[pin_num(&self.pin)].poll_wait(cx)
}
}
fn pin_num<T>(pin: &Pin<T>) -> usize {
let port = match pin.port() {
Port::Port0 => 0,
#[cfg(any(feature = "52833", feature = "52840"))]
Port::Port1 => 32,
};
port + pin.pin() as usize
}
fn pin_block<T>(pin: &Pin<T>) -> &gpio::RegisterBlock {
let ptr = match pin.port() {
Port::Port0 => P0::ptr(),
#[cfg(any(feature = "52833", feature = "52840"))]
Port::Port1 => P1::ptr(),
};
unsafe { &*ptr }
}
fn pin_conf<T>(pin: &Pin<T>) -> &gpio::PIN_CNF {
&pin_block(pin).pin_cnf[pin.pin() as usize]
}
pub struct InputChannel<'a, T> {
gpiote: &'a Gpiote,
pin: Pin<Input<T>>,
index: u8,
}
impl<'a, T> Drop for InputChannel<'a, T> {
fn drop(&mut self) {
self.gpiote.free_channel(self.index);
}
}
impl<'a, T> InputChannel<'a, T> {
pub async fn wait(&self) {
self.gpiote.channel_signals[self.index as usize]
.wait()
.await;
}
pub fn pin(&self) -> &Pin<Input<T>> {
&self.pin
}
}
pub struct OutputChannel<'a> {
gpiote: &'a Gpiote,
index: u8,
}
impl<'a> Drop for OutputChannel<'a> {
fn drop(&mut self) {
self.gpiote.free_channel(self.index);
}
}
impl<'a> OutputChannel<'a> {
/// Triggers `task out` (as configured with task_out_polarity, defaults to Toggle).
pub fn out(&self) {
self.gpiote.inner.tasks_out[self.index as usize].write(|w| unsafe { w.bits(1) });
let g = unsafe { &*GPIOTE::ptr() };
let index = self.ch.number();
g.tasks_out[index].write(|w| unsafe { w.bits(1) });
}
/// Triggers `task set` (set associated pin high).
#[cfg(not(feature = "51"))]
pub fn set(&self) {
self.gpiote.inner.tasks_set[self.index as usize].write(|w| unsafe { w.bits(1) });
let g = unsafe { &*GPIOTE::ptr() };
let index = self.ch.number();
g.tasks_set[index].write(|w| unsafe { w.bits(1) });
}
/// Triggers `task clear` (set associated pin low).
#[cfg(not(feature = "51"))]
pub fn clear(&self) {
self.gpiote.inner.tasks_clr[self.index as usize].write(|w| unsafe { w.bits(1) });
let g = unsafe { &*GPIOTE::ptr() };
let index = self.ch.number();
g.tasks_clr[index].write(|w| unsafe { w.bits(1) });
}
/// Returns reference to task_out endpoint for PPI.
pub fn task_out(&self) -> &Reg<u32, _TASKS_OUT> {
&self.gpiote.inner.tasks_out[self.index as usize]
let g = unsafe { &*GPIOTE::ptr() };
let index = self.ch.number();
&g.tasks_out[index]
}
/// Returns reference to task_clr endpoint for PPI.
#[cfg(not(feature = "51"))]
pub fn task_clr(&self) -> &Reg<u32, _TASKS_CLR> {
&self.gpiote.inner.tasks_clr[self.index as usize]
let g = unsafe { &*GPIOTE::ptr() };
let index = self.ch.number();
&g.tasks_clr[index]
}
/// Returns reference to task_set endpoint for PPI.
#[cfg(not(feature = "51"))]
pub fn task_set(&self) -> &Reg<u32, _TASKS_SET> {
&self.gpiote.inner.tasks_set[self.index as usize]
let g = unsafe { &*GPIOTE::ptr() };
let index = self.ch.number();
&g.tasks_set[index]
}
}
@ -463,3 +383,73 @@ impl Iterator for BitIter {
}
}
}
pub struct GpiotePin<T> {
pin: GpioPin<Input<T>>,
}
impl<T> Unpin for GpiotePin<T> {}
impl<T> GpiotePin<T> {
pub fn new(_gpiote: Gpiote, pin: GpioPin<Input<T>>) -> Self {
Self { pin }
}
}
impl<T: 'static> WaitForHigh for GpiotePin<T> {
type Future<'a> = PortInputFuture<'a, T>;
fn wait_for_high<'a>(self: Pin<&'a mut Self>) -> Self::Future<'a> {
PortInputFuture {
pin: &self.get_mut().pin,
polarity: PortInputPolarity::High,
}
}
}
impl<T: 'static> WaitForLow for GpiotePin<T> {
type Future<'a> = PortInputFuture<'a, T>;
fn wait_for_low<'a>(self: Pin<&'a mut Self>) -> Self::Future<'a> {
PortInputFuture {
pin: &self.get_mut().pin,
polarity: PortInputPolarity::Low,
}
}
}
impl<T> Deref for GpiotePin<T> {
type Target = GpioPin<Input<T>>;
fn deref(&self) -> &Self::Target {
&self.pin
}
}
enum PortInputPolarity {
High,
Low,
}
pub struct PortInputFuture<'a, T> {
pin: &'a GpioPin<Input<T>>,
polarity: PortInputPolarity,
}
impl<'a, T> Drop for PortInputFuture<'a, T> {
fn drop(&mut self) {
pin_conf(&self.pin).modify(|_, w| w.sense().disabled());
PORT_SIGNALS[pin_num(&self.pin)].reset();
}
}
impl<'a, T> Future for PortInputFuture<'a, T> {
type Output = ();
fn poll(self: core::pin::Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
pin_conf(&self.pin).modify(|_, w| match self.polarity {
PortInputPolarity::Low => w.sense().low(),
PortInputPolarity::High => w.sense().high(),
});
PORT_SIGNALS[pin_num(&self.pin)].poll_wait(cx)
}
}