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

Merge pull request #1950 from embassy-rs/stm32-test-cleanup

Browse Source 
stm32/usart: return error instead of panicking on bad baudrate.
This commit is contained in:
Dario Nieuwenhuis 2023-09-25 22:21:29 +00:00 committed by GitHub
commit e8587e2fba
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
22 changed files with 94 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
embassy-stm32/src/usart/buffered.rs
View File

@ -118,7 +118,7 @@ impl<'d, T: BasicInstance> SetConfig for BufferedUart<'d, T> {
type Config = Config; type Config = Config;
fn set_config(&mut self, config: &Self::Config) { fn set_config(&mut self, config: &Self::Config) {
self.set_config(config) unwrap!(self.set_config(config))
} }
} }
@ -126,7 +126,7 @@ impl<'d, T: BasicInstance> SetConfig for BufferedUartRx<'d, T> {
type Config = Config; type Config = Config;
fn set_config(&mut self, config: &Self::Config) { fn set_config(&mut self, config: &Self::Config) {
self.set_config(config) unwrap!(self.set_config(config))
} }
} }
@ -134,7 +134,7 @@ impl<'d, T: BasicInstance> SetConfig for BufferedUartTx<'d, T> {
type Config = Config; type Config = Config;
fn set_config(&mut self, config: &Self::Config) { fn set_config(&mut self, config: &Self::Config) {
self.set_config(config) unwrap!(self.set_config(config))
} }
} }
@ -147,7 +147,7 @@ impl<'d, T: BasicInstance> BufferedUart<'d, T> {
tx_buffer: &'d mut [u8], tx_buffer: &'d mut [u8],
rx_buffer: &'d mut [u8], rx_buffer: &'d mut [u8],
config: Config, config: Config,
) -> BufferedUart<'d, T> { ) -> Result<Self, ConfigError> {
// UartRx and UartTx have one refcount ea. // UartRx and UartTx have one refcount ea.
T::enable(); T::enable();
T::enable(); T::enable();
@ -166,7 +166,7 @@ impl<'d, T: BasicInstance> BufferedUart<'d, T> {
tx_buffer: &'d mut [u8], tx_buffer: &'d mut [u8],
rx_buffer: &'d mut [u8], rx_buffer: &'d mut [u8],
config: Config, config: Config,
) -> BufferedUart<'d, T> { ) -> Result<Self, ConfigError> {
into_ref!(cts, rts); into_ref!(cts, rts);
// UartRx and UartTx have one refcount ea. // UartRx and UartTx have one refcount ea.
@ -194,7 +194,7 @@ impl<'d, T: BasicInstance> BufferedUart<'d, T> {
tx_buffer: &'d mut [u8], tx_buffer: &'d mut [u8],
rx_buffer: &'d mut [u8], rx_buffer: &'d mut [u8],
config: Config, config: Config,
) -> BufferedUart<'d, T> { ) -> Result<Self, ConfigError> {
into_ref!(de); into_ref!(de);
// UartRx and UartTx have one refcount ea. // UartRx and UartTx have one refcount ea.
@ -217,7 +217,7 @@ impl<'d, T: BasicInstance> BufferedUart<'d, T> {
tx_buffer: &'d mut [u8], tx_buffer: &'d mut [u8],
rx_buffer: &'d mut [u8], rx_buffer: &'d mut [u8],
config: Config, config: Config,
) -> BufferedUart<'d, T> { ) -> Result<Self, ConfigError> {
into_ref!(_peri, rx, tx); into_ref!(_peri, rx, tx);
let state = T::buffered_state(); let state = T::buffered_state();
@ -230,7 +230,7 @@ impl<'d, T: BasicInstance> BufferedUart<'d, T> {
rx.set_as_af(rx.af_num(), AFType::Input); rx.set_as_af(rx.af_num(), AFType::Input);
tx.set_as_af(tx.af_num(), AFType::OutputPushPull); tx.set_as_af(tx.af_num(), AFType::OutputPushPull);
configure(r, &config, T::frequency(), T::KIND, true, true); configure(r, &config, T::frequency(), T::KIND, true, true)?;
r.cr1().modify(|w| { r.cr1().modify(|w| {
#[cfg(lpuart_v2)] #[cfg(lpuart_v2)]
@ -243,17 +243,17 @@ impl<'d, T: BasicInstance> BufferedUart<'d, T> {
T::Interrupt::unpend(); T::Interrupt::unpend();
unsafe { T::Interrupt::enable() }; unsafe { T::Interrupt::enable() };
Self { Ok(Self {
rx: BufferedUartRx { phantom: PhantomData }, rx: BufferedUartRx { phantom: PhantomData },
tx: BufferedUartTx { phantom: PhantomData }, tx: BufferedUartTx { phantom: PhantomData },
} })
} }
pub fn split(self) -> (BufferedUartTx<'d, T>, BufferedUartRx<'d, T>) { pub fn split(self) -> (BufferedUartTx<'d, T>, BufferedUartRx<'d, T>) {
(self.tx, self.rx) (self.tx, self.rx)
} }
pub fn set_config(&mut self, config: &Config) { pub fn set_config(&mut self, config: &Config) -> Result<(), ConfigError> {
reconfigure::<T>(config) reconfigure::<T>(config)
} }
} }
@ -333,7 +333,7 @@ impl<'d, T: BasicInstance> BufferedUartRx<'d, T> {
} }
} }
pub fn set_config(&mut self, config: &Config) { pub fn set_config(&mut self, config: &Config) -> Result<(), ConfigError> {
reconfigure::<T>(config) reconfigure::<T>(config)
} }
} }
@ -407,7 +407,7 @@ impl<'d, T: BasicInstance> BufferedUartTx<'d, T> {
} }
} }
pub fn set_config(&mut self, config: &Config) { pub fn set_config(&mut self, config: &Config) -> Result<(), ConfigError> {
reconfigure::<T>(config) reconfigure::<T>(config)
} }
} }

