Khởi tạo dự án với esp-generate

Nếu bạn đã quen với viêc dùng nút New Project trên các IDE chuyên biệt để phát triển, giờ chúng ta đã có công cụ esp-generate trên máy, đây sẽ là lúc sử dụng nó để khởi tạo dự án.

Mình sẽ để thông tin cấu hình dưới đây và giải thích từng chi tiết.

• Enable unstable HAL features: Một số tính năng được đánh dấu là unstable và có thể được thay đổi trong các minor update, các tính năng unstable có thể kể đến như:

  • ESP_HAL_CONFIG_PLACE_SPI_MASTER_DRIVER_IN_RAM: Thiết đặt driver SPI master ở RAM để tăng hiệu suất.

  • ESP_HAL_CONFIG_PLACE_RMT_DRIVER_IN_RAM: Đặt driver RMT ở RAM để tăng hiệu suất.

  • ESP_HAL_CONFIG_STACK_GUARD_VALUE: Giá trị ghi vào biến stack guard (mặc định là 0xDEEDBAAD).

  • ESP_HAL_CONFIG_STACK_GUARD_MONITORING: Sử dụng data watchpoint để kiểm tra xem stack guard có bị ghi đè không.

  • ESP_HAL_CONFIG_WRITE_VEC_TABLE_MONITORING: Sử dụng data watchpoint để bảo vệ vector table khỏi bị ghi đè

  • ESP_HAL_CONFIG_STACK_GUARD_MONITORING_WITH_DEBUGGER_CONNECTED: Bật stack guard ngay cả khi đang kết nối debugger.

  • ESP_HAL_CONFIG_IMPL_CRITICAL_SECTION: Cung cấp implementation cho critical-section.

Các tính năng này có thể hữu ích khi được sử dụng trong dự án, vì vậy mình sẽ enable trước để có thể sử dụng nếu cần. Chú ý là nếu bạn muốn dùng feature nào thì sẽ cần set value ở [env] trong file .cargo/config.toml

• Enable allocations via the esp-alloc crate: Cho phép phân bổ bộ nhớ Heap thông qua esp-alloc. Trong quá trình làm việc của hệ thống, có thể sẽ cần sử dụng đến vùng nhớ Heap (dù thường thì người phát triển sẽ tránh sử dụng Heap), ví dụ như:

  • Sử dụng kiểu dữ liệu động: String, Vec<T>, Box<T> / Rc<T> / Arc<T>.

  • Xử lý dữ liệu không biết trước kích thước.

Tính năng này cho phép cấp phát bộ nhớ trong Heap với crate esp-alloc. Một vài tính năng (Wi-Fi, BLE,…) sẽ chỉ có thể được sử dụng nếu tính năng này được enable.

• Enable Wi-Fi via the esp-radio crate: Cho phép sử dụng Wi-Fi.

• Enable BLE via the esp-radio crate (embassy-trouble): Cho phép sử dụng BLE (Bluetooth Low Energy). Nếu bạn để ý thì còn có lựa chọn với (bleps), tuy nhiên độ hoàn thiện của embassy-trouble là tốt hơn và thường được sử dụng hơn. Tính năng này chỉ có thể enable nếu bạn chọn cùng với Add embassy framework support, mình sẽ nói thêm về framework này ở phần sau

• Use probe-rs to flash and monitor instead of espflash: Sử dụng probe-rs thay vì espflash.

• Flashing, logging and debugging (probe-rs):

  • 

    Use defmt to print messages: defmt là một logging framework hiệu suất cao, được thiết kế để giải quyết vấn đề tốn tài nguyên khi ghi log với println! hoặc crate log. Cách giải quyết của nó khá hay: Thay vì lưu chuỗi log vào Flash của MCU, nó sẽ lưu chuỗi đó vào một file metadata trên máy host với 1 ID riêng, khi cần gửi log thì MCU sẽ chỉ gửi ID và thông tin bổ sung. Ví dụ:
    Đối với Vị trí (x):{} với giá trị truyền vào là 10
    Logging bình thường: MCU lưu Vị trí (x): vào Flash, xử lý ghép giá trị 10 vào chuỗi, rồi gửi Vị trí (x):10 qua UART.

    Sử dụng defmt: Khi compile thì chuỗi Vị trí (x): được lưu với ID là 1 trong file metadata, MCU sẽ chỉ gửi raw data như [1, 25], probe-rs sẽ xử lý việc tìm và nối chuỗi rồi in ra trên máy host.

  • Use panic-rtt-target as the panic handler: panic-rtt-target sử dụng giao thức RTT (Real-Time Transfer) thay vì UART để thông báo lỗi khi chương trình bị panic.

