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

cfg! macro didn't work, had to duplicate functions with different guards

Browse Source
This commit is contained in:
Andres Oliva 2023-10-11 23:39:24 +02:00
parent ee5ea7aa06
commit f76d50e837
1 changed files with 29 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
embassy-stm32/src/i2c/v2.rs
View File

@ -7,6 +7,7 @@ use embassy_embedded_hal::SetConfig;
use embassy_hal_internal::drop::OnDrop; use embassy_hal_internal::drop::OnDrop;
use embassy_hal_internal::{into_ref, PeripheralRef}; use embassy_hal_internal::{into_ref, PeripheralRef};
use embassy_sync::waitqueue::AtomicWaker; use embassy_sync::waitqueue::AtomicWaker;
#[cfg(feature = "time")]
use embassy_time::{Duration, Instant}; use embassy_time::{Duration, Instant};
use crate::dma::{NoDma, Transfer}; use crate::dma::{NoDma, Transfer};
@ -759,12 +760,14 @@ impl<'d, T: Instance, TXDMA, RXDMA> I2c<'d, T, TXDMA, RXDMA> {
// Automatic Stop // Automatic Stop
} }
#[cfg(feature = "time")]
pub fn blocking_read(&mut self, address: u8, read: &mut [u8]) -> Result<(), Error> { pub fn blocking_read(&mut self, address: u8, read: &mut [u8]) -> Result<(), Error> {
if cfg!(feature = "time") { self.blocking_read_timeout(address, read, self.timeout)
self.blocking_read_timeout(address, read, self.timeout) }
} else {
self.blocking_read_timeout(address, read, || Ok(())) #[cfg(not(feature = "time"))]
} pub fn blocking_read(&mut self, address: u8, read: &mut [u8]) -> Result<(), Error> {
self.blocking_read_timeout(address, read, || Ok(()))
} }
#[cfg(feature = "time")] #[cfg(feature = "time")]
@ -782,12 +785,14 @@ impl<'d, T: Instance, TXDMA, RXDMA> I2c<'d, T, TXDMA, RXDMA> {
self.write_internal(address, write, true, check_timeout) self.write_internal(address, write, true, check_timeout)
} }
#[cfg(feature = "time")]
pub fn blocking_write(&mut self, address: u8, write: &[u8]) -> Result<(), Error> { pub fn blocking_write(&mut self, address: u8, write: &[u8]) -> Result<(), Error> {
if cfg!(feature = "time") { self.blocking_write_timeout(address, write, self.timeout)
self.blocking_write_timeout(address, write, self.timeout) }
} else {
self.blocking_write_timeout(address, write, || Ok(())) #[cfg(not(feature = "time"))]
} pub fn blocking_write(&mut self, address: u8, write: &[u8]) -> Result<(), Error> {
self.blocking_write_timeout(address, write, || Ok(()))
} }
#[cfg(feature = "time")] #[cfg(feature = "time")]
@ -812,18 +817,19 @@ impl<'d, T: Instance, TXDMA, RXDMA> I2c<'d, T, TXDMA, RXDMA> {
read: &mut [u8], read: &mut [u8],
check_timeout: impl Fn() -> Result<(), Error>, check_timeout: impl Fn() -> Result<(), Error>,
) -> Result<(), Error> { ) -> Result<(), Error> {
let check_timeout = timeout_fn(timeout);
self.write_internal(address, write, false, &check_timeout)?; self.write_internal(address, write, false, &check_timeout)?;
self.read_internal(address, read, true, &check_timeout) self.read_internal(address, read, true, &check_timeout)
// Automatic Stop // Automatic Stop
} }
#[cfg(feature = "time")]
pub fn blocking_write_read(&mut self, address: u8, write: &[u8], read: &mut [u8]) -> Result<(), Error> { pub fn blocking_write_read(&mut self, address: u8, write: &[u8], read: &mut [u8]) -> Result<(), Error> {
if cfg!(feature = "time") { self.blocking_write_read_timeout(address, write, read, self.timeout)
self.blocking_write_read_timeout(address, write, read, self.timeout) }
} else {
self.blocking_write_read_timeout(address, write, read, || Ok(())) #[cfg(not(feature = "time"))]
} pub fn blocking_write_read(&mut self, address: u8, write: &[u8], read: &mut [u8]) -> Result<(), Error> {
self.blocking_write_read_timeout(address, write, read, || Ok(()))
} }
fn blocking_write_vectored_with_timeout( fn blocking_write_vectored_with_timeout(
@ -925,12 +931,14 @@ impl<'d, T: Instance, TXDMA, RXDMA> I2c<'d, T, TXDMA, RXDMA> {
self.blocking_write_vectored_with_timeout(address, write, check_timeout) self.blocking_write_vectored_with_timeout(address, write, check_timeout)
} }
#[cfg(feature = "time")]
pub fn blocking_write_vectored(&mut self, address: u8, write: &[&[u8]]) -> Result<(), Error> { pub fn blocking_write_vectored(&mut self, address: u8, write: &[&[u8]]) -> Result<(), Error> {
if cfg!(feature = "time") { self.blocking_write_vectored_timeout(address, write, self.timeout)
self.blocking_write_vectored_timeout(address, write, self.timeout) }
} else {
self.blocking_write_vectored_timeout(address, write, || Ok(())) #[cfg(not(feature = "time"))]
} pub fn blocking_write_vectored(&mut self, address: u8, write: &[&[u8]]) -> Result<(), Error> {
self.blocking_write_vectored_timeout(address, write, || Ok(()))
} }
} }