239 lines
6.7 KiB
Rust
239 lines
6.7 KiB
Rust
//! Quadrature decoder (QDEC) driver.
|
|
|
|
use core::future::poll_fn;
|
|
use core::task::Poll;
|
|
|
|
use embassy_hal_common::{into_ref, PeripheralRef};
|
|
use embassy_sync::waitqueue::AtomicWaker;
|
|
|
|
use crate::gpio::sealed::Pin as _;
|
|
use crate::gpio::{AnyPin, Pin as GpioPin};
|
|
use crate::interrupt::InterruptExt;
|
|
use crate::peripherals::QDEC;
|
|
use crate::{interrupt, pac, Peripheral};
|
|
|
|
/// Quadrature decoder driver.
|
|
pub struct Qdec<'d> {
|
|
_p: PeripheralRef<'d, QDEC>,
|
|
}
|
|
|
|
/// QDEC config
|
|
#[non_exhaustive]
|
|
pub struct Config {
|
|
/// Number of samples
|
|
pub num_samples: NumSamples,
|
|
/// Sample period
|
|
pub period: SamplePeriod,
|
|
/// Set LED output pin polarity
|
|
pub led_polarity: LedPolarity,
|
|
/// Enable/disable input debounce filters
|
|
pub debounce: bool,
|
|
/// Time period the LED is switched ON prior to sampling (0..511 us).
|
|
pub led_pre_usecs: u16,
|
|
}
|
|
|
|
impl Default for Config {
|
|
fn default() -> Self {
|
|
Self {
|
|
num_samples: NumSamples::_1smpl,
|
|
period: SamplePeriod::_256us,
|
|
led_polarity: LedPolarity::ActiveHigh,
|
|
debounce: true,
|
|
led_pre_usecs: 0,
|
|
}
|
|
}
|
|
}
|
|
|
|
static WAKER: AtomicWaker = AtomicWaker::new();
|
|
|
|
impl<'d> Qdec<'d> {
|
|
/// Create a new QDEC.
|
|
pub fn new(
|
|
qdec: impl Peripheral<P = QDEC> + 'd,
|
|
irq: impl Peripheral<P = interrupt::QDEC> + 'd,
|
|
a: impl Peripheral<P = impl GpioPin> + 'd,
|
|
b: impl Peripheral<P = impl GpioPin> + 'd,
|
|
config: Config,
|
|
) -> Self {
|
|
into_ref!(a, b);
|
|
Self::new_inner(qdec, irq, a.map_into(), b.map_into(), None, config)
|
|
}
|
|
|
|
/// Create a new QDEC, with a pin for LED output.
|
|
pub fn new_with_led(
|
|
qdec: impl Peripheral<P = QDEC> + 'd,
|
|
irq: impl Peripheral<P = interrupt::QDEC> + 'd,
|
|
a: impl Peripheral<P = impl GpioPin> + 'd,
|
|
b: impl Peripheral<P = impl GpioPin> + 'd,
|
|
led: impl Peripheral<P = impl GpioPin> + 'd,
|
|
config: Config,
|
|
) -> Self {
|
|
into_ref!(a, b, led);
|
|
Self::new_inner(qdec, irq, a.map_into(), b.map_into(), Some(led.map_into()), config)
|
|
}
|
|
|
|
fn new_inner(
|
|
p: impl Peripheral<P = QDEC> + 'd,
|
|
irq: impl Peripheral<P = interrupt::QDEC> + 'd,
|
|
a: PeripheralRef<'d, AnyPin>,
|
|
b: PeripheralRef<'d, AnyPin>,
|
|
led: Option<PeripheralRef<'d, AnyPin>>,
|
|
config: Config,
|
|
) -> Self {
|
|
into_ref!(p, irq);
|
|
let r = Self::regs();
|
|
|
|
// Select pins.
|
|
a.conf().write(|w| w.input().connect().pull().pullup());
|
|
b.conf().write(|w| w.input().connect().pull().pullup());
|
|
r.psel.a.write(|w| unsafe { w.bits(a.psel_bits()) });
|
|
r.psel.b.write(|w| unsafe { w.bits(b.psel_bits()) });
|
|
if let Some(led_pin) = &led {
|
|
led_pin.conf().write(|w| w.dir().output());
|
|
r.psel.led.write(|w| unsafe { w.bits(led_pin.psel_bits()) });
|
|
}
|
|
|
|
// Enables/disable input debounce filters
|
|
r.dbfen.write(|w| match config.debounce {
|
|
true => w.dbfen().enabled(),
|
|
false => w.dbfen().disabled(),
|
|
});
|
|
|
|
// Set LED output pin polarity
|
|
r.ledpol.write(|w| match config.led_polarity {
|
|
LedPolarity::ActiveHigh => w.ledpol().active_high(),
|
|
LedPolarity::ActiveLow => w.ledpol().active_low(),
|
|
});
|
|
|
|
// Set time period the LED is switched ON prior to sampling (0..511 us).
|
|
r.ledpre
|
|
.write(|w| unsafe { w.ledpre().bits(config.led_pre_usecs.min(511)) });
|
|
|
|
// Set sample period
|
|
r.sampleper.write(|w| match config.period {
|
|
SamplePeriod::_128us => w.sampleper()._128us(),
|
|
SamplePeriod::_256us => w.sampleper()._256us(),
|
|
SamplePeriod::_512us => w.sampleper()._512us(),
|
|
SamplePeriod::_1024us => w.sampleper()._1024us(),
|
|
SamplePeriod::_2048us => w.sampleper()._2048us(),
|
|
SamplePeriod::_4096us => w.sampleper()._4096us(),
|
|
SamplePeriod::_8192us => w.sampleper()._8192us(),
|
|
SamplePeriod::_16384us => w.sampleper()._16384us(),
|
|
SamplePeriod::_32ms => w.sampleper()._32ms(),
|
|
SamplePeriod::_65ms => w.sampleper()._65ms(),
|
|
SamplePeriod::_131ms => w.sampleper()._131ms(),
|
|
});
|
|
|
|
// Enable peripheral
|
|
r.enable.write(|w| w.enable().set_bit());
|
|
|
|
// Start sampling
|
|
unsafe { r.tasks_start.write(|w| w.bits(1)) };
|
|
|
|
irq.disable();
|
|
irq.set_handler(|_| {
|
|
let r = Self::regs();
|
|
r.intenclr.write(|w| w.reportrdy().clear());
|
|
WAKER.wake();
|
|
});
|
|
irq.enable();
|
|
|
|
Self { _p: p }
|
|
}
|
|
|
|
/// Perform an asynchronous read of the decoder.
|
|
/// The returned future can be awaited to obtain the number of steps.
|
|
///
|
|
/// If the future is dropped, the read is cancelled.
|
|
///
|
|
/// # Example
|
|
///
|
|
/// ```no_run
|
|
/// let irq = interrupt::take!(QDEC);
|
|
/// let config = qdec::Config::default();
|
|
/// let mut q = Qdec::new(p.QDEC, p.P0_31, p.P0_30, config);
|
|
/// let delta = q.read().await;
|
|
/// ```
|
|
pub async fn read(&mut self) -> i16 {
|
|
let t = Self::regs();
|
|
t.intenset.write(|w| w.reportrdy().set());
|
|
unsafe { t.tasks_readclracc.write(|w| w.bits(1)) };
|
|
|
|
let value = poll_fn(|cx| {
|
|
WAKER.register(cx.waker());
|
|
if t.events_reportrdy.read().bits() == 0 {
|
|
return Poll::Pending;
|
|
} else {
|
|
t.events_reportrdy.reset();
|
|
let acc = t.accread.read().bits();
|
|
Poll::Ready(acc as i16)
|
|
}
|
|
})
|
|
.await;
|
|
value
|
|
}
|
|
|
|
fn regs() -> &'static pac::qdec::RegisterBlock {
|
|
unsafe { &*pac::QDEC::ptr() }
|
|
}
|
|
}
|
|
|
|
/// Sample period
|
|
#[derive(Debug, Eq, PartialEq, Clone, Copy)]
|
|
pub enum SamplePeriod {
|
|
/// 128 us
|
|
_128us,
|
|
/// 256 us
|
|
_256us,
|
|
/// 512 us
|
|
_512us,
|
|
/// 1024 us
|
|
_1024us,
|
|
/// 2048 us
|
|
_2048us,
|
|
/// 4096 us
|
|
_4096us,
|
|
/// 8192 us
|
|
_8192us,
|
|
/// 16384 us
|
|
_16384us,
|
|
/// 32 ms
|
|
_32ms,
|
|
/// 65 ms
|
|
_65ms,
|
|
/// 131 ms
|
|
_131ms,
|
|
}
|
|
|
|
/// Number of samples taken.
|
|
#[derive(Debug, Eq, PartialEq, Clone, Copy)]
|
|
pub enum NumSamples {
|
|
/// 10 samples
|
|
_10smpl,
|
|
/// 40 samples
|
|
_40smpl,
|
|
/// 80 samples
|
|
_80smpl,
|
|
/// 120 samples
|
|
_120smpl,
|
|
/// 160 samples
|
|
_160smpl,
|
|
/// 200 samples
|
|
_200smpl,
|
|
/// 240 samples
|
|
_240smpl,
|
|
/// 280 samples
|
|
_280smpl,
|
|
/// 1 sample
|
|
_1smpl,
|
|
}
|
|
|
|
/// LED polarity
|
|
#[derive(Debug, Eq, PartialEq, Clone, Copy)]
|
|
pub enum LedPolarity {
|
|
/// Active high (a high output turns on the LED).
|
|
ActiveHigh,
|
|
/// Active low (a low output turns on the LED).
|
|
ActiveLow,
|
|
}
|