### AI Assistant Prompt: Test All MCP Tools

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/README.md

Example prompt to guide an AI assistant in systematically testing all 22 MCP embedded debugger tools on an STM32 board.

```plaintext
Please help me test all 22 MCP embedded debugger tools with my STM32 board. Start by connecting to the probe, then systematically test each tool category: probe management, memory operations, debug control, breakpoints, flash operations, RTT communication, and session management.
```

--------------------------------

### AI Assistant Prompt: List Probes

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/README.md

Example prompt to ask an AI assistant to list available debug probes on the system.

```plaintext
Please list available debug probes on the system
```

--------------------------------

### AI Assistant Prompt: Connect and Flash

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/README.md

Example prompt to instruct an AI assistant to connect to a specific STM32 board using a ST-Link probe and flash a firmware image.

```plaintext
Connect to my STM32G431CBTx using ST-Link probe, then flash the firmware at examples/STM32_demo/target/thumbv7em-none-eabi/release/STM32_demo
```

--------------------------------

### Start/Stop Calculation Command

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_TESTING_RESULTS.md

This is a single-character command sent to the RTT Down Channel 0 to start or stop the calculation process.

```text
rtt_write --ch=0 S
```

--------------------------------

### AI Assistant Prompt: Interactive RTT

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/README.md

Example prompt to ask an AI assistant to attach to RTT, display terminal channel data, and send a command to toggle an LED.

```plaintext
Please attach RTT and show me the data from the terminal channel. Then send a command 'L' to toggle the LED.
```

--------------------------------

### Get System Information Command

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_TESTING_RESULTS.md

This is a single-character command sent to the RTT Down Channel 0 to request system information.

```text
rtt_write --ch=0 I
```

--------------------------------

### AI Assistant Prompt: Memory Analysis

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/README.md

Example prompt to request an AI assistant to read a specified amount of memory from a given address and analyze its data format.

```plaintext
Read 64 bytes of memory from address 0x08000000 and analyze the data format
```

--------------------------------

### Get Debug Session Information

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/ALL_22_TOOLS_TESTING_SUMMARY.md

Retrieves detailed information about the current debug session, including probe and target details. Use this to confirm session parameters.

```cli
probe_info
```

--------------------------------

### Cargo.toml Dependencies Update for RTT

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_BIDIRECTIONAL_DESIGN.md

Updates the `Cargo.toml` file to remove the `defmt-rtt` dependency and add the `rtt-target` crate. This is a necessary setup step for implementing RTT bidirectional communication.

```toml
# Remove defmt-rtt, add rtt-target
[dependencies]
# defmt-rtt = { version = "1.0.0", optional = true }  # Remove
rtt-target = "0.5"  # Add

# Remove defmt feature from default
[features]
default = ["panic-probe"]  # Remove defmt-rtt

```

--------------------------------

### RTT Read after Reset Command

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_TESTING_RESULTS.md

Shows the responses received after sending the reset command, including confirmation on the Command channel and the start of a new Fibonacci sequence on the Data channel.

```text
📥 RTT Read from Channel 0
Data: Fibonacci counter reset to 0
Milestone: 10 Fibonacci numbers calculated

📥 RTT Read from Channel 1 (Data)
Data: F(0) = 0
F(1) = 1
F(2) = 1
...
```

--------------------------------

### Get Fibonacci Value Command

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_TESTING_RESULTS.md

This is a single-character command sent to the RTT Down Channel 0 to retrieve the current Fibonacci value.

```text
rtt_write --ch=0 F
```

--------------------------------

### Get Debug Session Status

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/ALL_22_TOOLS_TESTING_SUMMARY.md

Monitors the real-time status of the debug session, including core registers and session state. Useful for live debugging.

```cli
get_status
```

--------------------------------

### Build STM32 Demo Firmware

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/README.md

Builds the firmware for the STM32 demo using Cargo. Ensure you are in the correct directory.

```bash
cd examples/STM32_demo
cargo build --release
```

--------------------------------

### Firmware Deployment Summary

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/ALL_22_TOOLS_TESTING_SUMMARY.md

Provides a summary of the firmware deployment process, including flash operations, target reset, and RTT attachment.

