Rust no-std Embedded Development: Building Bare Metal Firmware from Scratch 2026

In the embedded development space, C has long been the dominant language. But as the Rust ecosystem matures, more teams are replacing C with Rust to build safe and reliable bare metal firmware. Rust's ownership system eliminates memory safety vulnerabilities at compile time, while the no_std environment allows Rust to run on bare metal hardware without any operating system. This guide walks you through the core patterns of Rust embedded development from the ground up.

Core Concepts at a Glance

Concept	Description	Use Case
no_std	Disables Rust standard library, uses only core and alloc	Bare metal / RTOS environments
cortex-m-rt	Cortex-M runtime entry and linker scripts	ARM Cortex-M series MCUs
PAC	Peripheral Access Crate, direct register mapping	Low-level driver development
HAL	Hardware Abstraction Layer, high-level API	Application-level development
critical-section	Critical section abstraction, cross-platform safety	Interrupt-safe code
defmt	Zero-cost logging framework	Embedded debugging
RTIC	Interrupt-based real-time concurrency framework	Real-time systems
embassy	Async embedded executor	High-concurrency peripheral operations

Five Key Pain Points

1. Complex Environment Setup: The Rust embedded toolchain requires cross-compilation, debugger connections, and flashing tools — newcomers often give up at the environment configuration stage
2. Opaque Bare Metal Startup: The boot process between MCU power-on and main() execution (vector table, stack initialization, data section copying) is a black box for many developers
3. High Barrier for Peripheral Drivers: Register operations, timing control, and DMA configuration require understanding both hardware reference manuals and Rust's unsafe semantics
4. Bug-Prone Interrupt Handling: Data races between interrupts and the main loop, priority configuration, and nested interrupts are all high-frequency bug sources
5. Lack of RTOS Integration Best Practices: FreeRTOS/RT-Thread interop with Rust, memory allocation strategies, and inter-task communication lack mature solutions

Step-by-Step: 5 Core Patterns

Pattern 1: no_std Environment Setup

Runtime: Rust 1.85+ / cortex-m target / probe-rs 0.24+

First, create a no_std project and configure the cross-compilation target:

# Install Rust embedded target
rustup target add thumbv7em-none-eabihf

# Create no_std project
cargo new --lib embedded-firmware
cd embedded-firmware

# Cargo.toml
[package]
name = "embedded-firmware"
version = "0.1.0"
edition = "2021"

[dependencies]
cortex-m = "0.7"
cortex-m-rt = "0.7"
panic-halt = "1.0"
defmt = "0.3"
defmt-rtt = "0.4"

[profile.release]
opt-level = "s"
lto = true
codegen-units = 1

[[bin]]
name = "embedded-firmware"
path = "src/main.rs"

// src/main.rs
#![no_main]
#![no_std]

use cortex_m_rt::entry;
use panic_halt as _;
use defmt::info;

#[entry]
fn main() -> ! {
    info!("Hello from no_std Rust!");

    loop {
        cortex_m::asm::delay(8_000_000); // ~1 second delay (8MHz clock)
    }
}

# .cargo/config.toml
[build]
target = "thumbv7em-none-eabihf"

[target.thumbv7em-none-eabihf]
runner = "probe-rs run --chip STM32F411CEUx"

rustflags = [
    "-C", "link-arg=-Tlink.x",
    "-C", "link-arg=--nmagic",
    "-C", "link-arg=-Tdefmt.x",
]

Pattern 2: Cortex-M Bare Metal Startup

Understand and customize the boot process, master the vector table and linker scripts:

// src/startup.rs
//! Custom startup code - Understanding MCU boot from power-on to main

use core::arch::global_asm;

// Vector table: The first data structure read after MCU power-on
// Located at the start of Flash, contains initial stack pointer and interrupt vectors
global_asm!(
    ".section .vector_table, \"a\"",
    ".global _vector_table",
    "_vector_table:",
    "    .word _estack           // Initial stack pointer (points to end of RAM)",
    "    .word Reset             // Reset handler",
    "    .word NMI               // NMI handler",
    "    .word HardFault         // HardFault handler",
    "    .word 0                 // MemManage (Cortex-M7 only)",
    "    .word 0                 // BusFault",
    "    .word 0                 // UsageFault",
    "    .word 0                 // Reserved",
    "    .word 0                 // Reserved",
    "    .word 0                 // Reserved",
    "    .word 0                 // Reserved",
    "    .word SVCall            // SVC call",
    "    .word DebugMonitor      // Debug Monitor",
    "    .word 0                 // Reserved",
    "    .word PendSV            // PendSV (context switch)",
    "    .word SysTick           // SysTick timer",
);