Sau khi khởi tạo xong, chúng ta đã có một folder project trông như này:

Vậy là giờ chúng ta có thể bắt đầu viết code được rồi đấy, tuy nhiên mình sẽ nói qua một chút về thứ chúng ta sẽ dùng nhé.

Embassy Framework

Embassy là một framework hiện đại để phát triển dự án nhúng bằng Rust, với ý tưởng cốt lõi là Rust + async ❤️ embedded. Nó mang Async/Await (thứ mà thường gặp khi làm Backend Website với NodeJS🫨) xuống phần cứng bare-metal.

Async trên Bare-metal là cái thứ gì?

Mình sẽ để đoạn code mà chúng ta vừa khởi tạo lúc nãy ở đây để nói về Async nhé

// src/bin/main.rs
#[esp_rtos::main]
async fn main(spawner: Spawner) -> ! {
    // Khởi tạo các ngoại vi, cấp phát bộ nhớ, khai báo phần cứng blabla
    // ...
    // TODO: Spawn some tasks
    let _ = spawner;

    loop {
        info!("Hello world!");
        Timer::after(Duration::from_secs(1)).await;
    }

}

Thay vì đánh vật để xử lý các ngắt phức tạp, hoặc quản lý luồng nặng nề của RTOS, Embassy cho phép chúng ta viết code trông có vẻ “tuần tự” nhưng thực ra lại là chạy “đa nhiệm” hiệu quả.

• Code blocking: delay(1000); sẽ khiến CPU thực sự phải chờ trong 1 giây mà không làm gì cả, gây lãng phí tài nguyên.

• Code async: Timer::after(Duration::from_secs(1)).await; cho phép CPU chuyển sang task khác trong vòng 1 giây, sau khi đủ 1 giây thì sẽ quay trở lại.

Thông thường để đa nhiệm trên MCU, có 2 phương án được đưa ra:

• Super-loop: Liên tục polling khiến cho code rất rối và khó quản lý thời gian.

• RTOS: Dùng các luồng (thread) để quản lý, tốn tài nguyên (do mỗi thread cần stack riêng), dễ gặp Race Condition hoặc Deadlock.

Embassy xử lý bằng cách chọn mô hình Cooperative Multitasking dựa trên async/await của Rust.

• Zero-cost: Không cấp phát bộ nhớ động bắt buộc.

• Hiệu suất cao: CPU chỉ chạy khi thực sự có việc, còn không thì sẽ ngủ.

• Không scheduler: embassy-executor sẽ chịu trách nhiệm xếp lịch chạy các task, vì là cooperative nên nhẹ và đơn giản hơn scheduler của RTOS nhiều

Những thành phần chính của framework

Embassy không chỉ là một thư viện, nó là một bộ công cụ đầy đủ:

• embassy-executor: Như mình đã nhắc ở trên, đây chính là thứ điều phối cho hệ thống.

• embassy-time: Quản lý thời gian, Clock, Delay, Timeout.

• embassy-sync: Các công cụ để các Task giao tiếp với nhau an toàn: Channel, Mutex, Signal.

• embassy-net: Network Stack (TCP/UDP, DHCP) hỗ trợ async.

• HAL (Hardware Abstraction Layer): Các driver phần cứng hỗ trợ async.

  • STM32: embassy-stm32

  • nRF: embassy-nrf

  • RP2040: embassy-rp

  • ESP32: Sử dụng esp-hal (được tích hợp chặt chẽ với Embassy).

Flash chương trình vào ESP32C3

Okay, giờ chúng ta đã có một Hello world! project, giờ thì thử flash xuống board chứ nhỉ.

Khi chạy lệnh cargo run thì thực chất chúng ta chạy probe-rs run --chip=esp32c3 --preverify --always-print-stacktrace --no-location --catch-hardfault, bạn có thể kiểm tra nội dung file ./cargo/config.toml để xem thử nha.

