rtt-target

The rtt-target crate implements the RTT (Real-Time Transfer) I/O protocol. It uses in-memory ring buffers and polling to facilitate input and output via a debug probe. This approach allows for debug logging from a microcontroller with minimal delays and no blocking, making it suitable for real-time applications where semihosting delays are unacceptable.

Note on Locking:

• Using a platform-specific critical-section is required for standard printing.
• Writing directly to a channel object using the write! macro or the binary write method does not require locking and therefore does not require a platform-specific critical section.

To use rtt-target as a backend for defmt, you must:

1. Enable the defmt feature in your Cargo.toml.
2. Initialize the system by either calling the rtt_init_defmt! macro OR manually setting up your channels and calling set_defmt_channel before any defmt calls are made.

# In Cargo.toml
features = ["defmt"]

Use panic-rtt-target to automatically log panic messages over an RTT channel.

Requirements:

• You must initialize RTT using one of the rtt_init macros (e.g., rtt_init_default!()), otherwise you will encounter a linker error at compile time.
• The panic handler runs in a non-returning critical_section. You must provide a critical_section implementation for your target.

Behavior:

• Panics are logged to the print channel.
• Upon panicking, the channel mode is automatically set to BlockIfFull to ensure the complete message is captured.
• If a panic occurs before RTT is initialized or if no print channel exists, no logs will be produced.

#![no_std]

use panic_rtt_target as _;
use rtt_target::rtt_init_default;

fn main() -> ! {
    // Initialize RTT (required to avoid linker errors)
    rtt_init_default!();

    panic!("Something has gone terribly wrong");
}

To use rtt-target for simple debug printing, you must provide a platform-specific critical-section implementation. Once configured, you can initialize the RTT print system using the rtt_init_print! macro and use rprintln! to print formatted messages to the RTT channel.

use rtt_target::{rtt_init_print, rprintln};

fn main() {
    rtt_init_print!();
    loop {
        rprintln!("Hello, world!");
    }
}

Add both rtt-target and panic-rtt-target to your Cargo.toml dependencies.

[dependencies]
rtt-target = "x.y.z"
panic-rtt-target = "x.y.z"

To use rtt-target as a backend for the log crate, you must:

1. Enable the log feature in your Cargo.toml.
2. Initialize the system by either calling the rtt_init_log! macro OR manually setting up your channels and calling init_logger or init_logger_with_level before using log macros.

# In Cargo.toml
features = ["log"]

The rtt::RttHeader and rtt::RttChannel types implement the core RTT (Real Time Transfer) protocol.

Note: This module is intended for use via the rtt_init! macro and is not meant to be used directly in user code. Most of its functionality is undocumented because it is an internal implementation detail of the protocol.

Key components include:

• RttHeader: The control block header that identifies the RTT setup and the number of available up/down channels.
• RttChannel: Represents an individual RTT channel with a name, a buffer, and read/write pointers.
• RttWriter: A helper for performing cancellable write operations to an up-channel.

By enabling the defmt feature in panic-rtt-target, panic messages will be printed to the defmt channel.

If you have configured both a print channel (via rtt-target) and a defmt channel, the panic message will be sent to both channels.

Note: Enabling this feature does not automatically enable the defmt feature in the rtt-target crate itself, allowing you to choose a different defmt backend if desired.

To use the defmt crate for efficient message formatting over RTT, you must enable the defmt feature in your Cargo.toml and initialize the channel using set_defmt_channel or the rtt_init_defmt macro.

Dependency Setup:

[dependencies]
defmt = { version = "0.3" }
rtt-target = { version = "0.6", features = ["defmt"] }

To forward log crate messages to RTT, enable the log feature and initialize the logger with rtt_init_log!. You can pass a log::LevelFilter as an argument to set the minimum log level.

use rtt_target::rtt_init_log;

fn main() -> ! {
   rtt_init_log!(); // Pass a log::LevelFilter to set min log level
   loop {
       log::info!("Hello, world!");
   }
}