/// Reset handler: Executed after MCU power-on or reset
/// Responsible for: initializing .data section, zeroing .bss section, calling main
#[no_mangle]
pub unsafe extern "C" fn Reset() -> ! {
    // 1. Initialize .data section: Copy initialization data from Flash to RAM
    extern "C" {
        static mut _sdata: u32;
        static mut _edata: u32;
        static _sidata: u32;
    }

    let mut src = &_sidata as *const u32;
    let mut dst = &mut _sdata as *mut u32;
    while dst < &mut _edata as *mut u32 {
        dst.write_volatile(src.read_volatile());
        src = src.add(1);
        dst = dst.add(1);
    }

    // 2. Zero .bss section
    extern "C" {
        static mut _sbss: u32;
        static mut _ebss: u32;
    }

    let mut bss_dst = &mut _sbss as *mut u32;
    while bss_dst < &mut _ebss as *mut u32 {
        bss_dst.write_volatile(0);
        bss_dst = bss_dst.add(1);
    }

    // 3. Call Rust main function
    extern "Rust" {
        fn main() -> !;
    }
    main()
}

/// HardFault handler - The most critical exception handler in embedded systems
#[no_mangle]
pub unsafe extern "C" fn HardFault() -> ! {
    // Read HardFault status register for diagnosis
    let scb = cortex_m::peripheral::SCB::ptr();
    let hfsr = (*scb).hfsr.read();
    defmt::error!("HardFault! HFSR = {:08x}", hfsr);

    // Read stacked registers for debugging
    let psp = cortex_m::register::psp::read();
    if psp != 0 {
        let stack_frame = psp as *const u32;
        defmt::error!("R0  = {:08x}", *stack_frame.offset(0));
        defmt::error!("R3  = {:08x}", *stack_frame.offset(3));
        defmt::error!("R12 = {:08x}", *stack_frame.offset(4));
        defmt::error!("LR  = {:08x}", *stack_frame.offset(5));
        defmt::error!("PC  = {:08x}", *stack_frame.offset(6));
    }

    loop {}
}

fn NMI() {}
fn SVCall() {}
fn DebugMonitor() {}
fn PendSV() {}
fn SysTick() {}

Pattern 3: Peripheral Driver Development

Develop peripheral drivers based on PAC and HAL, using GPIO and UART as examples:

// src/drivers/led.rs
//! LED driver - GPIO wrapper based on HAL

use embedded_hal::digital::OutputPin;
use cortex_m::delay::Delay;

/// LED driver struct
pub struct Led<PIN: OutputPin> {
    pin: PIN,
    active_low: bool,
}

impl<PIN: OutputPin> Led<PIN> {
    /// Create a new LED instance
    /// - `pin`: GPIO output pin
    /// - `active_low`: true means active-low (common anode LED)
    pub fn new(pin: PIN, active_low: bool) -> Self {
        let mut led = Self { pin, active_low };
        led.off(); // Turn off LED on init
        led
    }

    /// Turn on LED
    pub fn on(&mut self) {
        if self.active_low {
            self.pin.set_low().ok();
        } else {
            self.pin.set_high().ok();
        }
    }

    /// Turn off LED
    pub fn off(&mut self) {
        if self.active_low {
            self.pin.set_high().ok();
        } else {
            self.pin.set_low().ok();
        }
    }

    /// LED breathing effect (software PWM)
    pub fn breathe(&mut self, delay: &mut Delay, cycles: u32) {
        const STEPS: u32 = 100;
        for _ in 0..cycles {
            // Brightness increasing
            for i in 0..STEPS {
                self.on();
                delay.delay_us(i);
                self.off();
                delay.delay_us(STEPS - i);
            }
            // Brightness decreasing
            for i in (0..STEPS).rev() {
                self.on();
                delay.delay_us(i);
                self.off();
                delay.delay_us(STEPS - i);
            }
        }
    }
}

// src/drivers/uart.rs
//! UART driver - Serial communication wrapper based on HAL

use embedded_hal::serial::{Read, Write};
use nb::block;