[target.riscv32imc-unknown-none-elf]
runner = "probe-rs run --chip=esp32c3 --preverify --always-print-stacktrace --no-location --catch-hardfault"

Bài viết trước: 02 - Thiết lập môi trường phát triển dự án nhúng sử dụng Rust

Mình muốn series này sẽ có sự rõ ràng cần thiết, để tránh người mới làm quen với Rust cảm thấy bối rối. Dưới đây là những thông tin về thành phần và công cụ mình sẽ sử dụng xuyên suốt series, cũng như là những nguồn tài liệu tham khảo cho bạn để làm quen với ngôn ngữ mới này.

• MCU: ESP32-C3 (được hỗ trợ bởi Espressif trong dự án esp-rs)

• OS: Ubuntu

• IDE: Visual Code

• Rust environment: no-std

• Reference book 📗: The Rust on ESP Book, The Embedded Rust Book, The Rust Programming Language

• Others: Series của RustDev Vietnam, rustlings

Cài đặt môi trường

Dependencies

Trước hết, bạn cần đảm bảo có đủ các công cụ cần thiết để cài đặt Rust

sudo apt update -y
sudo apt install -y curl build-essential

Rust Toolchain

Để cài đặt Rust, chúng ta sẽ sử dụng công cụ rustup. Tất nhiên bạn vẫn có thể cài Rust standalone, tuy nhiên mình khuyến khích bạn sử dụng rustup vì sự đơn giản trong quản lý phiên bản Rust.

Mở Terminal lên và chạy lệnh sau:

curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh

Nếu xuất hiện bảng chọn các tùy chọn cài đặt, hãy chọn 1) Proceed with installation (default) bằng cách gõ 1 và Enter nhé.

Cargo là package manager và build system của Rust, nó sẽ được tự động cài đặt sau khi bạn chạy lệnh trên, còn giờ thì hãy thêm cargo vào PATH enviroment variable. Ở đây mình sử dụng shell bash mặc định

nano ~/.bashrc

Thêm dòng này vào cuối file và lưu lại

export PATH="$HOME/.cargo/bin:$PATH"

Khởi động một terminal session mới, hoặc đơn giản chạy lệnh source ~/.bashrc là được

Okay giờ thì kiểm tra phiên bản bằng lệnh rustup -V, kết quả sẽ tương tự sau

rek@RekPC:~$ rustup -V
rustup 1.27.1 (2025-03-14)
info: This is the version for the rustup toolchain manager, not the rustc compiler.
info: The currently active `rustc` version is `rustc 1.91.1 (ed61e7d7e 2025-11-07)`

Tuy nhiên, một vài feature của esp-rs yêu cầu bạn cần sử dụng phiên bản nightly của Rust toolchain, vì vậy chúng ta sẽ cài đặt nó bằng cách dùng lệnh sau

rustup install nightly

Mình sử dụng ESP32-C3 với kiến trúc tập lệnh là RV32IMC, vì vậy mình muốn file sau khi compile sẽ phù hợp với kiến trúc này. Cài đặt target bằng lệnh

rustup target add riscv32imc-unknown-none-elf

(Nếu bạn dự định sử dụng ESP32 / ESP32-S2 / ESP32-S3 sử dụng Xtensa)

# Cài đặt espup để quản lý toolchain cho target này
cargo install espup --lockednày
# Cài đặt toolchain cần thiết
espup install
# Tự động thiết đặt môi trường mỗi khi mở shell mới
cat $HOME/export-esp.sh >> ~/.bashrc
# Khởi động lại terminal session
source ~/.bashrc

Cài đặt công cụ phát triển

esp-generate

Công cụ này giúp chúng ta khởi tạo dự án với các cấu hình mong muốn một cách nhanh chóng, cài đặt với lệnh sau

cargo install esp-generate --locked

espflash

Bộ công cụ dùng để flash các Espressif SoCs

cargo install espflash --locked

probe-rs (khuyến khích dùng)

Probe-rs là một bộ công cụ hiện đại được viết bằng Rust, dùng để flash và debug cho MCU. Nếu bạn đã dùng qua OpenOCD, mình nghĩ trải nghiệm với probe-rs sẽ khiến bạn thích Rust hơn.