87
embassy-stm32/src/usart/mod.rs
View File

@ -13,11 +13,10 @@ use futures::future::{select, Either};
use crate::dma::{NoDma, Transfer}; use crate::dma::{NoDma, Transfer};
use crate::gpio::sealed::AFType; use crate::gpio::sealed::AFType;
use crate::interrupt::typelevel::Interrupt; use crate::interrupt::typelevel::Interrupt;
#[cfg(not(any(usart_v1, usart_v2)))]
#[allow(unused_imports)] #[allow(unused_imports)]
#[cfg(not(any(usart_v1, usart_v2)))]
use crate::pac::usart::regs::Isr as Sr; use crate::pac::usart::regs::Isr as Sr;
#[cfg(any(usart_v1, usart_v2))] #[cfg(any(usart_v1, usart_v2))]
#[allow(unused_imports)]
use crate::pac::usart::regs::Sr; use crate::pac::usart::regs::Sr;
#[cfg(not(any(usart_v1, usart_v2)))] #[cfg(not(any(usart_v1, usart_v2)))]
use crate::pac::usart::Lpuart as Regs; use crate::pac::usart::Lpuart as Regs;
@ -76,12 +75,14 @@ impl<T: BasicInstance> interrupt::typelevel::Handler<T::Interrupt> for Interrupt
} }
#[derive(Clone, Copy, PartialEq, Eq, Debug)] #[derive(Clone, Copy, PartialEq, Eq, Debug)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum DataBits { pub enum DataBits {
DataBits8, DataBits8,
DataBits9, DataBits9,
} }
#[derive(Clone, Copy, PartialEq, Eq, Debug)] #[derive(Clone, Copy, PartialEq, Eq, Debug)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum Parity { pub enum Parity {
ParityNone, ParityNone,
ParityEven, ParityEven,
@ -89,6 +90,7 @@ pub enum Parity {
} }
#[derive(Clone, Copy, PartialEq, Eq, Debug)] #[derive(Clone, Copy, PartialEq, Eq, Debug)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum StopBits { pub enum StopBits {
#[doc = "1 stop bit"] #[doc = "1 stop bit"]
STOP1, STOP1,
@ -100,6 +102,14 @@ pub enum StopBits {
STOP1P5, STOP1P5,
} }
#[non_exhaustive]
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum ConfigError {
BaudrateTooLow,
BaudrateTooHigh,
}
#[non_exhaustive] #[non_exhaustive]
#[derive(Clone, Copy, PartialEq, Eq, Debug)] #[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub struct Config { pub struct Config {
@ -173,8 +183,8 @@ impl<'d, T: BasicInstance, TxDma, RxDma> SetConfig for Uart<'d, T, TxDma, RxDma>
type Config = Config; type Config = Config;
fn set_config(&mut self, config: &Self::Config) { fn set_config(&mut self, config: &Self::Config) {
self.tx.set_config(config); unwrap!(self.tx.set_config(config));
self.rx.set_config(config); unwrap!(self.rx.set_config(config));
} }
} }
@ -187,7 +197,7 @@ impl<'d, T: BasicInstance, TxDma> SetConfig for UartTx<'d, T, TxDma> {
type Config = Config; type Config = Config;
fn set_config(&mut self, config: &Self::Config) { fn set_config(&mut self, config: &Self::Config) {
self.set_config(config); unwrap!(self.set_config(config));
} }
} }
@ -203,7 +213,7 @@ impl<'d, T: BasicInstance, RxDma> SetConfig for UartRx<'d, T, RxDma> {
type Config = Config; type Config = Config;
fn set_config(&mut self, config: &Self::Config) { fn set_config(&mut self, config: &Self::Config) {
self.set_config(config); unwrap!(self.set_config(config));
} }
} }
@ -214,7 +224,7 @@ impl<'d, T: BasicInstance, TxDma> UartTx<'d, T, TxDma> {
tx: impl Peripheral<P = impl TxPin<T>> + 'd, tx: impl Peripheral<P = impl TxPin<T>> + 'd,
tx_dma: impl Peripheral<P = TxDma> + 'd, tx_dma: impl Peripheral<P = TxDma> + 'd,
config: Config, config: Config,
) -> Self { ) -> Result<Self, ConfigError> {
T::enable(); T::enable();
T::reset(); T::reset();
@ -227,7 +237,7 @@ impl<'d, T: BasicInstance, TxDma> UartTx<'d, T, TxDma> {
cts: impl Peripheral<P = impl CtsPin<T>> + 'd, cts: impl Peripheral<P = impl CtsPin<T>> + 'd,
tx_dma: impl Peripheral<P = TxDma> + 'd, tx_dma: impl Peripheral<P = TxDma> + 'd,
config: Config, config: Config,
) -> Self { ) -> Result<Self, ConfigError> {
into_ref!(cts); into_ref!(cts);
T::enable(); T::enable();
@ -245,25 +255,25 @@ impl<'d, T: BasicInstance, TxDma> UartTx<'d, T, TxDma> {
tx: impl Peripheral<P = impl TxPin<T>> + 'd, tx: impl Peripheral<P = impl TxPin<T>> + 'd,
tx_dma: impl Peripheral<P = TxDma> + 'd, tx_dma: impl Peripheral<P = TxDma> + 'd,
config: Config, config: Config,
) -> Self { ) -> Result<Self, ConfigError> {
into_ref!(_peri, tx, tx_dma); into_ref!(_peri, tx, tx_dma);
let r = T::regs(); let r = T::regs();
tx.set_as_af(tx.af_num(), AFType::OutputPushPull); tx.set_as_af(tx.af_num(), AFType::OutputPushPull);
configure(r, &config, T::frequency(), T::KIND, false, true); configure(r, &config, T::frequency(), T::KIND, false, true)?;
// create state once! // create state once!
let _s = T::state(); let _s = T::state();
Self { Ok(Self {
tx_dma, tx_dma,
phantom: PhantomData, phantom: PhantomData,
} })
} }
pub fn set_config(&mut self, config: &Config) { pub fn set_config(&mut self, config: &Config) -> Result<(), ConfigError> {
reconfigure::<T>(config) reconfigure::<T>(config)
} }
@ -307,7 +317,7 @@ impl<'d, T: BasicInstance, RxDma> UartRx<'d, T, RxDma> {
rx: impl Peripheral<P = impl RxPin<T>> + 'd, rx: impl Peripheral<P = impl RxPin<T>> + 'd,
rx_dma: impl Peripheral<P = RxDma> + 'd, rx_dma: impl Peripheral<P = RxDma> + 'd,
config: Config, config: Config,
) -> Self { ) -> Result<Self, ConfigError> {
T::enable(); T::enable();
T::reset(); T::reset();
@ -321,7 +331,7 @@ impl<'d, T: BasicInstance, RxDma> UartRx<'d, T, RxDma> {
rts: impl Peripheral<P = impl RtsPin<T>> + 'd, rts: impl Peripheral<P = impl RtsPin<T>> + 'd,
rx_dma: impl Peripheral<P = RxDma> + 'd, rx_dma: impl Peripheral<P = RxDma> + 'd,
config: Config, config: Config,
) -> Self { ) -> Result<Self, ConfigError> {
into_ref!(rts); into_ref!(rts);
T::enable(); T::enable();
@ -340,14 +350,14 @@ impl<'d, T: BasicInstance, RxDma> UartRx<'d, T, RxDma> {
rx: impl Peripheral<P = impl RxPin<T>> + 'd, rx: impl Peripheral<P = impl RxPin<T>> + 'd,
rx_dma: impl Peripheral<P = RxDma> + 'd, rx_dma: impl Peripheral<P = RxDma> + 'd,
config: Config, config: Config,
) -> Self { ) -> Result<Self, ConfigError> {
into_ref!(peri, rx, rx_dma); into_ref!(peri, rx, rx_dma);
let r = T::regs(); let r = T::regs();
rx.set_as_af(rx.af_num(), AFType::Input); rx.set_as_af(rx.af_num(), AFType::Input);
configure(r, &config, T::frequency(), T::KIND, true, false); configure(r, &config, T::frequency(), T::KIND, true, false)?;
T::Interrupt::unpend(); T::Interrupt::unpend();
unsafe { T::Interrupt::enable() }; unsafe { T::Interrupt::enable() };
@ -355,16 +365,16 @@ impl<'d, T: BasicInstance, RxDma> UartRx<'d, T, RxDma> {
// create state once! // create state once!
let _s = T::state(); let _s = T::state();
Self { Ok(Self {
_peri: peri, _peri: peri,
rx_dma, rx_dma,
detect_previous_overrun: config.detect_previous_overrun, detect_previous_overrun: config.detect_previous_overrun,
#[cfg(any(usart_v1, usart_v2))] #[cfg(any(usart_v1, usart_v2))]
buffered_sr: stm32_metapac::usart::regs::Sr(0), buffered_sr: stm32_metapac::usart::regs::Sr(0),
} })
} }
pub fn set_config(&mut self, config: &Config) { pub fn set_config(&mut self, config: &Config) -> Result<(), ConfigError> {
reconfigure::<T>(config) reconfigure::<T>(config)
} }
@ -680,7 +690,7 @@ impl<'d, T: BasicInstance, TxDma, RxDma> Uart<'d, T, TxDma, RxDma> {
tx_dma: impl Peripheral<P = TxDma> + 'd, tx_dma: impl Peripheral<P = TxDma> + 'd,
rx_dma: impl Peripheral<P = RxDma> + 'd, rx_dma: impl Peripheral<P = RxDma> + 'd,
config: Config, config: Config,
) -> Self { ) -> Result<Self, ConfigError> {
// UartRx and UartTx have one refcount ea. // UartRx and UartTx have one refcount ea.
T::enable(); T::enable();
T::enable(); T::enable();
@ -699,7 +709,7 @@ impl<'d, T: BasicInstance, TxDma, RxDma> Uart<'d, T, TxDma, RxDma> {
tx_dma: impl Peripheral<P = TxDma> + 'd, tx_dma: impl Peripheral<P = TxDma> + 'd,
rx_dma: impl Peripheral<P = RxDma> + 'd, rx_dma: impl Peripheral<P = RxDma> + 'd,
config: Config, config: Config,
) -> Self { ) -> Result<Self, ConfigError> {
into_ref!(cts, rts); into_ref!(cts, rts);
// UartRx and UartTx have one refcount ea. // UartRx and UartTx have one refcount ea.
@ -726,7 +736,7 @@ impl<'d, T: BasicInstance, TxDma, RxDma> Uart<'d, T, TxDma, RxDma> {
tx_dma: impl Peripheral<P = TxDma> + 'd, tx_dma: impl Peripheral<P = TxDma> + 'd,
rx_dma: impl Peripheral<P = RxDma> + 'd, rx_dma: impl Peripheral<P = RxDma> + 'd,
config: Config, config: Config,
) -> Self { ) -> Result<Self, ConfigError> {
into_ref!(de); into_ref!(de);
// UartRx and UartTx have one refcount ea. // UartRx and UartTx have one refcount ea.
@ -748,7 +758,7 @@ impl<'d, T: BasicInstance, TxDma, RxDma> Uart<'d, T, TxDma, RxDma> {
tx_dma: impl Peripheral<P = TxDma> + 'd, tx_dma: impl Peripheral<P = TxDma> + 'd,
rx_dma: impl Peripheral<P = RxDma> + 'd, rx_dma: impl Peripheral<P = RxDma> + 'd,
config: Config, config: Config,
) -> Self { ) -> Result<Self, ConfigError> {
into_ref!(peri, rx, tx, tx_dma, rx_dma); into_ref!(peri, rx, tx, tx_dma, rx_dma);
let r = T::regs(); let r = T::regs();
@ -770,7 +780,7 @@ impl<'d, T: BasicInstance, TxDma, RxDma> Uart<'d, T, TxDma, RxDma> {
} }
} }
configure(r, &config, T::frequency(), T::KIND, true, true); configure(r, &config, T::frequency(), T::KIND, true, true)?;
T::Interrupt::unpend(); T::Interrupt::unpend();
unsafe { T::Interrupt::enable() }; unsafe { T::Interrupt::enable() };
@ -778,7 +788,7 @@ impl<'d, T: BasicInstance, TxDma, RxDma> Uart<'d, T, TxDma, RxDma> {
// create state once! // create state once!
let _s = T::state(); let _s = T::state();
Self { Ok(Self {
tx: UartTx { tx: UartTx {
tx_dma, tx_dma,
phantom: PhantomData, phantom: PhantomData,
@ -790,10 +800,10 @@ impl<'d, T: BasicInstance, TxDma, RxDma> Uart<'d, T, TxDma, RxDma> {
#[cfg(any(usart_v1, usart_v2))] #[cfg(any(usart_v1, usart_v2))]
buffered_sr: stm32_metapac::usart::regs::Sr(0), buffered_sr: stm32_metapac::usart::regs::Sr(0),
}, },
} })
} }
pub fn set_config(&mut self, config: &Config) { pub fn set_config(&mut self, config: &Config) -> Result<(), ConfigError> {
reconfigure::<T>(config) reconfigure::<T>(config)
} }
@ -842,18 +852,27 @@ impl<'d, T: BasicInstance, TxDma, RxDma> Uart<'d, T, TxDma, RxDma> {
} }
} }
fn reconfigure<T: BasicInstance>(config: &Config) { fn reconfigure<T: BasicInstance>(config: &Config) -> Result<(), ConfigError> {
T::Interrupt::disable(); T::Interrupt::disable();
let r = T::regs(); let r = T::regs();
let cr = r.cr1().read(); let cr = r.cr1().read();
configure(r, config, T::frequency(), T::KIND, cr.re(), cr.te()); configure(r, config, T::frequency(), T::KIND, cr.re(), cr.te())?;
T::Interrupt::unpend(); T::Interrupt::unpend();
unsafe { T::Interrupt::enable() }; unsafe { T::Interrupt::enable() };
Ok(())
} }
fn configure(r: Regs, config: &Config, pclk_freq: Hertz, kind: Kind, enable_rx: bool, enable_tx: bool) { fn configure(
r: Regs,
config: &Config,
pclk_freq: Hertz,
kind: Kind,
enable_rx: bool,
enable_tx: bool,
) -> Result<(), ConfigError> {
if !enable_rx && !enable_tx { if !enable_rx && !enable_tx {
panic!("USART: At least one of RX or TX should be enabled"); panic!("USART: At least one of RX or TX should be enabled");
} }
@ -921,7 +940,7 @@ fn configure(r: Regs, config: &Config, pclk_freq: Hertz, kind: Kind, enable_rx:
found_brr = Some(brr); found_brr = Some(brr);
break; break;
} }
panic!("USART: baudrate too high"); return Err(ConfigError::BaudrateTooHigh);
} }
if brr < brr_max { if brr < brr_max {
@ -933,7 +952,7 @@ fn configure(r: Regs, config: &Config, pclk_freq: Hertz, kind: Kind, enable_rx:
} }
} }
let brr = found_brr.expect("USART: baudrate too low"); let brr = found_brr.ok_or(ConfigError::BaudrateTooLow)?;
#[cfg(not(usart_v1))] #[cfg(not(usart_v1))]
let oversampling = if over8 { "8 bit" } else { "16 bit" }; let oversampling = if over8 { "8 bit" } else { "16 bit" };
@ -985,6 +1004,8 @@ fn configure(r: Regs, config: &Config, pclk_freq: Hertz, kind: Kind, enable_rx:
r.cr3().modify(|w| { r.cr3().modify(|w| {
w.set_onebit(config.assume_noise_free); w.set_onebit(config.assume_noise_free);
}); });
Ok(())
} }
mod eh02 { mod eh02 {

6
embassy-stm32/src/usart/ringbuffered.rs
View File

@ -7,7 +7,7 @@ use embassy_embedded_hal::SetConfig;
use embassy_hal_internal::PeripheralRef; use embassy_hal_internal::PeripheralRef;
use futures::future::{select, Either}; use futures::future::{select, Either};
use super::{clear_interrupt_flags, rdr, reconfigure, sr, BasicInstance, Config, Error, UartRx}; use super::{clear_interrupt_flags, rdr, reconfigure, sr, BasicInstance, Config, ConfigError, Error, UartRx};
use crate::dma::ReadableRingBuffer; use crate::dma::ReadableRingBuffer;
use crate::usart::{Regs, Sr}; use crate::usart::{Regs, Sr};
@ -20,7 +20,7 @@ impl<'d, T: BasicInstance, RxDma: super::RxDma<T>> SetConfig for RingBufferedUar
type Config = Config; type Config = Config;
fn set_config(&mut self, config: &Self::Config) { fn set_config(&mut self, config: &Self::Config) {
self.set_config(config); unwrap!(self.set_config(config));
} }
} }
@ -63,7 +63,7 @@ impl<'d, T: BasicInstance, RxDma: super::RxDma<T>> RingBufferedUartRx<'d, T, RxD
Err(err) Err(err)
} }
pub fn set_config(&mut self, config: &Config) { pub fn set_config(&mut self, config: &Config) -> Result<(), ConfigError> {
self.teardown_uart(); self.teardown_uart();
reconfigure::<T>(config) reconfigure::<T>(config)
} }