/// UART error type
#[derive(Debug, defmt::Format)]
pub enum UartError {
    Framing,
    Noise,
    Overrun,
    Parity,
    BufferFull,
}

/// Ring buffer - For interrupt-driven reception
pub struct RingBuffer<const N: usize> {
    buffer: [u8; N],
    head: usize,
    tail: usize,
    full: bool,
}

impl<const N: usize> RingBuffer<N> {
    pub const fn new() -> Self {
        Self {
            buffer: [0u8; N],
            head: 0,
            tail: 0,
            full: false,
        }
    }

    pub fn push(&mut self, byte: u8) -> bool {
        if self.full {
            return false;
        }
        self.buffer[self.head] = byte;
        self.head = (self.head + 1) % N;
        if self.head == self.tail {
            self.full = true;
        }
        true
    }

    pub fn pop(&mut self) -> Option<u8> {
        if self.is_empty() {
            return None;
        }
        let byte = self.buffer[self.tail];
        self.tail = (self.tail + 1) % N;
        self.full = false;
        Some(byte)
    }

    pub fn is_empty(&self) -> bool {
        self.head == self.tail && !self.full
    }

    pub fn len(&self) -> usize {
        if self.full {
            return N;
        }
        if self.head >= self.tail {
            self.head - self.tail
        } else {
            N - self.tail + self.head
        }
    }
}

/// UART communication interface
pub struct UartDriver<SERIAL> {
    serial: SERIAL,
    rx_buffer: RingBuffer<256>,
}

impl<SERIAL, E> UartDriver<SERIAL>
where
    SERIAL: Read<u8, Error = E> + Write<u8, Error = E>,
    E: defmt::Format,
{
    pub fn new(serial: SERIAL) -> Self {
        Self {
            serial,
            rx_buffer: RingBuffer::new(),
        }
    }

    /// Non-blocking read of interrupt-received data
    pub fn read_byte(&mut self) -> Option<u8> {
        self.rx_buffer.pop()
    }

    /// Called from interrupt: Store received byte in buffer
    pub fn on_rx_interrupt(&mut self) {
        match self.serial.read() {
            Ok(byte) => {
                if !self.rx_buffer.push(byte) {
                    defmt::warn!("UART RX buffer overflow!");
                }
            }
            Err(nb::Error::WouldBlock) => {}
            Err(nb::Error::Other(_)) => {
                defmt::error!("UART read error");
            }
        }
    }

    /// Blocking send byte
    pub fn write_byte(&mut self, byte: u8) {
        block!(self.serial.write(byte)).ok();
    }

    /// Blocking send string
    pub fn write_str(&mut self, s: &str) {
        for byte in s.bytes() {
            self.write_byte(byte);
        }
    }

    /// Release ownership of underlying serial
    pub fn free(self) -> SERIAL {
        self.serial
    }
}

Pattern 4: Interrupt Handling

Safe interrupt handling patterns to avoid data races:

// src/interrupts.rs
//! Safe interrupt handling - Using cortex_m::interrupt and atomics

use core::sync::atomic::{AtomicU32, AtomicBool, Ordering};
use cortex_m::interrupt::{self, Mutex};
use core::cell::RefCell;
use stm32f4xx_hal::pac::{self, interrupt};

/// Method 1: Atomic operations - Simplest interrupt-safe approach
/// Suitable for simple flags and counters
static Systick_COUNT: AtomicU32 = AtomicU32::new(0);
static BUTTON_PRESSED: AtomicBool = AtomicBool::new(false);

/// Method 2: Mutex-protected shared resources
/// Suitable for sharing complex structures
type SharedSerial = Mutex<RefCell<Option<pac::USART1>>>;
static SHARED_SERIAL: SharedSerial = Mutex::new(RefCell::new(None));

/// Method 3: cortex_m::singleton! Compile-time guaranteed singleton
/// Suitable for peripherals with only one instance
cortex_m::singleton!(
    static SHARED_BUFFER: [u8; 128] = [0; 128];
);

/// SysTick interrupt - System tick
#[interrupt]
fn SysTick() {
    // Atomic operations don't require disabling interrupts, best performance
    Systick_COUNT.fetch_add(1, Ordering::Relaxed);

    if Systick_COUNT.load(Ordering::Relaxed) % 1000 == 0 {
        defmt::trace!("1 second elapsed");
    }
}