```text
🚀 Firmware deployment completed!

Total Time: 6.1s

Status:
🔄 Step 1/5: Erasing flash memory...
✅ Flash erased successfully
🔄 Step 2/5: Programming firmware...
✅ Programmed 510636 bytes
🔄 Step 3/5: Resetting target...
✅ Target reset successfully
✅ Target running
🔄 Step 4/5: Attaching RTT (probe-rs style)...
✅ RTT attached on attempt 1 (3 up, 2 down channels)
🔄 Step 5/5: Finalizing...

✅ Firmware is now running on target.
```

--------------------------------

### Main Application Structure with RTT Bidirectional Channels

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_BIDIRECTIONAL_DESIGN.md

Initializes RTT with multiple up and down channels for bidirectional communication. Sets up global state for LED, calculation, and speed multiplier. The main loop processes commands and performs Fibonacci calculations.

```rust
#![no_std]
#![no_main]

use rtt_target::{rtt_init, rprintln};
use core::fmt::Write;
use embassy_executor::Spawner;
use embassy_stm32::gpio::{Level, Output, Speed};
use embassy_time::{Duration, Timer};

// Global state for commands
static mut LED_STATE: bool = false;
static mut CALCULATION_ACTIVE: bool = true;
static mut SPEED_MULTIPLIER: u32 = 1;

#[embassy_executor::main]
async fn main(_spawner: Spawner) {
    let p = embassy_stm32::init(Default::default());
    let mut led = Output::new(p.PB7, Level::Low, Speed::Low);
    
    // Initialize RTT with bidirectional channels
    let channels = rtt_init! {
        up: {
            0: { size: 1024, mode: NoBlockSkip, name: "Terminal" }
            1: { size: 512, mode: NoBlockSkip, name: "Data" }
            2: { size: 256, mode: NoBlockSkip, name: "Debug" }
        }
        down: {
            0: { size: 64, mode: NoBlockSkip, name: "Commands" }
            1: { size: 128, mode: NoBlockSkip, name: "Config" }
        }
    };

    writeln!(channels.up.0, "RTT Bidirectional Demo Started").ok();
    writeln!(channels.up.2, "Channels: 3 Up, 2 Down").ok();
    
    let mut fib_index = 0u32;
    let mut cmd_buffer = [0u8; 64];
    let mut config_buffer = [0u8; 128];

    loop {
        // Process incoming commands
        process_commands(&channels, &mut cmd_buffer, &mut config_buffer, &mut led).await;
        
        // Fibonacci calculation (if active)
        if unsafe { CALCULATION_ACTIVE } {
            let fib_value = fibonacci(fib_index);
            writeln!(channels.up.1, "F({})", fib_index, fib_value).ok();
            
            if fib_index % 10 == 0 {
                writeln!(channels.up.0, "Milestone: {} Fibonacci numbers calculated", fib_index).ok();
            }
            
            fib_index += 1;
        }
        
        // LED control
        if unsafe { LED_STATE } {
            led.set_high();
        } else {
            led.set_low();
        }
        
        // Variable delay based on speed setting
        let delay_ms = 1000 * unsafe { SPEED_MULTIPLIER };
        Timer::after(Duration::from_millis(delay_ms.into())).await;
    }
}

```

--------------------------------

### Firmware Deployment Results

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_TESTING_RESULTS.md

Shows the output of a successful firmware deployment process, including RTT attachment.

```text
🚀 Firmware deployment completed!

Session ID: session_1754377337779
File: G:\\codes\\MCP_server\\demo_code\\target\\thumbv7em-none-eabi\\release\\demo_code
Format: elf
Total Time: 6.1s

Status:
🔄 Step 1/5: Erasing flash memory...
✅ Flash erased successfully
🔄 Step 2/5: Programming firmware...
✅ Programmed 510636 bytes
🔄 Step 3/5: Resetting target...
✅ Target reset successfully
✅ Target running
🔄 Step 4/5: Attaching RTT (probe-rs style)...
✅ RTT attached on attempt 1 (3 up, 2 down channels)
🔄 Step 5/5: Finalizing...

✅ Firmware is now running on target.
```

--------------------------------