# Download udev rules từ probe.rs
curl -O https://probe.rs/files/69-probe-rs.rules
# Chuyển file rules vào /etc/udev/rules.d
sudo mv 69-probe-rs.rules /etc/udev/rules.d
# Load rules
sudo udevadm control --reload && sudo udevadm trigger
# Thêm user của bạn vào plugdev group
sudo groupadd --system plugdev && sudo usermod -a -G plugdev $USER
# Cài đặt probe-rs
cargo binstall probe-rs-tools
# Hoàn tất cài đặt
probe-rs complete install

esp-config (tùy chọn)

Công cụ hỗ trợ chỉnh sửa tùy chọn cấu hình thông qua Terminal UI, tất nhiên nếu không dùng thì bạn hoàn toàn có thể thay đổi thủ công thông qua file .cargo/config.toml

cargo install esp-config --features=tui --locked

Extension cho VS Code

Để thuận tiện cho việc phát triển với Rust, bạn có thể cài một số extension sau:

• Rust Syntax

• Dependi

• Debugger for probe-rs

• rust-analyzer

• Even Better TOML

• CodeLLDB

Để nhanh chóng cài đủ các extension trên, mình đã đóng gói tất cả vào cùng 1 extension pack, bạn chỉ cần cài extension pack ESP SoCs firmware developing with Rust

Trong VS Code, nhấn tổ hợp Ctrl + P và paste dòng sau rồi Enter là đủ

https://marketplace.visualstudio.com/items?itemName=rek.esp-socs-firmware-developing-with-rust

Kết luận

Với việc thực hiện các bước trên, bạn đã thiết lập môi trường để phát triển dự án nhúng sử dụng Rust một cách hiệu quả 😉
Ở bài viết tiếp theo, chúng ta sẽ làm quen với việc sử dụng Rust trong phát triển dự án nhúng. Tuy nhiên vì Rust là một ngôn ngữ hơi khó học đối với người bắt đầu, minh khuyến khích các bạn tìm hiểu trước trong “Rust Book” và tự làm quen với Rust qua rustlings, ngoài ra series về Rust của RustDev Vietnam cũng rất đáng tham khảo.

Bài viết trước: 01 - Rust là gì và tại sao dùng nó cho hệ thống nhúng?

Đối với việc phát triển firmware cho các hệ thống nhúng, một trong những “tiêu chuẩn” cho toàn ngành là sử dụng C/C++

C/C++ rất mạnh trong việc can thiệp sâu vào hệ thống: làm việc với từng bit trong thanh ghi, quản lý cấp phát bộ nhớ, các thư viện tiêu chuẩn của vendor… Không thể phủ nhận rằng C/C++ đã là nền tảng của cả ngành công nghiệp này. Tuy nhiên, làm việc với nó giống như làm bếp khi có trong tay 1 con dao sắc vậy, nếu cẩn thận thì mọi chuyện sẽ tốt đẹp, hoặc nếu không thì hậu quả sẽ khó lường.

Rust đang nổi lên như một ngôn ngữ được gọi là “C++ -killer”, dù rằng mình không tin là vậy cho lắm 😅
Nhưng mình cho rằng Rust có những đặc điểm mà một ngôn ngữ dùng để phát triển hệ thống nhúng nên có. Và series này là để làm rõ điều đó 😆

Những khó khăn khi sử dụng C/C++ trong phát triển hệ thống nhúng và so sánh với Rust

1. Memory Safety
   C/C++ là ngôn ngữ non-memory safe, nghĩa là sẽ có hàng loạt lỗi liên quan đến bộ nhớ như: Buffer overflow, Null pointer dereference, Dangling pointer,… Hệ thống nhúng có thể bị hard fault nếu không được kiểm tra cẩn thận.
   Rust lại là ngôn ngôn ngữ memory safe, điều đó có nghĩa là phần lớn thời gian thì bạn chẳng phải lo lắng gì về những điều trên. Tất nhiên vẫn sẽ có một vài ngoại lệ, nhưng chúng ta sẽ nhắc tới nó sau.