/// External button interrupt - GPIO interrupt
#[interrupt]
fn EXTI0() {
    // Clear interrupt pending flag
    unsafe {
        let exti = &*pac::EXTI::ptr();
        exti.pr.write(|w| w.pr0().set_bit());
    }

    // Set flag, process in main loop
    BUTTON_PRESSED.store(true, Ordering::Release);
}

/// USART1 interrupt - Serial receive interrupt
#[interrupt]
fn USART1() {
    // Use Mutex for safe access to shared serial
    interrupt::free(|cs| {
        let mut serial = SHARED_SERIAL.borrow(cs).borrow_mut();
        if let Some(ref mut usart1) = serial.deref_mut() {
            if usart1.sr.read().rxne().bit_is_set() {
                let byte = usart1.dr.read().bits() as u8;
                defmt::info!("RX: {:02x}", byte);
            }
        }
    });
}

/// Check interrupt flags in main loop
pub fn process_interrupt_flags() {
    if BUTTON_PRESSED.swap(false, Ordering::AcqRel) {
        defmt::info!("Button pressed!");
    }

    let tick = Systick_COUNT.load(Ordering::Acquire);
    if tick > 0 && tick % 5000 == 0 {
        defmt::info!("5 seconds elapsed, tick = {}", tick);
    }
}

use core::ops::DerefMut;

Pattern 5: RTOS Integration

Rust integration with FreeRTOS/embassy:

// src/rtos_embassy.rs
//! Embassy async executor - Rust-native "RTOS" solution

use embassy_executor::Spawner;
use embassy_stm32::{
    gpio::{Level, Output, Speed},
    usart::Uart,
    time::Hertz,
    Config,
};
use embassy_time::{Duration, Timer};

/// Embassy async task: LED blink
#[embassy_executor::task]
async fn blink_led(mut led: Output<'static, embassy_stm32::gpio::PA5>) {
    let mut counter = 0u32;
    loop {
        led.set_high();
        Timer::after(Duration::from_millis(500)).await;
        led.set_low();
        Timer::after(Duration::from_millis(500)).await;
        counter += 1;
        defmt::info!("Blink #{}", counter);
    }
}

/// Embassy async task: UART echo
#[embassy_executor::task]
async fn uart_echo(mut uart: Uart<'static, embassy_stm32::usart::USART2>) {
    use embassy_stm32::usart::Error;
    loop {
        let mut buf = [0u8; 1];
        match uart.read(&mut buf).await {
            Ok(_) => {
                let _ = uart.write(&buf).await;
            }
            Err(Error::Framing) => defmt::error!("UART framing error"),
            Err(_) => defmt::error!("UART error"),
        }
    }
}

/// Embassy async task: Sensor reading
#[embassy_executor::task]
async fn sensor_reader() {
    let mut values = [0u16; 64];
    let mut idx = 0;
    loop {
        Timer::after(Duration::from_secs(1)).await;

        let value = read_adc_channel(0);
        values[idx % 64] = value;
        idx += 1;

        if idx % 10 == 0 {
            let avg: u16 = values[..10].iter().sum::<u16>() / 10;
            defmt::info!("Sensor avg: {}", avg);
        }
    }
}

fn read_adc_channel(_ch: u8) -> u16 {
    42
}

/// Main entry - Embassy runtime
#[embassy_executor::main]
async fn main(spawner: Spawner) {
    let config = Config::default();
    let p = embassy_stm32::init(config);

    let led = Output::new(p.PA5, Level::Low, Speed::Low);

    let uart_config = embassy_stm32::usart::Config::default()
        .baudrate(Hertz(115200));
    let uart = Uart::new(
        p.USART2, p.PA3, p.PA2,
        uart_config,
    ).unwrap();

    spawner.spawn(blink_led(led)).ok();
    spawner.spawn(uart_echo(uart)).ok();
    spawner.spawn(sensor_reader()).ok();

    defmt::info!("Embassy RTOS started!");

    loop {
        Timer::after(Duration::from_secs(5)).await;
        defmt::info!("Main loop heartbeat");
    }
}

// src/rtos_freertos.rs
//! FreeRTOS + Rust integration - Using freertos-rust crate

use freertos_rust::{CurrentTask, Delay, FreeRtosAllocator, Task, TaskPriority};

// FreeRTOS global allocator - Must be declared
#[global_allocator]
static ALLOC: FreeRtosAllocator = FreeRtosAllocator;