### RTT Write to Command Channel (System Info)

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_TESTING_RESULTS.md

Demonstrates sending the 'I' command to the RTT Command channel (Down 0) to request system information.

```text
📤 RTT Write to Channel 0
Data: I
Bytes Written: 1
```

--------------------------------

### RTT Write Configuration

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_TESTING_RESULTS.md

This snippet demonstrates writing configuration data to RTT Down Channel 1 using the rtt_write tool, expecting configuration to be applied.

```text
rtt_write --ch=1 <config_data>
```

--------------------------------

### Test Commands for MCP Validation

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_BIDIRECTIONAL_DESIGN.md

This snippet demonstrates various commands for testing MCP tool functionality. It includes commands for toggling LEDs, retrieving system information, setting speed, configuring LEDs, and reading responses from different RTT channels.

```bash
# Test single commands
mcp__embedded-debugger__rtt_write --channel=0 --data="L"  # Toggle LED
mcp__embedded-debugger__rtt_write --channel=0 --data="I"  # System info
mcp__embedded-debugger__rtt_write --channel=0 --data="5"  # Set speed

# Test configuration commands  
mcp__embedded-debugger__rtt_write --channel=1 --data="SPEED:3"
mcp__embedded-debugger__rtt_write --channel=1 --data="LED:ON"

# Read responses
mcp__embedded-debugger__rtt_read --channel=0  # Terminal
mcp__embedded-debugger__rtt_read --channel=1  # Data
mcp__embedded-debugger__rtt_read --channel=2  # Debug
```

--------------------------------

### RTT Write to Command Channel (LED Toggle)

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_TESTING_RESULTS.md

Demonstrates sending a single-character command ('L') to the RTT Command channel (Down 0) to toggle the LED.

```text
📤 RTT Write to Channel 0
Data: L
Bytes Written: 1
```

--------------------------------

### Full System Reset Command

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_TESTING_RESULTS.md

This command initiates a full system reset via RTT Down Channel 1.

```text
rtt_write --ch=1 RESET
```

--------------------------------

### Single Step Execution

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/ALL_22_TOOLS_TESTING_SUMMARY.md

Executes a single instruction on the target microcontroller. Useful for detailed code tracing.

```cli
step
```

--------------------------------

### Claude Desktop Configuration (Windows)

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/README.md

Configure Claude Desktop to use the embedded debugger MCP server on Windows. Ensure the command path points to the correct executable.

```json
{
  "mcpServers": {
    "embedded-debugger": {
      "command": "C:\\path\\to\\debugger-mcp-rs\\target\\release\\embedded-debugger-mcp.exe",
      "args": [],
      "env": {
        "RUST_LOG": "info"
      }
    }
  }
}
```

--------------------------------

### RTT Write Commands

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_TESTING_RESULTS.md

This snippet demonstrates writing commands to RTT Down Channel 0 using the rtt_write tool, expecting immediate command execution.

```text
rtt_write --ch=0 <command>
```

--------------------------------

### Target-Side RTT Channel Configuration

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_BIDIRECTIONAL_DESIGN.md

Configures multiple up and down RTT channels with specified sizes, modes, and names using the `rtt-init!` macro from the `rtt-target` crate. Use this to set up communication channels for logging, data streaming, and command reception.

```rust
let channels = rtt_init! {
    up: {
        0: { 
            size: 1024, 
            mode: NoBlockSkip, 
            name: "Terminal" 
        }      // General logging & status
        1: { 
            size: 512, 
            mode: NoBlockSkip, 
            name: "Data" 
        }         // Fibonacci results & telemetry
        2: { 
            size: 256, 
            mode: NoBlockSkip, 
            name: "Debug" 
        }        // Debug information
    }
    down: {
        0: { 
            size: 64, 
            mode: NoBlockSkip, 
            name: "Commands" 
        }      // Single-character commands
        1: { 
            size: 128, 
            mode: NoBlockSkip, 
            name: "Config" 
        }       // Configuration data
    }
};

```

--------------------------------

### List Debug Probes

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/ALL_22_TOOLS_TESTING_SUMMARY.md

Lists available debug probes connected to the system. Useful for identifying the target probe before initiating a session.

