1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105
//! Logging facilities for Cortex-M processors //! //! ## Destinations //! //! The crate provides following destinations for writes: //! - [Dummy](destination/dummy/struct.Dummy.html) - noop destination that performs no writes. Useful for release mode //! - [Itm](destination/itm/struct.Itm.html) - Uses Cortex-M [Itm](https://docs.rs/cortex-m/0.5.1/cortex_m/itm/index.html) to send output. Note that it is available only on ARMv7-M and newer //! - [Semihosting](destination/semihosting/trait.SemihostingComp.html) - Uses Cortex-M [Semihosting](https://docs.rs/cortex-m-semihosting) to send output. //! //! All destinations implements [fmt::Write](https://doc.rust-lang.org/core/fmt/trait.Write.html) //! to provide simple and generic interface //! //! ## Printers //! //! Each destination is provided with corresponding [Printer](printer/trait.Printer.html). //! In addition to providing generic interface it also allows to configure Interrupt mode for all //! prints. [See](modes/index.html). //! //! ## Macros //! //! The crate provide primitieve macros that are enabled only in debug release. //! Controlled by `debug_assertions` attribute //! //! ```rust //! use cortex_m_log::{print, println, d_print, d_println}; //! use cortex_m_log::printer::Dummy; //! //! fn main() { //! let mut log = Dummy; //! println!(log, "Some print with newline!"); //! //Debug version of print that resolves into nothing in release mode //! //Note that you must import print macro for it to work //! d_print!(log, "Print stuff: {}", "stuff"); //! //Note that you must import println macro for it to work //! d_println!(log, "Print stuff: {} and also newline", "stuff"); //! } //! ``` #![no_std] pub mod modes; pub mod destination; pub mod printer; #[cfg(feature = "log-integration")] pub mod log; ///Print macro that uses Printers to write formatted output #[macro_export] macro_rules! print { ($logger:expr, $($arg:tt)+) => ({ use $crate::printer::Printer; $logger.print(format_args!($($arg)+)); }) } ///Print macro that uses Printers to write formatted output with newline #[macro_export] macro_rules! println { ($logger:expr, $($arg:tt)+) => ({ use $crate::printer::Printer; $logger.println(format_args!($($arg)+)); }) } ///Deubg print macro that uses Printers to write formatted output /// ///It is defined to empty macro unless `debug_assertions` is enabled #[macro_export] #[cfg(not(debug_assertions))] macro_rules! d_print { ($logger:expr, $($arg:tt)+) => ({ }) } ///Deubg print macro that uses Printers to write formatted output /// ///It is defined to empty macro unless `debug_assertions` is enabled #[macro_export] #[cfg(debug_assertions)] macro_rules! d_print { ($logger:expr, $($arg:tt)+) => ({ print!($logger, $($arg)+) }) } ///Deubg print macro that uses Printers to write formatted output with newline /// ///It is defined to empty macro unless `debug_assertions` is enabled #[macro_export] #[cfg(not(debug_assertions))] macro_rules! d_println { ($logger:expr, $($arg:tt)+) => ({ }) } ///Deubg print macro that uses Printers to write formatted output with newline /// ///It is defined to empty macro unless `debug_assertions` is enabled #[macro_export] #[cfg(debug_assertions)] macro_rules! d_println { ($logger:expr, $($arg:tt)+) => ({ println!($logger, $($arg)+) }) }