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

fmt: make all macros macro_rules so scoping is consistent.

Browse Source
This commit is contained in:
Dario Nieuwenhuis 2021-06-07 00:10:54 +02:00
parent 4dda7be968
commit e7dc5c0939
33 changed files with 950 additions and 377 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

213
embassy-extras/src/fmt.rs
View File

@ -1,69 +1,170 @@
#![macro_use]
#![allow(clippy::module_inception)]
#![allow(unused)]
#![allow(unused_macros)]
#[cfg(all(feature = "defmt", feature = "log"))]
compile_error!("You may not enable both `defmt` and `log` features.");
pub use fmt::*;
macro_rules! assert {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::assert!($($x)*);
#[cfg(feature = "defmt")]
defmt::assert!($($x)*);
}
};
}
macro_rules! assert_eq {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::assert_eq!($($x)*);
#[cfg(feature = "defmt")]
defmt::assert_eq!($($x)*);
}
};
}
macro_rules! assert_ne {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::assert_ne!($($x)*);
#[cfg(feature = "defmt")]
defmt::assert_ne!($($x)*);
}
};
}
macro_rules! debug_assert {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::debug_assert!($($x)*);
#[cfg(feature = "defmt")]
defmt::debug_assert!($($x)*);
}
};
}
macro_rules! debug_assert_eq {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::debug_assert_eq!($($x)*);
#[cfg(feature = "defmt")]
defmt::debug_assert_eq!($($x)*);
}
};
}
macro_rules! debug_assert_ne {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::debug_assert_ne!($($x)*);
#[cfg(feature = "defmt")]
defmt::debug_assert_ne!($($x)*);
}
};
}
macro_rules! todo {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::todo!($($x)*);
#[cfg(feature = "defmt")]
defmt::todo!($($x)*);
}
};
}
macro_rules! unreachable {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::unreachable!($($x)*);
#[cfg(feature = "defmt")]
defmt::unreachable!($($x)*);
}
};
}
macro_rules! panic {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::panic!($($x)*);
#[cfg(feature = "defmt")]
defmt::panic!($($x)*);
}
};
}
macro_rules! trace {
($($x:tt)*) => {
{
#[cfg(feature = "log")]
log::trace!($($x)*);
#[cfg(feature = "defmt")]
defmt::trace!($($x)*);
}
};
}
macro_rules! debug {
($($x:tt)*) => {
{
#[cfg(fevature = "log")]
log::debug!($($x)*);
#[cfg(feature = "defmt")]
defmt::debug!($($x)*);
}
};
}
macro_rules! info {
($($x:tt)*) => {
{
#[cfg(feature = "log")]
log::info!($($x)*);
#[cfg(feature = "defmt")]
defmt::info!($($x)*);
}
};
}
macro_rules! warn {
($($x:tt)*) => {
{
#[cfg(feature = "log")]
log::warn!($($x)*);
#[cfg(feature = "defmt")]
defmt::warn!($($x)*);
}
};
}
macro_rules! error {
($($x:tt)*) => {
{
#[cfg(feature = "log")]
log::error!($($x)*);
#[cfg(feature = "defmt")]
defmt::error!($($x)*);
}
};
}
#[cfg(feature = "defmt")]
mod fmt {
pub use defmt::{
assert, assert_eq, assert_ne, debug, debug_assert, debug_assert_eq, debug_assert_ne, error,
info, panic, todo, trace, unreachable, unwrap, warn,
macro_rules! unwrap {
($($x:tt)*) => {
defmt::unwrap!($($x)*)
};
}
#[cfg(feature = "log")]
mod fmt {
pub use core::{
assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo,
unreachable,
};
pub use log::{debug, error, info, trace, warn};
}
#[cfg(not(any(feature = "defmt", feature = "log")))]
mod fmt {
#![macro_use]
pub use core::{
assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo,
unreachable,
};
macro_rules! trace {
($($msg:expr),+ $(,)?) => {
()
};
}
macro_rules! debug {
($($msg:expr),+ $(,)?) => {
()
};
}
macro_rules! info {
($($msg:expr),+ $(,)?) => {
()
};
}
macro_rules! warn {
($($msg:expr),+ $(,)?) => {
()
};
}
macro_rules! error {
($($msg:expr),+ $(,)?) => {
()
};
}
}
#[cfg(not(feature = "defmt"))]
macro_rules! unwrap {
($arg:expr) => {

2
embassy-extras/src/ring_buffer.rs
View File

@ -1,5 +1,3 @@
use crate::fmt::assert;
pub struct RingBuffer<'a> {
buf: &'a mut [u8],
start: usize,

1
embassy-net/src/config/dhcp.rs
View File

@ -4,7 +4,6 @@ use smoltcp::time::Instant;
use super::*;
use crate::device::LinkState;
use crate::fmt::*;
use crate::{Interface, SocketSet};
pub struct DhcpConfigurator {

1
embassy-net/src/config/mod.rs
View File

@ -2,7 +2,6 @@ use heapless::Vec;
use smoltcp::time::Instant;
use smoltcp::wire::{Ipv4Address, Ipv4Cidr};
use crate::fmt::*;
use crate::{Interface, SocketSet};
mod statik;

1
embassy-net/src/config/statik.rs
View File

@ -1,7 +1,6 @@
use smoltcp::time::Instant;
use super::*;
use crate::fmt::*;
use crate::{Interface, SocketSet};
pub struct StaticConfigurator {

1
embassy-net/src/device.rs
View File

@ -3,7 +3,6 @@ use smoltcp::phy::Device as SmolDevice;
use smoltcp::phy::DeviceCapabilities;
use smoltcp::time::Instant as SmolInstant;
use crate::fmt::*;
use crate::packet_pool::PacketBoxExt;
use crate::Result;
use crate::{Packet, PacketBox, PacketBuf};

217
embassy-net/src/fmt.rs
View File

@ -1,74 +1,171 @@
#![macro_use]
#![allow(unused_macros)]
#[cfg(all(feature = "defmt", feature = "log"))]
compile_error!("You may not enable both `defmt` and `log` features.");
pub use fmt::*;
macro_rules! assert {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::assert!($($x)*);
#[cfg(feature = "defmt")]
defmt::assert!($($x)*);
}
};
}
macro_rules! assert_eq {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::assert_eq!($($x)*);
#[cfg(feature = "defmt")]
defmt::assert_eq!($($x)*);
}
};
}
macro_rules! assert_ne {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::assert_ne!($($x)*);
#[cfg(feature = "defmt")]
defmt::assert_ne!($($x)*);
}
};
}
macro_rules! debug_assert {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::debug_assert!($($x)*);
#[cfg(feature = "defmt")]
defmt::debug_assert!($($x)*);
}
};
}
macro_rules! debug_assert_eq {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::debug_assert_eq!($($x)*);
#[cfg(feature = "defmt")]
defmt::debug_assert_eq!($($x)*);
}
};
}
macro_rules! debug_assert_ne {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::debug_assert_ne!($($x)*);
#[cfg(feature = "defmt")]
defmt::debug_assert_ne!($($x)*);
}
};
}
macro_rules! todo {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::todo!($($x)*);
#[cfg(feature = "defmt")]
defmt::todo!($($x)*);
}
};
}
macro_rules! unreachable {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::unreachable!($($x)*);
#[cfg(feature = "defmt")]
defmt::unreachable!($($x)*);
}
};
}
macro_rules! panic {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::panic!($($x)*);
#[cfg(feature = "defmt")]
defmt::panic!($($x)*);
}
};
}
macro_rules! trace {
($($x:tt)*) => {
{
#[cfg(feature = "log")]
log::trace!($($x)*);
#[cfg(feature = "defmt")]
defmt::trace!($($x)*);
}
};
}
macro_rules! debug {
($($x:tt)*) => {
{
#[cfg(fevature = "log")]
log::debug!($($x)*);
#[cfg(feature = "defmt")]
defmt::debug!($($x)*);
}
};
}
macro_rules! info {
($($x:tt)*) => {
{
#[cfg(feature = "log")]
log::info!($($x)*);
#[cfg(feature = "defmt")]
defmt::info!($($x)*);
}
};
}
macro_rules! warn {
($($x:tt)*) => {
{
#[cfg(feature = "log")]
log::warn!($($x)*);
#[cfg(feature = "defmt")]
defmt::warn!($($x)*);
}
};
}
macro_rules! error {
($($x:tt)*) => {
{
#[cfg(feature = "log")]
log::error!($($x)*);
#[cfg(feature = "defmt")]
defmt::error!($($x)*);
}
};
}
#[cfg(feature = "defmt")]
mod fmt {
pub use defmt::{
assert, assert_eq, assert_ne, debug, debug_assert, debug_assert_eq, debug_assert_ne, error,
info, panic, todo, trace, unreachable, unwrap, warn,
macro_rules! unwrap {
($($x:tt)*) => {
defmt::unwrap!($($x)*)
};
}
#[cfg(feature = "log")]
mod fmt {
pub use core::{
assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo,
unreachable,
};
pub use log::{debug, error, info, trace, warn};
}
#[cfg(not(any(feature = "defmt", feature = "log")))]
mod fmt {
#![macro_use]
pub use core::{
assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo,
unreachable,
};
#[macro_export]
macro_rules! trace {
($($msg:expr),+ $(,)?) => {
()
};
}
#[macro_export]
macro_rules! debug {
($($msg:expr),+ $(,)?) => {
()
};
}
#[macro_export]
macro_rules! info {
($($msg:expr),+ $(,)?) => {
()
};
}
#[macro_export]
macro_rules! warn {
($($msg:expr),+ $(,)?) => {
()
};
}
#[macro_export]
macro_rules! error {
($($msg:expr),+ $(,)?) => {
()
};
}
}
#[cfg(not(feature = "defmt"))]
#[macro_export]
macro_rules! unwrap {
($arg:expr) => {
match $crate::fmt::Try::into_result($arg) {

1
embassy-net/src/stack.rs
View File

@ -20,7 +20,6 @@ use smoltcp::wire::{IpAddress, IpCidr, Ipv4Address, Ipv4Cidr};
use crate::config::Configurator;
use crate::config::Event;
use crate::device::{Device, DeviceAdapter, LinkState};
use crate::fmt::*;
use crate::{Interface, SocketSet};
const ADDRESSES_LEN: usize = 1;

1
embassy-net/src/tcp_socket.rs
View File

@ -11,7 +11,6 @@ use smoltcp::time::Duration;
use smoltcp::wire::IpEndpoint;
use super::stack::Stack;
use crate::fmt::*;
use crate::{Error, Result};
pub struct TcpSocket<'a> {

1
embassy-nrf/src/buffered_uarte.rs
View File

@ -11,7 +11,6 @@ use embassy_extras::peripheral::{PeripheralMutex, PeripheralState};
use embassy_extras::ring_buffer::RingBuffer;
use embassy_extras::{low_power_wait_until, unborrow};
use crate::fmt::{panic, *};
use crate::gpio::sealed::Pin as _;
use crate::gpio::{OptionalPin as GpioOptionalPin, Pin as GpioPin};
use crate::pac;

213
embassy-nrf/src/fmt.rs
View File

@ -1,69 +1,170 @@
#![macro_use]
#![allow(clippy::module_inception)]
#![allow(unused)]
#![allow(unused_macros)]
#[cfg(all(feature = "defmt", feature = "log"))]
compile_error!("You may not enable both `defmt` and `log` features.");
pub use fmt::*;
macro_rules! assert {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::assert!($($x)*);
#[cfg(feature = "defmt")]
defmt::assert!($($x)*);
}
};
}
macro_rules! assert_eq {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::assert_eq!($($x)*);
#[cfg(feature = "defmt")]
defmt::assert_eq!($($x)*);
}
};
}
macro_rules! assert_ne {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::assert_ne!($($x)*);
#[cfg(feature = "defmt")]
defmt::assert_ne!($($x)*);
}
};
}
macro_rules! debug_assert {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::debug_assert!($($x)*);
#[cfg(feature = "defmt")]
defmt::debug_assert!($($x)*);
}
};
}
macro_rules! debug_assert_eq {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::debug_assert_eq!($($x)*);
#[cfg(feature = "defmt")]
defmt::debug_assert_eq!($($x)*);
}
};
}
macro_rules! debug_assert_ne {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::debug_assert_ne!($($x)*);
#[cfg(feature = "defmt")]
defmt::debug_assert_ne!($($x)*);
}
};
}
macro_rules! todo {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::todo!($($x)*);
#[cfg(feature = "defmt")]
defmt::todo!($($x)*);
}
};
}
macro_rules! unreachable {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::unreachable!($($x)*);
#[cfg(feature = "defmt")]
defmt::unreachable!($($x)*);
}
};
}
macro_rules! panic {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::panic!($($x)*);
#[cfg(feature = "defmt")]
defmt::panic!($($x)*);
}
};
}
macro_rules! trace {
($($x:tt)*) => {
{
#[cfg(feature = "log")]
log::trace!($($x)*);
#[cfg(feature = "defmt")]
defmt::trace!($($x)*);
}
};
}
macro_rules! debug {
($($x:tt)*) => {
{
#[cfg(fevature = "log")]
log::debug!($($x)*);
#[cfg(feature = "defmt")]
defmt::debug!($($x)*);
}
};
}
macro_rules! info {
($($x:tt)*) => {
{
#[cfg(feature = "log")]
log::info!($($x)*);
#[cfg(feature = "defmt")]
defmt::info!($($x)*);
}
};
}
macro_rules! warn {
($($x:tt)*) => {
{
#[cfg(feature = "log")]
log::warn!($($x)*);
#[cfg(feature = "defmt")]
defmt::warn!($($x)*);
}
};
}
macro_rules! error {
($($x:tt)*) => {
{
#[cfg(feature = "log")]
log::error!($($x)*);
#[cfg(feature = "defmt")]
defmt::error!($($x)*);
}
};
}
#[cfg(feature = "defmt")]
mod fmt {
pub use defmt::{
assert, assert_eq, assert_ne, debug, debug_assert, debug_assert_eq, debug_assert_ne, error,
info, panic, todo, trace, unreachable, unwrap, warn,
macro_rules! unwrap {
($($x:tt)*) => {
defmt::unwrap!($($x)*)
};
}
#[cfg(feature = "log")]
mod fmt {
pub use core::{
assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo,
unreachable,
};
pub use log::{debug, error, info, trace, warn};
}
#[cfg(not(any(feature = "defmt", feature = "log")))]
mod fmt {
#![macro_use]
pub use core::{
assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo,
unreachable,
};
macro_rules! trace {
($($msg:expr),+ $(,)?) => {
()
};
}
macro_rules! debug {
($($msg:expr),+ $(,)?) => {
()
};
}
macro_rules! info {
($($msg:expr),+ $(,)?) => {
()
};
}
macro_rules! warn {
($($msg:expr),+ $(,)?) => {
()
};
}
macro_rules! error {
($($msg:expr),+ $(,)?) => {
()
};
}
}
#[cfg(not(feature = "defmt"))]
macro_rules! unwrap {
($arg:expr) => {

1
embassy-nrf/src/pwm.rs
View File

@ -6,7 +6,6 @@ use core::sync::atomic::{compiler_fence, Ordering};
use embassy::util::Unborrow;
use embassy_extras::unborrow;
use crate::fmt::{unreachable, *};
use crate::gpio::sealed::Pin as _;
use crate::gpio::OptionalPin as GpioOptionalPin;
use crate::interrupt::Interrupt;

1
embassy-nrf/src/qspi.rs
View File

@ -10,7 +10,6 @@ use embassy::util::{AtomicWaker, DropBomb, Unborrow};
use embassy_extras::unborrow;
use futures::future::poll_fn;
use crate::fmt::{assert, assert_eq, *};
use crate::gpio::sealed::Pin as _;
use crate::gpio::{self, Pin as GpioPin};
use crate::pac;

2
embassy-nrf/src/spim.rs
View File

@ -11,10 +11,10 @@ use embassy_extras::unborrow;
use futures::future::poll_fn;
use traits::spi::FullDuplex;
use crate::gpio;
use crate::gpio::sealed::Pin as _;
use crate::gpio::{OptionalPin, Pin as GpioPin};
use crate::interrupt::Interrupt;
use crate::{fmt::*, gpio};
use crate::{pac, util::slice_in_ram_or};
pub use embedded_hal::spi::{Mode, Phase, Polarity, MODE_0, MODE_1, MODE_2, MODE_3};

2
embassy-nrf/src/twim.rs
View File

@ -18,10 +18,10 @@ use futures::future::poll_fn;
use traits::i2c::I2c;
use crate::chip::{EASY_DMA_SIZE, FORCE_COPY_BUFFER_SIZE};
use crate::gpio;
use crate::gpio::Pin as GpioPin;
use crate::pac;
use crate::util::{slice_in_ram, slice_in_ram_or};
use crate::{fmt::*, gpio};
pub enum Frequency {
#[doc = "26738688: 100 kbps"]

1
embassy-nrf/src/uarte.rs
View File

@ -13,7 +13,6 @@ use embassy_extras::unborrow;
use futures::future::poll_fn;
use crate::chip::EASY_DMA_SIZE;
use crate::fmt::{assert, panic, *};
use crate::gpio::sealed::Pin as _;
use crate::gpio::{self, OptionalPin as GpioOptionalPin, Pin as GpioPin};
use crate::interrupt::Interrupt;

1
embassy-rp/src/dma.rs
View File

@ -1,6 +1,5 @@
use core::sync::atomic::{compiler_fence, Ordering};
use crate::fmt::assert;
use crate::pac::dma::vals;
use crate::{pac, peripherals};

217
embassy-rp/src/fmt.rs
View File

@ -1,74 +1,171 @@
#![macro_use]
#![allow(unused_macros)]
#[cfg(all(feature = "defmt", feature = "log"))]
compile_error!("You may not enable both `defmt` and `log` features.");
pub use fmt::*;
macro_rules! assert {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::assert!($($x)*);
#[cfg(feature = "defmt")]
defmt::assert!($($x)*);
}
};
}
macro_rules! assert_eq {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::assert_eq!($($x)*);
#[cfg(feature = "defmt")]
defmt::assert_eq!($($x)*);
}
};
}
macro_rules! assert_ne {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::assert_ne!($($x)*);
#[cfg(feature = "defmt")]
defmt::assert_ne!($($x)*);
}
};
}
macro_rules! debug_assert {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::debug_assert!($($x)*);
#[cfg(feature = "defmt")]
defmt::debug_assert!($($x)*);
}
};
}
macro_rules! debug_assert_eq {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::debug_assert_eq!($($x)*);
#[cfg(feature = "defmt")]
defmt::debug_assert_eq!($($x)*);
}
};
}
macro_rules! debug_assert_ne {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::debug_assert_ne!($($x)*);
#[cfg(feature = "defmt")]
defmt::debug_assert_ne!($($x)*);
}
};
}
macro_rules! todo {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::todo!($($x)*);
#[cfg(feature = "defmt")]
defmt::todo!($($x)*);
}
};
}
macro_rules! unreachable {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::unreachable!($($x)*);
#[cfg(feature = "defmt")]
defmt::unreachable!($($x)*);
}
};
}
macro_rules! panic {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::panic!($($x)*);
#[cfg(feature = "defmt")]
defmt::panic!($($x)*);
}
};
}
macro_rules! trace {
($($x:tt)*) => {
{
#[cfg(feature = "log")]
log::trace!($($x)*);
#[cfg(feature = "defmt")]
defmt::trace!($($x)*);
}
};
}
macro_rules! debug {
($($x:tt)*) => {
{
#[cfg(fevature = "log")]
log::debug!($($x)*);
#[cfg(feature = "defmt")]
defmt::debug!($($x)*);
}
};
}
macro_rules! info {
($($x:tt)*) => {
{
#[cfg(feature = "log")]
log::info!($($x)*);
#[cfg(feature = "defmt")]
defmt::info!($($x)*);
}
};
}
macro_rules! warn {
($($x:tt)*) => {
{
#[cfg(feature = "log")]
log::warn!($($x)*);
#[cfg(feature = "defmt")]
defmt::warn!($($x)*);
}
};
}
macro_rules! error {
($($x:tt)*) => {
{
#[cfg(feature = "log")]
log::error!($($x)*);
#[cfg(feature = "defmt")]
defmt::error!($($x)*);
}
};
}
#[cfg(feature = "defmt")]
mod fmt {
pub use defmt::{
assert, assert_eq, assert_ne, debug, debug_assert, debug_assert_eq, debug_assert_ne, error,
info, panic, todo, trace, unreachable, unwrap, warn,
macro_rules! unwrap {
($($x:tt)*) => {
defmt::unwrap!($($x)*)
};
}
#[cfg(feature = "log")]
mod fmt {
pub use core::{
assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo,
unreachable,
};
pub use log::{debug, error, info, trace, warn};
}
#[cfg(not(any(feature = "defmt", feature = "log")))]
mod fmt {
#![macro_use]
pub use core::{
assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo,
unreachable,
};
#[macro_export]
macro_rules! trace {
($($msg:expr),+ $(,)?) => {
()
};
}
#[macro_export]
macro_rules! debug {
($($msg:expr),+ $(,)?) => {
()
};
}
#[macro_export]
macro_rules! info {
($($msg:expr),+ $(,)?) => {
()
};
}
#[macro_export]
macro_rules! warn {
($($msg:expr),+ $(,)?) => {
()
};
}
#[macro_export]
macro_rules! error {
($($msg:expr),+ $(,)?) => {
()
};
}
}
#[cfg(not(feature = "defmt"))]
#[macro_export]
macro_rules! unwrap {
($arg:expr) => {
match $crate::fmt::Try::into_result($arg) {

1
embassy-rp/src/pll.rs
View File

@ -1,4 +1,3 @@
use crate::fmt::assert;
use crate::pac;
const XOSC_MHZ: u32 = 12;

1
embassy-stm32/src/dac/v2.rs
View File

@ -1,5 +1,4 @@
use crate::dac::{DacPin, Instance};
use crate::fmt::*;
use crate::gpio::AnyPin;
use crate::pac::dac;
use core::marker::PhantomData;

1
embassy-stm32/src/dma/v2.rs
View File

@ -5,7 +5,6 @@ use embassy::util::AtomicWaker;
use futures::future::poll_fn;
use super::*;
use crate::fmt::assert;
use crate::interrupt;
use crate::pac;
use crate::pac::dma::{regs, vals};

213
embassy-stm32/src/fmt.rs
View File

@ -1,69 +1,170 @@
#![macro_use]
#![allow(clippy::module_inception)]
#![allow(unused)]
#![allow(unused_macros)]
#[cfg(all(feature = "defmt", feature = "log"))]
compile_error!("You may not enable both `defmt` and `log` features.");
pub use fmt::*;
macro_rules! assert {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::assert!($($x)*);
#[cfg(feature = "defmt")]
defmt::assert!($($x)*);
}
};
}
macro_rules! assert_eq {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::assert_eq!($($x)*);
#[cfg(feature = "defmt")]
defmt::assert_eq!($($x)*);
}
};
}
macro_rules! assert_ne {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::assert_ne!($($x)*);
#[cfg(feature = "defmt")]
defmt::assert_ne!($($x)*);
}
};
}
macro_rules! debug_assert {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::debug_assert!($($x)*);
#[cfg(feature = "defmt")]
defmt::debug_assert!($($x)*);
}
};
}
macro_rules! debug_assert_eq {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::debug_assert_eq!($($x)*);
#[cfg(feature = "defmt")]
defmt::debug_assert_eq!($($x)*);
}
};
}
macro_rules! debug_assert_ne {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::debug_assert_ne!($($x)*);
#[cfg(feature = "defmt")]
defmt::debug_assert_ne!($($x)*);
}
};
}
macro_rules! todo {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::todo!($($x)*);
#[cfg(feature = "defmt")]
defmt::todo!($($x)*);
}
};
}
macro_rules! unreachable {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::unreachable!($($x)*);
#[cfg(feature = "defmt")]
defmt::unreachable!($($x)*);
}
};
}
macro_rules! panic {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::panic!($($x)*);
#[cfg(feature = "defmt")]
defmt::panic!($($x)*);
}
};
}
macro_rules! trace {
($($x:tt)*) => {
{
#[cfg(feature = "log")]
log::trace!($($x)*);
#[cfg(feature = "defmt")]
defmt::trace!($($x)*);
}
};
}
macro_rules! debug {
($($x:tt)*) => {
{
#[cfg(fevature = "log")]
log::debug!($($x)*);
#[cfg(feature = "defmt")]
defmt::debug!($($x)*);
}
};
}
macro_rules! info {
($($x:tt)*) => {
{
#[cfg(feature = "log")]
log::info!($($x)*);
#[cfg(feature = "defmt")]
defmt::info!($($x)*);
}
};
}
macro_rules! warn {
($($x:tt)*) => {
{
#[cfg(feature = "log")]
log::warn!($($x)*);
#[cfg(feature = "defmt")]
defmt::warn!($($x)*);
}
};
}
macro_rules! error {
($($x:tt)*) => {
{
#[cfg(feature = "log")]
log::error!($($x)*);
#[cfg(feature = "defmt")]
defmt::error!($($x)*);
}
};
}
#[cfg(feature = "defmt")]
mod fmt {
pub use defmt::{
assert, assert_eq, assert_ne, debug, debug_assert, debug_assert_eq, debug_assert_ne, error,
info, panic, todo, trace, unreachable, unwrap, warn,
macro_rules! unwrap {
($($x:tt)*) => {
defmt::unwrap!($($x)*)
};
}
#[cfg(feature = "log")]
mod fmt {
pub use core::{
assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo,
unreachable,
};
pub use log::{debug, error, info, trace, warn};
}
#[cfg(not(any(feature = "defmt", feature = "log")))]
mod fmt {
#![macro_use]
pub use core::{
assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo,
unreachable,
};
macro_rules! trace {
($($msg:expr),+ $(,)?) => {
()
};
}
macro_rules! debug {
($($msg:expr),+ $(,)?) => {
()
};
}
macro_rules! info {
($($msg:expr),+ $(,)?) => {
()
};
}
macro_rules! warn {
($($msg:expr),+ $(,)?) => {
()
};
}
macro_rules! error {
($($msg:expr),+ $(,)?) => {
()
};
}
}
#[cfg(not(feature = "defmt"))]
macro_rules! unwrap {
($arg:expr) => {

1
embassy-stm32/src/rcc/h7/mod.rs
View File

@ -2,7 +2,6 @@ use core::marker::PhantomData;
use embassy::util::Unborrow;
use crate::fmt::{assert, panic};
use crate::pac::rcc::vals::Timpre;
use crate::pac::{DBGMCU, RCC, SYSCFG};
use crate::peripherals;

1
embassy-stm32/src/rcc/h7/pll.rs
View File

@ -1,5 +1,4 @@
use super::{Hertz, RCC};
use crate::fmt::assert;
const VCO_MIN: u32 = 150_000_000;
const VCO_MAX: u32 = 420_000_000;

7
embassy-stm32/src/sdmmc/v2.rs
View File

@ -10,7 +10,6 @@ use embassy_extras::unborrow;
use futures::future::poll_fn;
use sdio_host::{BusWidth, CardCapacity, CardStatus, CurrentState, SDStatus, CID, CSD, OCR, SCR};
use crate::fmt::*;
use crate::interrupt::Interrupt;
use crate::pac;
use crate::pac::gpio::Gpio;
@ -434,7 +433,7 @@ impl SdmmcInner {
BusWidth::One => 0,
BusWidth::Four => 1,
BusWidth::Eight => 2,
_ => self::panic!("Invalid Bus Width"),
_ => panic!("Invalid Bus Width"),
})
});
@ -637,7 +636,7 @@ impl SdmmcInner {
direction: Dir,
data_transfer_timeout: u32,
) {
self::assert!(block_size <= 14, "Block size up to 2^14 bytes");
assert!(block_size <= 14, "Block size up to 2^14 bytes");
let regs = self.0;
let dtdir = match direction {
@ -678,7 +677,7 @@ impl SdmmcInner {
// Enforce AHB and SDMMC_CK clock relation. See RM0433 Rev 7
// Section 55.5.8
let sdmmc_bus_bandwidth = new_clock.0 * (width as u32);
self::assert!(hclk.0 > 3 * sdmmc_bus_bandwidth / 32);
assert!(hclk.0 > 3 * sdmmc_bus_bandwidth / 32);
*clock = new_clock;
// NOTE(unsafe) We have exclusive access to the regblock

1
embassy/src/executor/mod.rs
View File

@ -9,7 +9,6 @@ mod timer_queue;
mod util;
mod waker;
use crate::fmt::panic;
use crate::interrupt::{Interrupt, InterruptExt};
use crate::time::Alarm;

4
embassy/src/executor/waker.rs
View File

@ -24,7 +24,9 @@ pub(crate) unsafe fn from_task(p: NonNull<TaskHeader>) -> Waker {
pub unsafe fn task_from_waker(waker: &Waker) -> NonNull<TaskHeader> {
let hack: &WakerHack = mem::transmute(waker);
assert_eq!(hack.vtable, &VTABLE);
if hack.vtable != &VTABLE {
panic!("Found waker not created by the embassy executor. Consider enabling the `executor-agnostic` feature on the `embassy` crate.")
}
NonNull::new_unchecked(hack.data as *mut TaskHeader)
}

213
embassy/src/fmt.rs
View File

@ -1,69 +1,170 @@
#![macro_use]
#![allow(clippy::module_inception)]
#![allow(unused)]
#![allow(unused_macros)]
#[cfg(all(feature = "defmt", feature = "log"))]
compile_error!("You may not enable both `defmt` and `log` features.");
pub use fmt::*;
macro_rules! assert {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::assert!($($x)*);
#[cfg(feature = "defmt")]
defmt::assert!($($x)*);
}
};
}
macro_rules! assert_eq {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::assert_eq!($($x)*);
#[cfg(feature = "defmt")]
defmt::assert_eq!($($x)*);
}
};
}
macro_rules! assert_ne {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::assert_ne!($($x)*);
#[cfg(feature = "defmt")]
defmt::assert_ne!($($x)*);
}
};
}
macro_rules! debug_assert {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::debug_assert!($($x)*);
#[cfg(feature = "defmt")]
defmt::debug_assert!($($x)*);
}
};
}
macro_rules! debug_assert_eq {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::debug_assert_eq!($($x)*);
#[cfg(feature = "defmt")]
defmt::debug_assert_eq!($($x)*);
}
};
}
macro_rules! debug_assert_ne {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::debug_assert_ne!($($x)*);
#[cfg(feature = "defmt")]
defmt::debug_assert_ne!($($x)*);
}
};
}
macro_rules! todo {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::todo!($($x)*);
#[cfg(feature = "defmt")]
defmt::todo!($($x)*);
}
};
}
macro_rules! unreachable {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::unreachable!($($x)*);
#[cfg(feature = "defmt")]
defmt::unreachable!($($x)*);
}
};
}
macro_rules! panic {
($($x:tt)*) => {
{
#[cfg(not(feature = "defmt"))]
core::panic!($($x)*);
#[cfg(feature = "defmt")]
defmt::panic!($($x)*);
}
};
}
macro_rules! trace {
($($x:tt)*) => {
{
#[cfg(feature = "log")]
log::trace!($($x)*);
#[cfg(feature = "defmt")]
defmt::trace!($($x)*);
}
};
}
macro_rules! debug {
($($x:tt)*) => {
{
#[cfg(fevature = "log")]
log::debug!($($x)*);
#[cfg(feature = "defmt")]
defmt::debug!($($x)*);
}
};
}
macro_rules! info {
($($x:tt)*) => {
{
#[cfg(feature = "log")]
log::info!($($x)*);
#[cfg(feature = "defmt")]
defmt::info!($($x)*);
}
};
}
macro_rules! warn {
($($x:tt)*) => {
{
#[cfg(feature = "log")]
log::warn!($($x)*);
#[cfg(feature = "defmt")]
defmt::warn!($($x)*);
}
};
}
macro_rules! error {
($($x:tt)*) => {
{
#[cfg(feature = "log")]
log::error!($($x)*);
#[cfg(feature = "defmt")]
defmt::error!($($x)*);
}
};
}
#[cfg(feature = "defmt")]
mod fmt {
pub use defmt::{
assert, assert_eq, assert_ne, debug, debug_assert, debug_assert_eq, debug_assert_ne, error,
info, panic, todo, trace, unreachable, unwrap, warn,
macro_rules! unwrap {
($($x:tt)*) => {
defmt::unwrap!($($x)*)
};
}
#[cfg(feature = "log")]
mod fmt {
pub use core::{
assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo,
unreachable,
};
pub use log::{debug, error, info, trace, warn};
}
#[cfg(not(any(feature = "defmt", feature = "log")))]
mod fmt {
#![macro_use]
pub use core::{
assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo,
unreachable,
};
macro_rules! trace {
($($msg:expr),+ $(,)?) => {
()
};
}
macro_rules! debug {
($($msg:expr),+ $(,)?) => {
()
};
}
macro_rules! info {
($($msg:expr),+ $(,)?) => {
()
};
}
macro_rules! warn {
($($msg:expr),+ $(,)?) => {
()
};
}
macro_rules! error {
($($msg:expr),+ $(,)?) => {
()
};
}
}
#[cfg(not(feature = "defmt"))]
macro_rules! unwrap {
($arg:expr) => {

2
embassy/src/time/mod.rs
View File

@ -10,8 +10,6 @@ pub use duration::Duration;
pub use instant::Instant;
pub use traits::*;
use crate::fmt::*;
// TODO allow customizing, probably via Cargo features `tick-hz-32768` or something.
pub const TICKS_PER_SECOND: u64 = 32768;

1
embassy/src/util/drop_bomb.rs
View File

@ -1,4 +1,3 @@
use crate::fmt::panic;
use core::mem;
/// An explosive ordinance that panics if it is improperly disposed of.

2
embassy/src/util/mutex.rs
View File

@ -1,8 +1,6 @@
use core::cell::UnsafeCell;
use critical_section::CriticalSection;
use crate::fmt::assert;
/// A "mutex" based on critical sections
///
/// # Safety

1
embassy/src/util/portal.rs
View File

@ -1,4 +1,3 @@
use crate::fmt::panic;
use core::cell::UnsafeCell;
use core::mem;
use core::mem::MaybeUninit;

1
embassy/src/util/signal.rs
View File

@ -9,7 +9,6 @@ use executor::raw::TaskHeader;
use ptr::NonNull;
use crate::executor;
use crate::fmt::panic;
use crate::interrupt::{Interrupt, InterruptExt};
/// Synchronization primitive. Allows creating awaitable signals that may be passed between tasks.