```cli
list_probes
```

--------------------------------

### Build Embedded Debugger MCP Server

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/README.md

Clone the repository and build the embedded debugger MCP server from source using Cargo.

```bash
git clone https://github.com/adancurusul/embedded-debugger-mcp.git
cd embedded-debugger-mcp
cargo build --release
```

--------------------------------

### Claude Desktop Configuration (macOS/Linux)

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/README.md

Configure Claude Desktop to use the embedded debugger MCP server on macOS or Linux. Ensure the command path points to the correct executable.

```json
{
  "mcpServers": {
    "embedded-debugger": {
      "command": "/path/to/debugger-mcp-rs/target/release/embedded-debugger-mcp",
      "args": [],
      "env": {
        "RUST_LOG": "info"
      }
    }
  }
}
```

--------------------------------

### RTT Read from Command Channel (LED Toggle Response)

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_TESTING_RESULTS.md

Shows the response received from the RTT Command channel (Up 0) after sending the LED toggle command.

```text
📥 RTT Read from Channel 0
Data: LED toggled: true
```

--------------------------------

### Debug Session Establishment Confirmation

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/ALL_22_TOOLS_TESTING_SUMMARY.md

Confirms the successful establishment of a debug session, providing session details and connection time.

```text
✅ Debug session established!

Session ID: session_1754380648429
Probe: STLink V2 (VID:PID = 0483:3748)
Target: STM32G431CBTx
Connected at: 2025-08-05 07:57:28 UTC

Target connection established and ready for debugging.
```

--------------------------------

### Receive SPEED Configuration Response

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_TESTING_RESULTS.md

This snippet shows the RTT response received after sending a configuration command. It confirms that the configuration was parsed and applied successfully.

```text
RTT_PRINTF(0, "Config received: SPEED:%d\nSpeed configured to: %dx\n", speed, speed);
```

--------------------------------

### RTT Attach to Channels

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_TESTING_RESULTS.md

This snippet demonstrates establishing a connection and attaching to RTT channels.

```text
rtt_attach
```

--------------------------------

### RTT Write to Command Channel (Reset)

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_TESTING_RESULTS.md

Demonstrates sending the 'R' command to the RTT Command channel (Down 0) to reset the Fibonacci counter.

```text
📤 RTT Write to Channel 0
Data: R
Bytes Written: 1
```

--------------------------------

### Toggle LED Command

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_TESTING_RESULTS.md

This is a single-character command sent to the RTT Down Channel 0 to toggle the LED state.

```text
rtt_write --ch=0 L
```

--------------------------------

### Send SPEED Configuration Command

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_TESTING_RESULTS.md

This snippet shows the RTT command sent to configure the speed. It targets Channel 1 and specifies a speed multiplier of 3.

```text
Rtt_Write(1, (const char*)"SPEED:3", 7);
```

--------------------------------

### Control LED State Command

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_TESTING_RESULTS.md

This command is used to control the LED state (ON/OFF) via RTT Down Channel 1.

```text
rtt_write --ch=1 LED:ON
```

--------------------------------

### Command Processing Implementation for RTT Channels

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_BIDIRECTIONAL_DESIGN.md

Handles incoming commands from the 'Commands' channel and configuration data from the 'Config' channel. Parses single-character commands to control LED, reset Fibonacci, toggle calculation, query status, pause, or set speed. Processes configuration strings.