/// FreeRTOS task function
fn led_task(_pv: *mut core::ffi::c_void) {
    loop {
        toggle_led();
        Delay::new(500);
    }
}

fn sensor_task(_pv: *mut core::ffi::c_void) {
    loop {
        let value = read_sensor();
        defmt::info!("Sensor: {}", value);
        Delay::new(1000);
    }
}

/// Start FreeRTOS tasks
pub fn start_freertos_tasks() {
    Task::new()
        .name("LED")
        .stack_size(256)
        .priority(TaskPriority(2))
        .start(led_task)
        .expect("Failed to create LED task");

    Task::new()
        .name("Sensor")
        .stack_size(512)
        .priority(TaskPriority(1))
        .start(sensor_task)
        .expect("Failed to create Sensor task");

    freertos_rust::start_scheduler();
}

fn toggle_led() { /* Hardware-specific */ }
fn read_sensor() -> u16 { 42 }

Pitfall Guide

Pitfall 1: Forgetting #![no_std] Causes Linker Errors

// ❌ Wrong: Missing no_std declaration
use std::println; // This pulls in the entire standard library!

// ✅ Correct: Must declare at crate root
#![no_std]
#![no_main]

Reason: Rust links the standard library by default, but embedded targets don't have OS support for it. Forgetting the declaration leads to numerous undefined symbol linker errors.

Pitfall 2: Calling Blocking Functions in Interrupts

// ❌ Wrong: Time-consuming operations in interrupt
#[interrupt]
fn USART1() {
    let data = blocking_read_sensor(); // May block for ms!
    process_data(data);
}

// ✅ Correct: Only set flags in interrupt, process in main loop
#[interrupt]
fn USART1() {
    DATA_READY.store(true, Ordering::Release);
}

loop {
    if DATA_READY.swap(false, Ordering::AcqRel) {
        let data = blocking_read_sensor();
        process_data(data);
    }
}

Pitfall 3: Shared Mutable State Without Protection

// ❌ Wrong: Raw shared mutable static variable
static mut BUFFER: [u8; 64] = [0; 64];

#[interrupt]
fn DMA1_STREAM0() {
    unsafe { BUFFER[0] = 42; } // Data race!
}

// ✅ Correct: Use Mutex or Atomic
use core::sync::atomic::AtomicU8;
static BUFFER_HEAD: AtomicU8 = AtomicU8::new(0);

Pitfall 4: PAC Register Operations Without unsafe

// ❌ Wrong: Direct PAC register access without safe API
let gpioa = unsafe { &*pac::GPIOA::ptr() };
gpioa.bsrr.write(|w| w.bits(1)); // Not using type-safe API

// ✅ Correct: Use PAC's type-safe API
let gpioa = unsafe { &*pac::GPIOA::ptr() };
gpioa.bsrr.write(|w| w.bs5().set_bit()); // Compile-time checked

Pitfall 5: Undetected Stack Overflow

// ❌ Wrong: Large array directly on stack
fn process() {
    let buffer = [0u8; 4096]; // STM32F103 only has 20KB RAM!
}

// ✅ Correct: Use static buffers or heap allocation
static BUFFER: cortex_m::singleton!(Buffer = [0u8; 4096]) = [0; 4096];

use embedded_alloc::Heap;
#[global_allocator]
static HEAP: Heap = Heap::empty();

Error Troubleshooting Table

Error Message	Cause	Solution
error: language item required, but not found: eh_personality	Missing no_std runtime support	Add #![no_main] and panic-halt dependency in main.rs
error: linking with cc failed	Missing linker script	Add -C link-arg=-Tlink.x to rustflags
error[E0152]: duplicate lang item	Multiple crates define the same lang item	Check if both std and no_std panic handlers are referenced
region FLASH overflowed	Firmware exceeds Flash capacity	Enable LTO, reduce codegen-units to 1, use opt-level=s
region RAM overflowed	Insufficient RAM	Reduce stack/heap size, use static allocation instead of heap
HardFault at 0x08001234	Null pointer dereference or stack overflow	Use defmt to print fault registers, check stack size
panic at src/main.rs:42	Runtime panic	Use panic-probe instead of panic-halt for call stack
error: cannot find -lprobe_rs	probe-rs not installed	cargo install probe-rs-tools
OpenOCD connection failed	Debugger connection failure	Check ST-Link driver, USB cable, openocd.cfg configuration
error[E0277]: the trait bound is not satisfied	HAL trait not implemented	Check if target MCU is supported by HAL crate

