nordic-dev.net/embassy
2
0
Fork 0
mirror of https://github.com/embassy-rs/embassy.git synced 2024-11-25 00:02:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

remove qei trait

Browse Source
This commit is contained in:
xoviat 2021-04-02 13:52:31 -05:00
parent 388558263b
commit 6f0fb6cab1
5 changed files with 1 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
embassy-stm32/src/f4/mod.rs
View File

@ -1,2 +1 @@
pub mod qei;
pub mod serial;

91
embassy-stm32/src/f4/qei.rs
View File

@ -1,91 +0,0 @@
use crate::interrupt;
use core::future::Future;
use core::pin::Pin;
use embassy::traits::qei::WaitForRotate;
use embedded_hal::Direction;
use stm32f4xx_hal::pac::TIM2;
use stm32f4xx_hal::{qei, qei::Pins};
pub struct Qei<T: Instance, PINS> {
_qei: qei::Qei<T, PINS>,
int: T::Interrupt,
}
impl<PINS: Pins<TIM2>> Qei<TIM2, PINS> {
pub fn tim2(tim: TIM2, pins: PINS, interrupt: interrupt::TIM2) -> Self {
let qei = qei::Qei::tim2(tim, pins);
let tim = unsafe {
&mut *(stm32f4xx_hal::stm32::TIM2::ptr()
as *mut stm32f4xx_hal::stm32::tim2::RegisterBlock)
};
/*
enable qei interrupt
*/
tim.dier.write(|w| w.uie().set_bit());
Qei {
_qei: qei,
int: interrupt,
}
}
}
impl<PINS: Pins<TIM2> + 'static> WaitForRotate for Qei<TIM2, PINS> {
type RotateFuture<'a> = impl Future<Output = Direction> + 'a;
fn wait_for_rotate<'a>(
self: Pin<&'a mut Self>,
count_down: u16,
count_up: u16,
) -> Self::RotateFuture<'a> {
let s = unsafe { self.get_unchecked_mut() };
let tim = unsafe {
&mut *(stm32f4xx_hal::stm32::TIM2::ptr()
as *mut stm32f4xx_hal::stm32::tim2::RegisterBlock)
};
/*
the interrupt will be reached at zero or the max count
write the total range to the qei.
*/
tim.arr
.write(|w| unsafe { w.bits((count_down + count_up) as u32) });
/*
set timer to the correct value in the range
*/
tim.cnt.write(|w| unsafe { w.bits(count_down as u32) });
/*
clear interrupt flag
*/
tim.sr.write(|w| w.uif().clear_bit());
async move {
embassy::util::InterruptFuture::new(&mut s.int).await;
if tim.cnt.read().bits() == 0 {
Direction::Downcounting
} else if tim.cnt.read() == count_down + count_up {
Direction::Upcounting
} else {
panic!("unexpected value")
}
}
}
}
mod sealed {
pub trait Sealed {}
}
pub trait Instance: sealed::Sealed {
type Interrupt: interrupt::Interrupt;
}
impl sealed::Sealed for TIM2 {}
impl Instance for TIM2 {
type Interrupt = interrupt::TIM2;
}

2
embassy-stm32/src/lib.rs
View File

@ -109,7 +109,7 @@ pub mod rtc;
feature = "stm32f469",
feature = "stm32f479",
))]
pub use f4::{qei, serial};
pub use f4::serial;
#[cfg(any(
feature = "stm32f401",

1
embassy-traits/src/lib.rs
View File

@ -12,6 +12,5 @@ pub mod delay;
pub mod flash;
pub mod gpio;
pub mod i2c;
pub mod qei;
pub mod spi;
pub mod uart;

22
embassy-traits/src/qei.rs
View File

@ -1,22 +0,0 @@
use core::future::Future;
use core::pin::Pin;
use embedded_hal::Direction;
// Wait for a specified number of rotations either up or down
pub trait WaitForRotate {
type RotateFuture<'a>: Future<Output = Direction> + 'a;
/// Wait for a specified number of rotations, in ticks, either up or down.
///
/// Return Direction::Upcounting if the high bound is reached.
/// Return Direction::Downcounting if the low bound is reached.
///
/// Number of ticks is encoder dependent. As an example, if we connect
/// the Bourns PEC11H-4120F-S0020, we have 20 ticks per full rotation.
/// Other encoders may vary.
fn wait_for_rotate<'a>(
self: Pin<&'a mut Self>,
count_down: u16,
count_up: u16,
) -> Self::RotateFuture<'a>;
}