```rust
async fn process_commands(
    channels: &rtt_target::Channels,
    cmd_buf: &mut [u8],
    config_buf: &mut [u8], 
    led: &mut Output<'_>
) {
    // Process single-character commands
    if let Ok(bytes) = channels.down.0.read(cmd_buf) {
        for i in 0..bytes {
            match cmd_buf[i] as char {
                'L' => {
                    unsafe { LED_STATE = !LED_STATE; }
                    writeln!(channels.up.0, "LED toggled: {}", unsafe { LED_STATE }).ok();
                }
                'R' => {
                    // Reset handled in main loop
                    writeln!(channels.up.0, "Fibonacci counter reset requested").ok();
                }
                'S' => {
                    unsafe { CALCULATION_ACTIVE = !CALCULATION_ACTIVE; }
                    writeln!(channels.up.0, "Calculation {}", 
                           if unsafe { CALCULATION_ACTIVE } { "started" } else { "stopped" }).ok();
                }
                'F' => {
                    writeln!(channels.up.0, "Current Fibonacci index: {}", /* current index */).ok();
                }
                'I' => {
                    writeln!(channels.up.0, "System: STM32G431CBTx, RTT Bidirectional Demo").ok();
                    writeln!(channels.up.2, "Speed: {}, LED: {}, Calc: {}", 
                           unsafe { SPEED_MULTIPLIER }, 
                           unsafe { LED_STATE }, 
                           unsafe { CALCULATION_ACTIVE }).ok();
                }
                'P' => {
                    writeln!(channels.up.0, "Pausing for 5 seconds...").ok();
                    Timer::after(Duration::from_secs(5)).await;
                    writeln!(channels.up.0, "Pause complete").ok();
                }
                '0'..='9' => {
                    let speed = (cmd_buf[i] - b'0' + 1) as u32;
                    unsafe { SPEED_MULTIPLIER = speed; }
                    writeln!(channels.up.0, "Speed set to: {}", speed).ok();
                }
                _ => {
                    writeln!(channels.up.2, "Unknown command: 0x{:02X}", cmd_buf[i]).ok();
                }
            }
        }
    }
    
    // Process configuration commands
    if let Ok(bytes) = channels.down.1.read(config_buf) {
        if bytes > 0 {
            if let Ok(s) = core::str::from_utf8(&config_buf[..bytes]) {
                writeln!(channels.up.0, "Config received: {}", s).ok();
                // Parse and process configuration
                process_config_string(s, channels);
            }
        }
    }
}

```

--------------------------------

### Resume Target Execution

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/ALL_22_TOOLS_TESTING_SUMMARY.md

Resumes the execution of the target microcontroller after it has been halted. Use to continue normal operation.

```cli
run
```

--------------------------------

### RTT Read for System Information Command

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_TESTING_RESULTS.md

Shows the multi-channel response received after requesting system information, including data from both the Command and Debug channels.

```text
📥 RTT Read from Channel 0
Data: System: STM32G431CBTx RTT Bidirectional Demo

📥 RTT Read from Channel 2 (Debug)
Data: Status - Speed:1, LED:true, Calc:true, Index:43
```

--------------------------------

### Set Speed Configuration Command

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_TESTING_RESULTS.md

This command is used to set the speed multiplier via RTT Down Channel 1.

```text
rtt_write --ch=1 SPEED:3
```

--------------------------------

### Program Flash Memory

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/ALL_22_TOOLS_TESTING_SUMMARY.md

Programs the flash memory of the target device with firmware from an ELF file. Includes verification of the programming process.

```cli
flash_program
File: G:\\codes\\MCP_server\\demo_code\\target\\thumbv7em-none-eabi\\release\\demo_code
Format: elf
```

--------------------------------

### Set Hardware Breakpoint

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/ALL_22_TOOLS_TESTING_SUMMARY.md

Sets a hardware breakpoint at a specified memory address. The target will halt when execution reaches this address.

```cli
set_breakpoint
Address: 0x080012A0
Type: Hardware breakpoint
```

--------------------------------

### System Status from RTT Debug Channel

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/ALL_22_TOOLS_TESTING_SUMMARY.md

Shows real-time system status updates received from RTT Debug Channel (Up 2), including loop count, speed, and LED status.

```text
Status: Loop#50, Speed:1x, LED:true, Calc:true, FibIdx:50
```

--------------------------------

### Reset Target Device

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/ALL_22_TOOLS_TESTING_SUMMARY.md

Performs a hardware reset of the target microcontroller. Use to restart the application or recover from an unresponsive state.

```cli
reset
```

--------------------------------

### RTT Read Fibonacci Results

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_TESTING_RESULTS.md

This snippet demonstrates reading Fibonacci results from RTT Up Channel 1 using the rtt_read tool.

```text
rtt_read --ch=1
```

--------------------------------

### Set Speed Command

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_TESTING_RESULTS.md