2. Memory Management

   Việc quản lý bộ nhớ khi sử dụng C/C++ là thủ công, và phụ thuộc vào người phát triển. Đối với C++, có một nguyên tắc mà được sử dụng để quản lý bộ nhớ, đó là RAII (Resource Acquisition Is Initialization). Chương trình có được quản lý bộ nhớ tốt hay không, phần lớn dựa vào kinh nghiệm và cẩn trọng của người phát triển.
   Quản lý bộ nhớ với Rust thì lại sử dụng cơ chế Ownership & Borrowing. Đây là điểm khác biệt lớn giữa C/C++ và Rust. Cơ chế này cho phép người phát triển quản lý bộ nhớ an toàn và hiệu quả hơn, nhưng đồng nghĩa với việc sẽ phải “đánh vật” với compiler.

   

3. Race Condition
   Một ví dụ điển hình là việc main() đang đọc dữ liệu cảm biến nhưng ngắt lại được gọi, khiến dữ liệu đọc được bị sai sót do thay đổi giữa chừng. Trong C/C++, người phát triển thường phải quyết vấn đề này với việc kết hợp volatile và tắt ngắt.

    int main() {
        while (1) {
            __disable_irq(); // Tắt ngắt toàn cục
            if (counter > 100) {
                counter = 0;
            }
            __enable_irq();  // Bật ngắt lại
   
            // Vấn đề:
            // 1. Quên enable lại -> Treo hệ thống
            // 2. Disable quá lâu -> Miss các ngắt quan trọng khác
        }
    }
   

   Với Rust, câu chuyện này sẽ khác biệt một chút, compiler yêu cầu bạn sử dụng Atomic hoặc các cơ chế Mutex, Semaphore,… Điều này có thể gây khó khăn ban đầu cho người phát triển, tuy nhiên đảm bảo rằng một khi compile thành công thì sẽ gần như không có race condition.

    use core::sync::atomic::{AtomicBool, Ordering};
    // Biến static global, có thể truy cập từ mọi nơi an toàn
    static G_FLAG: AtomicBool = AtomicBool::new(false);
   
    #[entry]
    fn main() -> ! {
        loop {
            if G_FLAG.load(Ordering::Relaxed) {
                G_FLAG.store(false, Ordering::Relaxed);
                // Xử lý sự kiện...
            }
        }
    }
   
    #[interrupt]
    fn EXTI0() {
        // Ngắt ghi
        G_FLAG.store(true, Ordering::Relaxed);
    }
   

Rust có đáng để tìm hiểu nếu bạn đang phát triển hệ thống nhúng?

Mình nghĩ là có.

1. Nếu bạn đang gặp các vấn đề trên và cảm thấy hứng thú với việc triển khai Rust

   Rust hiện tại cũng đã đang dần được các tập đoàn lớn chấp nhận, đơn cử như việc Espressif release esp-hal 1.0.0 vào tháng 10 vừa qua. Rust đem lại sự đảm bảo về chất lượng cho firmware của hệ thống, đồng thời giúp mã nguồn có khả năng mở rộng tốt hơn và logic hơn. Các chương trình được viết bởi Rust đem lại hiệu năng ngang ngửa C. Tất nhiên nếu bạn có thể viết mã C ở mức hoàn hảo thì quá tuyệt, nhưng thường thì việc viết Rust để đem lại chất lượng cao thì dễ dàng hơn. Khi làm việc cùng Rust có 1 cái compiler khó tính, nó yêu cầu bạn phải đảm bảo mọi thứ an toàn, và một chương trình an toàn là một chương trình tốt 👍

2. Chưa đủ hứng thú để triển khai, nhưng đủ để muốn tìm hiểu thêm về Rust
   Nếu bạn đang chỉ tìm hiểu về Rust và không/chưa có ý định sử dụng nó trong hệ thống nhúng của bạn, không sao cả 😉 Đa số các hệ thống nhúng vẫn đang dùng C, và thường thì chẳng có vấn đề gì. Tất nhiên, bạn không muốn hệ thống do mình phát triển là ngoại lệ trong bức tranh đẹp đó. Và khi bạn tìm hiểu về Rust, bạn sẽ hiểu sâu hơn về cách Rust đang xử lý những vấn đề bạn thường gặp phải. Thứ bạn học được có thể không phải là cách triển khai Rust với hệ thống của bạn, mà là cách Rust ngăn việc những vấn đề sẽ xảy ra.

Bài viết sau: 02 - Thiết lập môi trường phát triển dự án nhúng sử dụng Rust