Advanced Optimization

1. Use defmt Instead of Traditional Logging

// defmt has zero overhead in release mode
// Compile-time formatting, no runtime cost
defmt::info!("Sensor value: {}", value);
defmt::debug!("Buffer: {[u8; 4]}", &buf[..4]);
defmt::error!("HardFault HFSR={:08x}", hfsr);

2. Use cortex_m::singleton! for Static Resource Management

// Compile-time guaranteed singleton, no runtime checks
cortex_m::singleton!(
    static SHARED_STATE: SharedState = SharedState::new();
);

3. Use RTIC for Zero-Cost Interrupt-Driven Architecture

#[rtic::app(device = stm32f4xx_hal::pac)]
mod app {
    use stm32f4xx_hal::prelude::*;

    #[shared]
    struct Shared {
        sensor_value: u16,
    }

    #[local]
    struct Local {
        led: PA5<Output<PushPull>>,
    }

    #[init]
    fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) {
        let mut led = cx.device.GPIOA.split().pa5.into_push_pull_output();
        led.set_high();

        (
            Shared { sensor_value: 0 },
            Local { led },
            init::Monotonics(),
        )
    }

    #[task(binds = TIM2, shared = [sensor_value], local = [led])]
    fn timer_interrupt(cx: timer_interrupt::Context) {
        let sensor_value = cx.shared.sensor_value;
        let led = cx.local.led;

        *sensor_value.lock(|v| *v = read_adc());
        led.toggle();
    }
}

4. Use embassy for Async Concurrency

#[embassy_executor::task]
async fn task_a() {
    loop {
        do_something().await;
        Timer::after(Duration::from_millis(100)).await;
    }
}

#[embassy_executor::task]
async fn task_b() {
    loop {
        another_thing().await;
        Timer::after(Duration::from_secs(1)).await;
    }
}
// Each task only needs tens of bytes of stack (coroutine state machine)

5. Flash Optimization Strategy

[profile.release]
opt-level = "z"          # Optimize for size, not speed
lto = true               # Link-time optimization, eliminate unused code
codegen-units = 1        # Single compilation unit, optimal optimization
strip = true             # Remove debug symbols
panic = "abort"          # abort instead of unwind, smaller size

# Typical optimization results:
# Before: 128KB
# After: 32KB (75% reduction)

Comparison Analysis

Feature	Embassy	RTIC	FreeRTOS+Rust	Bare Metal Polling
Memory Overhead	Very Low (coroutines)	Very Low	High (per-task stack)	Lowest
Learning Curve	Medium	Medium	High	Low
Concurrency Model	async/await	Interrupt priority	Preemptive multitasking	None
Ecosystem Maturity	★★★★	★★★	★★	★★★★★
Debug Convenience	★★★★	★★★★	★★★	★★★★★
Real-time Guarantee	Soft real-time	Hard real-time	Hard real-time	Depends on implementation
Rust Native	✅	✅	❌ (C interop)	✅
Use Case	IoT/Sensors	Motor control	Complex multitasking	Simple control

Summary

Rust embedded development is transitioning from "experimental" to "production-ready." As of 2026, the no_std ecosystem is mature enough:

• Environment Setup: probe-rs unifies flashing and debugging, cargo embed does it all in one step
• Bare Metal Startup: cortex-m-rt encapsulates boot details, but understanding the underlying principles remains key for troubleshooting
• Peripheral Drivers: The PAC→HAL→Application three-layer architecture balances safety and efficiency
• Interrupt Handling: Atomic operations, Mutex, and RTIC cover different complexity requirements
• RTOS Integration: Embassy is becoming the first choice as a Rust-native solution; FreeRTOS suits existing project migration

Recommendation: New projects should consider Embassy first; for hard real-time requirements, choose RTIC; for existing FreeRTOS codebases, use freertos-rust for incremental migration.

Recommended Online Tools

• /en/json/format - JSON formatter, essential for debugging serial protocol data
• /en/dev/curl-to-code - HTTP request to code converter, great for IoT device API debugging
• /en/encode/hash - Hash calculator for firmware checksum generation
• /en/text/diff - Text diff tool for comparing register configurations across versions