This command is used to set the speed multiplier (1x-10x) via RTT Down Channel 0.

```text
rtt_write --ch=0 3
```

--------------------------------

### RTT Channel Detection Output

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_TESTING_RESULTS.md

Displays the detected RTT channels after successful attachment, listing both up and down channels with their configurations.

```text
📋 RTT Channels

Session ID: session_1754377337779

📥 Up Channels (Target → Host):
  0. Terminal (Size: 1024 bytes, Mode: RTT)
  2. Debug (Size: 256 bytes, Mode: RTT)
  1. Data (Size: 512 bytes, Mode: RTT)

📤 Down Channels (Host → Target):
  0. Commands (Size: 64 bytes, Mode: RTT)
  1. Config (Size: 128 bytes, Mode: RTT)
```

--------------------------------

### RTT Channel Discovery

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_TESTING_RESULTS.md

This snippet shows the command used to discover all available RTT channels.

```text
rtt_channels
```

--------------------------------

### Flash Verification Failure Details

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/ALL_22_TOOLS_TESTING_SUMMARY.md

Details a flash verification failure, highlighting the number of mismatches and the first two differing bytes.

```text
❌ Flash verification failed!

Bytes Verified: 16
Mismatches: 2

First 2 mismatches:
  1. 0x08000004: expected 0x01, got 0xD9
  2. 0x08000005: expected 0xD9, got 0x01
```

--------------------------------

### Set Calculation Mode Command

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_TESTING_RESULTS.md

This command is used to set the calculation mode to AUTO or MANUAL via RTT Down Channel 1.

```text
rtt_write --ch=1 MODE:AUTO
```

--------------------------------

### RTT Channel Information

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/ALL_22_TOOLS_TESTING_SUMMARY.md

Lists the detected RTT channels, categorizing them into Up (Target → Host) and Down (Host → Target) with their respective sizes and modes.

```text
📋 RTT Channels

📥 Up Channels (Target → Host):
  0. Terminal (Size: 1024 bytes, Mode: RTT)
  2. Debug (Size: 256 bytes, Mode: RTT)  
  1. Data (Size: 512 bytes, Mode: RTT)

📤 Down Channels (Host → Target):
  0. Commands (Size: 64 bytes, Mode: RTT)
  1. Config (Size: 128 bytes, Mode: RTT)
```

--------------------------------

### Halt Target Execution

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/ALL_22_TOOLS_TESTING_SUMMARY.md

Stops the execution of the target microcontroller. Use this to inspect the system state at a specific point.

```cli
halt
```

--------------------------------

### RTT Attachment Confirmation

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/ALL_22_TOOLS_TESTING_SUMMARY.md

Indicates a successful RTT attachment on the first attempt, noting the number of detected channels.

```text
✅ RTT attached on attempt 1 (3 up, 2 down channels)
```

--------------------------------

### RTT Data Channel Read (Fibonacci Results)

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_TESTING_RESULTS.md

Displays the data read from the RTT Data channel (Up 1), containing a sequence of calculated Fibonacci numbers.

```text
📥 RTT Read from Channel 1

Bytes Read: 255

Data:
Text: F(0) = 0
F(1) = 1
F(2) = 1
F(3) = 2
F(4) = 3
F(5) = 5
F(6) = 8
F(7) = 13
F(8) = 21
F(9) = 34
F(10) = 55
F(11) = 89
F(12) = 144
F(13) = 233
F(14) = 377
F(15) = 610
F(16) = 987
F(17) = 1597
F(18) = 2584
F(19) = 4181
F(20) = 6765
F(21) = 10946
F(22) = 17711
```

--------------------------------

### RTT Read from Terminal Channel

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/ALL_22_TOOLS_TESTING_SUMMARY.md

Displays data read from RTT Channel 0 (Terminal), including system information and available commands.

```text
📥 RTT Read from Channel 0

Bytes Read: 516

Data:
Text: === RTT Bidirectional Communication Demo ===
Target: STM32G431CBTx
Channels: 3 Up (Terminal/Data/Debug), 2 Down (Commands/Config)

Available Commands (send to down channel 0):
  L - Toggle LED
  R - Reset Fibonacci counter
  S - Start/Stop calculation
  F - Get current Fibonacci value
  I - System information
  P - Pause 5 seconds
  0-9 - Set speed (1x-10x)

Config Commands (send to down channel 1):
  SPEED:n, LED:ON/OFF, MODE:AUTO/MANUAL, RESET

Starting main loop...
Milestone: 10 Fibonacci numbers calculated
```