2
examples/stm32f3/src/bin/usart_dma.rs
View File

@ -22,7 +22,7 @@ async fn main(_spawner: Spawner) {
info!("Hello World!"); info!("Hello World!");
let config = Config::default(); let config = Config::default();
let mut usart = Uart::new(p.USART1, p.PE1, p.PE0, Irqs, p.DMA1_CH4, NoDma, config); let mut usart = Uart::new(p.USART1, p.PE1, p.PE0, Irqs, p.DMA1_CH4, NoDma, config).unwrap();
for n in 0u32.. { for n in 0u32.. {
let mut s: String<128> = String::new(); let mut s: String<128> = String::new();

2
examples/stm32f4/src/bin/usart.rs
View File

@ -20,7 +20,7 @@ fn main() -> ! {
let p = embassy_stm32::init(Default::default()); let p = embassy_stm32::init(Default::default());
let config = Config::default(); let config = Config::default();
let mut usart = Uart::new(p.USART3, p.PD9, p.PD8, Irqs, NoDma, NoDma, config); let mut usart = Uart::new(p.USART3, p.PD9, p.PD8, Irqs, NoDma, NoDma, config).unwrap();
unwrap!(usart.blocking_write(b"Hello Embassy World!\r\n")); unwrap!(usart.blocking_write(b"Hello Embassy World!\r\n"));
info!("wrote Hello, starting echo"); info!("wrote Hello, starting echo");

2
examples/stm32f4/src/bin/usart_buffered.rs
View File

@ -22,7 +22,7 @@ async fn main(_spawner: Spawner) {
let mut tx_buf = [0u8; 32]; let mut tx_buf = [0u8; 32];
let mut rx_buf = [0u8; 32]; let mut rx_buf = [0u8; 32];
let mut buf_usart = BufferedUart::new(p.USART3, Irqs, p.PD9, p.PD8, &mut tx_buf, &mut rx_buf, config); let mut buf_usart = BufferedUart::new(p.USART3, Irqs, p.PD9, p.PD8, &mut tx_buf, &mut rx_buf, config).unwrap();
loop { loop {
let buf = buf_usart.fill_buf().await.unwrap(); let buf = buf_usart.fill_buf().await.unwrap();

2
examples/stm32f4/src/bin/usart_dma.rs
View File

@ -22,7 +22,7 @@ async fn main(_spawner: Spawner) {
info!("Hello World!"); info!("Hello World!");
let config = Config::default(); let config = Config::default();
let mut usart = Uart::new(p.USART3, p.PD9, p.PD8, Irqs, p.DMA1_CH3, NoDma, config); let mut usart = Uart::new(p.USART3, p.PD9, p.PD8, Irqs, p.DMA1_CH3, NoDma, config).unwrap();
for n in 0u32.. { for n in 0u32.. {
let mut s: String<128> = String::new(); let mut s: String<128> = String::new();

2
examples/stm32f7/src/bin/usart_dma.rs
View File

@ -20,7 +20,7 @@ bind_interrupts!(struct Irqs {
async fn main(_spawner: Spawner) { async fn main(_spawner: Spawner) {
let p = embassy_stm32::init(Default::default()); let p = embassy_stm32::init(Default::default());
let config = Config::default(); let config = Config::default();
let mut usart = Uart::new(p.UART7, p.PA8, p.PA15, Irqs, p.DMA1_CH1, NoDma, config); let mut usart = Uart::new(p.UART7, p.PA8, p.PA15, Irqs, p.DMA1_CH1, NoDma, config).unwrap();
for n in 0u32.. { for n in 0u32.. {
let mut s: String<128> = String::new(); let mut s: String<128> = String::new();

2
examples/stm32h5/src/bin/usart.rs
View File

@ -20,7 +20,7 @@ async fn main_task() {
let p = embassy_stm32::init(Default::default()); let p = embassy_stm32::init(Default::default());
let config = Config::default(); let config = Config::default();
let mut usart = Uart::new(p.UART7, p.PF6, p.PF7, Irqs, NoDma, NoDma, config); let mut usart = Uart::new(p.UART7, p.PF6, p.PF7, Irqs, NoDma, NoDma, config).unwrap();
unwrap!(usart.blocking_write(b"Hello Embassy World!\r\n")); unwrap!(usart.blocking_write(b"Hello Embassy World!\r\n"));
info!("wrote Hello, starting echo"); info!("wrote Hello, starting echo");

2
examples/stm32h5/src/bin/usart_dma.rs
View File

@ -23,7 +23,7 @@ async fn main_task() {
let p = embassy_stm32::init(Default::default()); let p = embassy_stm32::init(Default::default());
let config = Config::default(); let config = Config::default();
let mut usart = Uart::new(p.UART7, p.PF6, p.PF7, Irqs, p.GPDMA1_CH0, NoDma, config); let mut usart = Uart::new(p.UART7, p.PF6, p.PF7, Irqs, p.GPDMA1_CH0, NoDma, config).unwrap();
for n in 0u32.. { for n in 0u32.. {
let mut s: String<128> = String::new(); let mut s: String<128> = String::new();

2
examples/stm32h5/src/bin/usart_split.rs
View File

@ -36,7 +36,7 @@ async fn main(spawner: Spawner) -> ! {
info!("Hello World!"); info!("Hello World!");
let config = Config::default(); let config = Config::default();
let mut usart = Uart::new(p.UART7, p.PF6, p.PF7, Irqs, p.GPDMA1_CH0, p.GPDMA1_CH1, config); let mut usart = Uart::new(p.UART7, p.PF6, p.PF7, Irqs, p.GPDMA1_CH0, p.GPDMA1_CH1, config).unwrap();
unwrap!(usart.blocking_write(b"Type 8 chars to echo!\r\n")); unwrap!(usart.blocking_write(b"Type 8 chars to echo!\r\n"));
let (mut tx, rx) = usart.split(); let (mut tx, rx) = usart.split();

2
examples/stm32h7/src/bin/usart.rs
View File

@ -20,7 +20,7 @@ async fn main_task() {
let p = embassy_stm32::init(Default::default()); let p = embassy_stm32::init(Default::default());
let config = Config::default(); let config = Config::default();
let mut usart = Uart::new(p.UART7, p.PF6, p.PF7, Irqs, NoDma, NoDma, config); let mut usart = Uart::new(p.UART7, p.PF6, p.PF7, Irqs, NoDma, NoDma, config).unwrap();
unwrap!(usart.blocking_write(b"Hello Embassy World!\r\n")); unwrap!(usart.blocking_write(b"Hello Embassy World!\r\n"));
info!("wrote Hello, starting echo"); info!("wrote Hello, starting echo");

2
examples/stm32h7/src/bin/usart_dma.rs
View File

@ -23,7 +23,7 @@ async fn main_task() {
let p = embassy_stm32::init(Default::default()); let p = embassy_stm32::init(Default::default());
let config = Config::default(); let config = Config::default();
let mut usart = Uart::new(p.UART7, p.PF6, p.PF7, Irqs, p.DMA1_CH0, NoDma, config); let mut usart = Uart::new(p.UART7, p.PF6, p.PF7, Irqs, p.DMA1_CH0, NoDma, config).unwrap();
for n in 0u32.. { for n in 0u32.. {
let mut s: String<128> = String::new(); let mut s: String<128> = String::new();

2
examples/stm32h7/src/bin/usart_split.rs
View File

@ -36,7 +36,7 @@ async fn main(spawner: Spawner) -> ! {
info!("Hello World!"); info!("Hello World!");
let config = Config::default(); let config = Config::default();
let mut usart = Uart::new(p.UART7, p.PF6, p.PF7, Irqs, p.DMA1_CH0, p.DMA1_CH1, config); let mut usart = Uart::new(p.UART7, p.PF6, p.PF7, Irqs, p.DMA1_CH0, p.DMA1_CH1, config).unwrap();
unwrap!(usart.blocking_write(b"Type 8 chars to echo!\r\n")); unwrap!(usart.blocking_write(b"Type 8 chars to echo!\r\n"));
let (mut tx, rx) = usart.split(); let (mut tx, rx) = usart.split();

2
examples/stm32l0/src/bin/usart_dma.rs
View File

@ -15,7 +15,7 @@ bind_interrupts!(struct Irqs {
#[embassy_executor::main] #[embassy_executor::main]
async fn main(_spawner: Spawner) { async fn main(_spawner: Spawner) {
let p = embassy_stm32::init(Default::default()); let p = embassy_stm32::init(Default::default());
let mut usart = Uart::new(p.USART1, p.PB7, p.PB6, Irqs, p.DMA1_CH2, p.DMA1_CH3, Config::default()); let mut usart = Uart::new(p.USART1, p.PB7, p.PB6, Irqs, p.DMA1_CH2, p.DMA1_CH3, Config::default()).unwrap();
usart.write(b"Hello Embassy World!\r\n").await.unwrap(); usart.write(b"Hello Embassy World!\r\n").await.unwrap();
info!("wrote Hello, starting echo"); info!("wrote Hello, starting echo");

8
examples/stm32l0/src/bin/usart_irq.rs
View File

@ -18,13 +18,11 @@ async fn main(_spawner: Spawner) {
let p = embassy_stm32::init(Default::default()); let p = embassy_stm32::init(Default::default());
info!("Hi!"); info!("Hi!");
static mut TX_BUFFER: [u8; 8] = [0; 8];
static mut RX_BUFFER: [u8; 256] = [0; 256];
let mut config = Config::default(); let mut config = Config::default();
config.baudrate = 9600; config.baudrate = 9600;
let mut tx_buf = [0u8; 256];
let mut usart = unsafe { BufferedUart::new(p.USART2, Irqs, p.PA3, p.PA2, &mut TX_BUFFER, &mut RX_BUFFER, config) }; let mut rx_buf = [0u8; 256];
let mut usart = BufferedUart::new(p.USART2, Irqs, p.PA3, p.PA2, &mut tx_buf, &mut rx_buf, config).unwrap();
usart.write_all(b"Hello Embassy World!\r\n").await.unwrap(); usart.write_all(b"Hello Embassy World!\r\n").await.unwrap();
info!("wrote Hello, starting echo"); info!("wrote Hello, starting echo");

2
examples/stm32l4/src/bin/usart.rs
View File

@ -19,7 +19,7 @@ fn main() -> ! {
let p = embassy_stm32::init(Default::default()); let p = embassy_stm32::init(Default::default());
let config = Config::default(); let config = Config::default();
let mut usart = Uart::new(p.UART4, p.PA1, p.PA0, Irqs, NoDma, NoDma, config); let mut usart = Uart::new(p.UART4, p.PA1, p.PA0, Irqs, NoDma, NoDma, config).unwrap();
unwrap!(usart.blocking_write(b"Hello Embassy World!\r\n")); unwrap!(usart.blocking_write(b"Hello Embassy World!\r\n"));
info!("wrote Hello, starting echo"); info!("wrote Hello, starting echo");

2
examples/stm32l4/src/bin/usart_dma.rs
View File

@ -22,7 +22,7 @@ async fn main(_spawner: Spawner) {
info!("Hello World!"); info!("Hello World!");
let config = Config::default(); let config = Config::default();
let mut usart = Uart::new(p.UART4, p.PA1, p.PA0, Irqs, p.DMA1_CH3, NoDma, config); let mut usart = Uart::new(p.UART4, p.PA1, p.PA0, Irqs, p.DMA1_CH3, NoDma, config).unwrap();
for n in 0u32.. { for n in 0u32.. {
let mut s: String<128> = String::new(); let mut s: String<128> = String::new();

4
examples/stm32wl/src/bin/uart_async.rs
View File

@ -33,10 +33,10 @@ async fn main(_spawner: Spawner) {
config2.baudrate = 9600; config2.baudrate = 9600;
//RX/TX connected to USB/UART Bridge on LoRa-E5 mini v1.0 //RX/TX connected to USB/UART Bridge on LoRa-E5 mini v1.0
let mut usart1 = Uart::new(p.USART1, p.PB7, p.PB6, Irqs, p.DMA1_CH3, p.DMA1_CH4, config1); let mut usart1 = Uart::new(p.USART1, p.PB7, p.PB6, Irqs, p.DMA1_CH3, p.DMA1_CH4, config1).unwrap();
//RX1/TX1 (LPUART) on LoRa-E5 mini v1.0 //RX1/TX1 (LPUART) on LoRa-E5 mini v1.0
let mut usart2 = Uart::new(p.LPUART1, p.PC0, p.PC1, Irqs, p.DMA1_CH5, p.DMA1_CH6, config2); let mut usart2 = Uart::new(p.LPUART1, p.PC0, p.PC1, Irqs, p.DMA1_CH5, p.DMA1_CH6, config2).unwrap();
unwrap!(usart1.write(b"Hello Embassy World!\r\n").await); unwrap!(usart1.write(b"Hello Embassy World!\r\n").await);
unwrap!(usart2.write(b"Hello Embassy World!\r\n").await); unwrap!(usart2.write(b"Hello Embassy World!\r\n").await);

6
tests/stm32/src/bin/usart.rs
View File

@ -25,7 +25,7 @@ async fn main(_spawner: Spawner) {
{ {
let config = Config::default(); let config = Config::default();
let mut usart = Uart::new(&mut usart, &mut rx, &mut tx, irq, NoDma, NoDma, config); let mut usart = Uart::new(&mut usart, &mut rx, &mut tx, irq, NoDma, NoDma, config).unwrap();
// We can't send too many bytes, they have to fit in the FIFO. // We can't send too many bytes, they have to fit in the FIFO.
// This is because we aren't sending+receiving at the same time. // This is because we aren't sending+receiving at the same time.
@ -41,7 +41,7 @@ async fn main(_spawner: Spawner) {
// Test error handling with with an overflow error // Test error handling with with an overflow error
{ {
let config = Config::default(); let config = Config::default();
let mut usart = Uart::new(&mut usart, &mut rx, &mut tx, irq, NoDma, NoDma, config); let mut usart = Uart::new(&mut usart, &mut rx, &mut tx, irq, NoDma, NoDma, config).unwrap();
// Send enough bytes to fill the RX FIFOs off all USART versions. // Send enough bytes to fill the RX FIFOs off all USART versions.
let data = [0xC0, 0xDE, 0x12, 0x23, 0x34]; let data = [0xC0, 0xDE, 0x12, 0x23, 0x34];
@ -75,7 +75,7 @@ async fn main(_spawner: Spawner) {
let mut config = Config::default(); let mut config = Config::default();
config.baudrate = baudrate; config.baudrate = baudrate;
let mut usart = Uart::new(&mut usart, &mut rx, &mut tx, irq, NoDma, NoDma, config); let mut usart = Uart::new(&mut usart, &mut rx, &mut tx, irq, NoDma, NoDma, config).unwrap();
let n = (baudrate as usize / 100).max(64); let n = (baudrate as usize / 100).max(64);

2
tests/stm32/src/bin/usart_dma.rs
View File

@ -25,7 +25,7 @@ async fn main(_spawner: Spawner) {
let irq = irqs!(UART); let irq = irqs!(UART);
let config = Config::default(); let config = Config::default();
let usart = Uart::new(usart, rx, tx, irq, tx_dma, rx_dma, config); let usart = Uart::new(usart, rx, tx, irq, tx_dma, rx_dma, config).unwrap();
const LEN: usize = 128; const LEN: usize = 128;
let mut tx_buf = [0; LEN]; let mut tx_buf = [0; LEN];

2
tests/stm32/src/bin/usart_rx_ringbuffered.rs
View File

@ -40,7 +40,7 @@ async fn main(spawner: Spawner) {
config.stop_bits = StopBits::STOP1; config.stop_bits = StopBits::STOP1;
config.parity = Parity::ParityNone; config.parity = Parity::ParityNone;
let usart = Uart::new(usart, rx, tx, irq, tx_dma, rx_dma, config); let usart = Uart::new(usart, rx, tx, irq, tx_dma, rx_dma, config).unwrap();
let (tx, rx) = usart.split(); let (tx, rx) = usart.split();
static mut DMA_BUF: [u8; DMA_BUF_SIZE] = [0; DMA_BUF_SIZE]; static mut DMA_BUF: [u8; DMA_BUF_SIZE] = [0; DMA_BUF_SIZE];
let dma_buf = unsafe { DMA_BUF.as_mut() }; let dma_buf = unsafe { DMA_BUF.as_mut() };