--------------------------------

### Pause Calculation Command

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_TESTING_RESULTS.md

This is a single-character command sent to the RTT Down Channel 0 to pause the calculation for 5 seconds.

```text
rtt_write --ch=0 P
```

--------------------------------

### RTT Read Status Information

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_TESTING_RESULTS.md

This snippet demonstrates reading status information from RTT Up Channel 2 using the rtt_read tool.

```text
rtt_read --ch=2
```

--------------------------------

### RTT Write to Channel 0

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/ALL_22_TOOLS_TESTING_SUMMARY.md

Confirms a successful RTT write operation to Channel 0, specifying the data sent and bytes written.

```text
📤 RTT Write to Channel 0

Data: F
Encoding: utf8
Bytes Written: 1

Data sent successfully to target.
```

--------------------------------

### Read Memory Content

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/ALL_22_TOOLS_TESTING_SUMMARY.md

Reads a specified block of memory from the target device. Useful for inspecting memory state or verifying writes.

```cli
read_memory
Address: 0x08000000
Size: 64 bytes
Format: hex
```

--------------------------------

### Write Memory Content

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/ALL_22_TOOLS_TESTING_SUMMARY.md

Writes data to a specified memory address on the target device. Use for modifying RAM or flash memory.

```cli
write_memory
Address: 0x20007F00
Data: CAFEBABE
Format: hex
```

--------------------------------

### Fibonacci Stream from RTT Data Channel

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/ALL_22_TOOLS_TESTING_SUMMARY.md

Illustrates a continuous stream of Fibonacci numbers received from RTT Data Channel (Up 1).

```text
F(0) = 0
F(1) = 1
F(2) = 1
F(3) = 2
F(4) = 3
F(5) = 5
F(6) = 8
F(7) = 13
...continuous stream...
```

--------------------------------

### Clear Breakpoint

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/ALL_22_TOOLS_TESTING_SUMMARY.md

Removes a previously set breakpoint from the target device. Use to disable halting at a specific address.

```cli
clear_breakpoint
Address: 0x080012A0
```

--------------------------------

### Debug Session Disconnection Confirmation

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/ALL_22_TOOLS_TESTING_SUMMARY.md

Confirms successful disconnection of a debug session, including session details and duration.

```text
✅ Debug session disconnected successfully

Session ID: session_1754377337779
Probe: STLink V2
Target: STM32G431CBTx
Duration: 55.1 minutes

probe-rs Session resources have been cleaned up.
```

--------------------------------

### RTT Detach from Channels

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_TESTING_RESULTS.md

This snippet shows the command for cleanly disconnecting and detaching from RTT channels.

```text
rtt_detach
```

--------------------------------

### RTT Read Terminal Messages

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_TESTING_RESULTS.md

This snippet demonstrates reading text messages from RTT Up Channel 0 using the rtt_read tool.

```text
rtt_read --ch=0
```

--------------------------------

### RTT Detach Confirmation

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/ALL_22_TOOLS_TESTING_SUMMARY.md

Confirms that RTT communication has been successfully closed.

```text
✅ RTT detached successfully

RTT communication has been closed.
```

--------------------------------

### Reset Fibonacci Counter Command

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/RTT_TESTING_RESULTS.md

This is a single-character command sent to the RTT Down Channel 0 to reset the Fibonacci counter.

```text
rtt_write --ch=0 R
```

--------------------------------

### Flash Erase Confirmation

Source: https://github.com/adancurusul/embedded-debugger-mcp/blob/main/examples/STM32_demo/docs/ALL_22_TOOLS_TESTING_SUMMARY.md

Confirms successful completion of a full chip flash erase operation, noting the duration.

```text
✅ Flash erase completed successfully!

Erase Type: all
Duration: 121ms
Full chip erased

Flash memory has been erased and is ready for programming.
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.