Adding Rust Language Support for RT-Thread #10910

.gitignore

@@ -1,4 +1,6 @@
 *.pyc
+**/Cargo.lock
+**/target/
 *.map
 *.dblite
 *.elf

components/Kconfig

@@ -48,5 +48,5 @@ rsource "lwp/Kconfig"
 endif
 
 rsource "legacy/Kconfig"
-
+rsource "rust/Kconfig"
 endmenu

components/SConscript

@@ -5,13 +5,17 @@ from building import *
 
 objs = []
 cwd  = GetCurrentDir()
-list = os.listdir(cwd)
+entries = os.listdir(cwd)
 
-for item in list:
+for item in entries:
     if item in remove_components:
         continue
 
     if os.path.isfile(os.path.join(cwd, item, 'SConscript')):
-        objs = objs + SConscript(os.path.join(item, 'SConscript'))
+        result = SConscript(os.path.join(item, 'SConscript'))
+        if isinstance(result, (list, tuple)):
+            objs.extend(result)
+        else:
+            objs.append(result)
 
 Return('objs')

components/rust/Kconfig

@@ -0,0 +1,26 @@
+menuconfig RT_USING_RUST
+    bool "Enable Rust component support"
+    default n
+    help
+        Enable Rust programming language support for RT-Thread.
+        This allows you to write RT-Thread components using Rust.
+
+if RT_USING_RUST
+    config RT_RUST_CORE
+        bool "Enable Rust Core Library"
+        default y
+    config RUST_DEBUG_BUILD
+        bool "Build Rust code in debug mode"
+        default n
+        help
+            Build Rust code with debug symbols and without optimizations.
+            This increases binary size but helps with debugging.
+    config RUST_INIT_COMPONENT
+        bool "Auto-initialize Rust component"
+        default y
+        help
+            Automatically initialize Rust component during RT-Thread startup.
+
+    rsource "examples/Kconfig"
+
+endif

components/rust/README.md

@@ -0,0 +1,187 @@
+# RT-Thread Rust Component
+
+RT-Thread's general-purpose Rust component for the RTOS, with automatic detection of multiple architectures.
+
+## Features
+
+- Multi-architecture support: automatically detects ARM, AArch64, and RISC-V target architectures.
+- Zero configuration: no manual platform target setup required.
+- Modular design: core modules and example code are clearly separated.
+- RT-Thread integration: full access to RT-Thread kernel APIs.
+
+## Project Layout
+
+```
+rust/
+├── README.md                    # Project documentation
+├── Kconfig                      # Configuration options
+├── SConscript                   # Top-level build script
+├── core/                        # Core Rust library
+│   ├── Cargo.toml               # Rust project config
+│   ├── SConscript               # Core library build script
+│   ├── rust_cmd.c               # MSH command registration
+│   └── src/                     # Source directory
+│       ├── lib.rs               # Library entry
+│       ├── init.rs              # Component initialization
+│       ├── allocator.rs         # Memory allocator
+│       ├── panic.rs             # Panic handler
+│       ├── bindings/            # RT-Thread API FFI bindings
+│       ├── api/                 # RT-Thread API Rust wrappers
+│       ├── prelude/             # Common imports
+│       ├── thread.rs            # Thread operations
+│       ├── mutex.rs             # Mutex
+│       ├── sem.rs               # Semaphore
+│       ├── queue.rs             # Message queue
+│       ├── time.rs              # Time functions
+│       ├── fs.rs                # Filesystem
+│       ├── libloader.rs         # Dynamic library loading
+│       ├── param.rs             # Parameter passing
+│       └── out.rs               # Output functions
+├── rt_macros/                   # Rust procedural macros
+│   ├── Cargo.toml               # Macros crate config
+│   └── src/                     # Macros source
+│       ├── lib.rs               # Macros crate entry
+│       └── macros/              # Macro implementations
+│           ├── mod.rs           # Module definitions
+│           ├── main.rs          # main macro
+│           ├── component.rs     # component export macro
+│           ├── app.rs           # application export macro
+│           └── cmd.rs           # command export macro
+├── examples/                    # Example code
+│   ├── Kconfig                  # Examples config
+│   ├── SConscript               # Examples build scripts
+│   ├── application/             # Application examples
+│   ├── component/               # Component examples
+│   └── modules/                 # Dynamic module examples
+├── docs/                        # Detailed documentation
+└── tools/                       # Build tools
+    ├── build_support.py        # Build support functions
+    ├── build_component.py      # Component build tool
+    ├── build_usrapp.py         # User app build tool
+    ├── feature_config_component.py  # Component feature config
+    └── feature_config_examples.py   # Example feature config
+```
+
+## Quick Start
+
+### Prerequisites
+
+1. Install Rust:
+
+```bash
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+```
+
+2. Add target platforms (choose according to your architecture):
+
+```bash
+# RISC-V64 (soft-float)
+rustup target add riscv64imac-unknown-none-elf
+
+# ARM Cortex-M4
+rustup target add thumbv7em-none-eabi
+
+# Add other targets that match your toolchain/ABI as needed
+```
+
+### Build
+
+```bash
+# Enable the Rust component in menuconfig
+scons --menuconfig
+# Navigate to: Rust Component Support → Enable
+
+# Build
+scons
+
+# Clean
+scons -c
+```
+
+## Supported Architectures
+
+| Architecture   | Target                            | Auto-detect |
+| -------------- | --------------------------------- | ----------- |
+| Cortex-M3      | thumbv7m-none-eabi                | ✓           |
+| Cortex-M4/M7   | thumbv7em-none-eabi               | ✓           |
+| Cortex-M4F/M7F | thumbv7em-none-eabihf             | ✓           |
+| ARMv7-A        | armv7a-none-eabi                  | ✓           |
+| AArch64        | aarch64-unknown-none              | ✓           |
+| RISC-V32       | riscv32ima[f]c-unknown-none-elf   | ✓           |
+| RISC-V64       | riscv64[gc/imac]-unknown-none-elf | ✓           |
+
+The build system will automatically determine the correct target from the RT-Thread configuration.
+
+## Example MSH Commands
+
+- `rust_param_demo`  — Parameter passing demo
+- `rust_thread_demo` — Thread demo
+- `rust_mutex_demo`  — Mutex demo
+- `rust_queue_demo`  — Queue demo
+- `rust_sem_demo`    — Semaphore demo
+- `rust_dl_demo`     — Dynamic module loading demo
+- `rust_fs_demo`     — File and logging operations demo (requires logging component)
+
+## Configuration Options
+
+Available in menuconfig:
+
+- `RT_USING_RUST` - Enable/disable the Rust component
+- `RT_RUST_CORE` - Enable/disable the core support library
+- `RUST_INIT_COMPONENT` - Initialize automatically at startup
+- `RT_USING_RUST_EXAMPLES`
+  - `RT_RUST_BUILD_APPLICATIONS`: Enable/disable user applications
+  - `RT_RUST_BUILD_COMPONENTS`: Enable/disable components
+  - `RT_RUST_BUILD_MODULES`: Enable/disable building dynamic modules
+- `RUST_DEBUG_BUILD` - Enable/disable debug build
+
+## Technical Details
+
+- No-std: embedded-friendly `#![no_std]` environment.
+- FFI: seamless C/Rust interoperability.
+- Static linking: produces `.a` library files.
+- Memory safety: compile-time guarantees from Rust.
+- Zero-cost abstractions: performance comparable to C.
+
+## Use Cases
+
+- Safety-critical code: leverage Rust's memory-safety guarantees.
+- Complex algorithms: use Rust's advanced abstraction capabilities.
+- Device drivers: type-safe hardware abstractions.
+- Network protocol stacks: safe packet handling.
+- Cryptography libraries: secure implementations that help prevent memory leaks.
+
+## Troubleshooting
+
+### Linker Error
+
+If you encounter the error "can't link double-float modules with soft-float modules":
+
+- The build system should auto-detect the correct ABI.
+- Check whether the compiler `-mabi` flag matches the Rust target.
+
+### Target Not Installed
+
+If a target is reported as not installed:
+
+```bash
+rustup target add <target-name>
+```
+
+### Detection Failed
+
+If the target architecture cannot be detected:
+
+- Verify that the RT-Thread configuration is correct.
+- Inspect compiler flags in `rtconfig.py`.
+
+## License
+
+Apache-2.0
+
+## References
+
+- https://docs.rust-embedded.org/
+- https://www.rt-thread.org/document/site/
+- https://doc.rust-lang.org/nomicon/ffi.html
+- https://riscv.org/technical/specifications/

components/rust/README_cn.md

@@ -0,0 +1,191 @@
+# RT-Thread Rust 组件
+
+RT-Thread RTOS 的通用 Rust 组件，支持多架构自动检测。
+
+## 特性
+
+- **多架构支持**：自动检测 ARM、AArch64 和 RISC-V 目标架构
+- **零配置**：无需手动配置目标平台
+- **模块化设计**：核心模块与示例代码清晰分离
+- **RT-Thread 集成**：完整访问 RT-Thread 内核 API
+
+## 项目结构
+
+```
+rust/
+├── README.md                    # 项目说明文档
+├── Kconfig                      # 配置选项
+├── SConscript                   # 主构建脚本
+├── core/                        # 核心 Rust 库
+│   ├── Cargo.toml              # Rust 项目配置
+│   ├── SConscript              # 核心库构建脚本
+│   ├── rust_cmd.c              # MSH 命令注册
+│   └── src/                    # 源代码目录
+│       ├── lib.rs              # 主库入口
+│       ├── init.rs             # 组件初始化
+│       ├── allocator.rs        # 内存分配器
+│       ├── panic.rs            # Panic 处理
+│       ├── bindings/           # RT-Thread API FFI 绑定
+│       ├── api/                # RT-Thread API Rust 封装
+│       ├── prelude/            # 常用导入
+│       ├── thread.rs           # 线程操作
+│       ├── mutex.rs            # 互斥锁
+│       ├── sem.rs              # 信号量
+│       ├── queue.rs            # 消息队列
+│       ├── time.rs             # 时间函数
+│       ├── fs.rs               # 文件系统
+│       ├── libloader.rs        # 动态库加载
+│       ├── param.rs            # 参数传递
+│       └── out.rs              # 输出函数
+├── rt_macros/                   # Rust 宏定义库
+│   ├── Cargo.toml              # 宏库配置
+│   └── src/                    # 宏源代码
+│       ├── lib.rs              # 宏库入口
+│       └── macros/             # 宏实现
+│           ├── mod.rs          # 模块定义
+│           ├── main.rs         # 主函数宏
+│           ├── component.rs    # 组件导出宏
+│           ├── app.rs          # 应用导出宏
+│           └── cmd.rs          # 命令导出宏
+├── examples/                    # 示例代码
+│   ├── Kconfig                 # 示例配置
+│   ├── SConscript              # 示例构建脚本
+│   ├── application/            # 应用示例
+│   ├── component/              # 组件示例
+│   └── modules/                # 动态模块示例
+├── docs/                        # 详细文档
+└── tools/                       # 构建工具
+    ├── build_support.py        # 构建支持函数
+    ├── build_component.py      # 组件构建工具
+    ├── build_usrapp.py         # 用户应用构建工具
+    ├── feature_config_component.py  # 组件特性配置
+    └── feature_config_examples.py   # 示例特性配置
+```
+
+## 快速开始
+
+### 前置要求
+
+1. **安装 Rust**
+
+```bash
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+```
+
+2. **添加目标平台**（根据您的架构）
+
+```bash
+# RISC-V64（软浮点）
+rustup target add riscv64imac-unknown-none-elf
+
+# ARM Cortex-M4
+rustup target add thumbv7em-none-eabi
+
+# 其他目标请根据实际工具链/ABI 添加对应的 Rust target
+```
+
+### 构建
+
+```bash
+# 在 menuconfig 中启用 Rust 组件
+scons --menuconfig
+# 导航至：Rust Component Support → Enable
+
+# 构建
+scons
+
+# 清理
+scons -c
+```
+
+## 支持的架构
+
+| 架构           | 目标                              | 自动检测 |
+| -------------- | --------------------------------- | -------- |
+| Cortex-M3      | thumbv7m-none-eabi                | ✓        |
+| Cortex-M4/M7   | thumbv7em-none-eabi               | ✓        |
+| Cortex-M4F/M7F | thumbv7em-none-eabihf             | ✓        |
+| ARMv7-A        | armv7a-none-eabi                  | ✓        |
+| AArch64        | aarch64-unknown-none              | ✓        |
+| RISC-V32       | riscv32ima[f]c-unknown-none-elf   | ✓        |
+| RISC-V64       | riscv64[gc/imac]-unknown-none-elf | ✓        |
+
+构建系统会自动从 RT-Thread 配置中检测正确的目标。
+
+## 用户测试 MSH 命令
+
+| 命令               | 描述                               |
+| ------------------ | ---------------------------------- |
+| `rust_param_demo`  | 参数传递演示                       |
+| `rust_thread_demo` | 线程演示                           |
+| `rust_mutex_demo`  | 互斥锁演示                         |
+| `rust_queue_demo`  | 队列演示                           |
+| `rust_sem_demo`    | 信号量演示                         |
+| `rust_dl_demo`     | 动态模块加载演示                   |
+| `rust_fs_demo`     | 文件与日志操作演示(需启用日志组件) |
+
+## 配置选项
+
+通过 `menuconfig` 配置：
+
+- `RT_USING_RUST` - 启用/禁用 Rust 组件
+- `RT_RUST_CORE` - 启用/禁用核心支持库
+- `RUST_INIT_COMPONENT` - 启动时自动初始化
+- `RT_USING_RUST_EXAMPLES`
+  - `RT_RUST_BUILD_APPLICATIONS`：启用/禁用用户程序
+  - `RT_RUST_BUILD_COMPONENTS`：启用/禁用组件
+  - `RT_RUST_BUILD_MODULES`：启用/禁用编译动态模块
+- `RUST_DEBUG_BUILD` - 启用/禁用debug模式
+
+## 技术细节
+
+- **No-std**：嵌入式友好的 `#![no_std]` 环境
+- **FFI**：无缝的 C/Rust 互操作性
+- **静态链接**：生成 `.a` 库文件
+- **内存安全**：Rust 的编译时保证
+- **零成本**：性能与 C 相当
+
+## 应用场景
+
+Rust 组件特别适合以下场景：
+
+- **安全关键代码**：利用 Rust 的内存安全保证
+- **复杂算法**：利用 Rust 的高级抽象能力
+- **设备驱动**：类型安全的硬件抽象
+- **网络协议栈**：安全的数据包处理
+- **加密库**：防止内存泄露的安全实现
+
+## 故障排除
+
+### 链接错误
+
+如果遇到 "can't link double-float modules with soft-float modules" 错误：
+
+- 构建系统应该自动检测正确的 ABI
+- 检查编译器的 `-mabi` 标志是否与 Rust 目标匹配
+
+### 目标未安装
+
+如果提示目标未安装：
+
+```bash
+rustup target add <目标名称>
+```
+
+### 检测失败
+
+如果无法检测目标架构：
+
+- 检查 RT-Thread 配置是否正确
+- 查看 rtconfig.py 中的编译器标志
+
+## 许可证
+
+Apache-2.0
+
+## 参考资料
+
+- [Rust 嵌入式编程手册](https://docs.rust-embedded.org/)
+- [RT-Thread 文档中心](https://www.rt-thread.org/document/site/)
+- [Rust FFI 编程](https://doc.rust-lang.org/nomicon/ffi.html)
+- [RISC-V 规范](https://riscv.org/technical/specifications/)

components/rust/SConscript

@@ -0,0 +1,28 @@
+# for module compiling
+import os
+from building import *
+
+objs = []
+
+def _has(sym: str) -> bool:
+    try:
+        return bool(GetDepend([sym]))
+    except Exception:
+        return bool(GetDepend(sym))
+
+if not _has('RT_USING_RUST'):
+    Return('objs')
+
+cwd = GetCurrentDir()
+entries = os.listdir(cwd)
+
+for d in entries:
+    path = os.path.join(cwd, d)
+    if os.path.isfile(os.path.join(path, 'SConscript')):
+        result = SConscript(os.path.join(d, 'SConscript'))
+        if isinstance(result, (list, tuple)):
+            objs.extend(result)
+        else:
+            objs.append(result)
+
+Return('objs')

components/rust/core/.gitignore

@@ -0,0 +1,37 @@
+# Rust build artifacts (now in build/rust)
+/target/
+**/*.rs.bk
+*.pdb
+
+# Cargo lock file (optional - uncomment if you want to exclude it)
+# Cargo.lock
+
+# Build directories
+/build/
+*.o
+*.a
+*.so
+*.dylib
+*.dll
+
+# IDE specific files
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# Debug files
+*.dSYM/
+*.su
+*.idb
+*.pdb
+
+# Backup files
+*.bak
+*.tmp
+*.temp
+
+# Log files
+*.log

components/rust/core/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "rt-rust"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+name = "rt_rust"
+crate-type = ["rlib", "staticlib"]
+
+[features]
+default = []
+smp = []
+
+[profile.dev]
+panic = "abort"
+
+[profile.release]
+panic = "abort"

components/rust/core/SConscript

@@ -0,0 +1,71 @@
+import os
+from building import *
+
+cwd = GetCurrentDir()
+
+sys.path.append(os.path.join(cwd, '../tools'))
+from build_support import (
+    detect_rust_target,
+    make_rustflags,
+    collect_features,
+    verify_rust_toolchain,
+    ensure_rust_target_installed,
+    cargo_build_staticlib,
+    clean_rust_build,
+)
+def _has(sym: str) -> bool:
+    try:
+        return bool(GetDepend([sym]))
+    except Exception:
+        return bool(GetDepend(sym))
+
+
+# Source files – MSH command glue
+src = ['rust_cmd.c']
+LIBS = []
+LIBPATH = []
+
+if GetOption('clean'):
+    # Register Rust artifacts for cleaning
+    rust_build_dir = clean_rust_build(Dir('#').abspath)
+    if os.path.exists(rust_build_dir):
+        print(f'Registering {rust_build_dir} for cleanup')
+        Clean('.', rust_build_dir)
+    else:
+        print('No rust build artifacts to clean')
+else:
+    if verify_rust_toolchain():
+        import rtconfig
+
+        target = detect_rust_target(_has, rtconfig)
+        if not target:
+            print('Error: Unable to detect Rust target; please check configuration')
+        else:
+            print(f'Detected Rust target: {target}')
+
+            # Optional hint if target missing
+            ensure_rust_target_installed(target)
+
+            # Build mode and features
+            debug = bool(_has('RUST_DEBUG_BUILD'))
+            features = collect_features(_has)
+
+            rustflags = make_rustflags(rtconfig, target)
+            rust_lib = cargo_build_staticlib(
+                rust_dir=cwd, target=target, features=features, debug=debug, rustflags=rustflags
+            )
+
+            if rust_lib:
+                LIBS = ['rt_rust']
+                LIBPATH = [os.path.dirname(rust_lib)]
+                print('Rust library linked successfully')
+            else:
+                print('Warning: Failed to build Rust library')
+    else:
+        print('Warning: Rust toolchain not found')
+        print('Please install Rust from https://rustup.rs')
+
+# Define component group for SCons
+group = DefineGroup('rust', src, depend=['RT_USING_RUST'], LIBS=LIBS, LIBPATH=LIBPATH)
+
+Return('group')

components/rust/core/rust_cmd.c

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2025-09-20     foxglove    First version
+ * 2025-10-10     foxglove     Clear Rust component MSH command registration
+ *
+ * Description: Rust component MSH command registration
+ *              Provides access interface to Rust modular APIs
+ */
+
+#include <rtthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <rtdbg.h>
+
+extern int rust_init(void);
+/* ============== Rust function declarations ============== */
+
+/* Component initialization */
+static int rust_component_init(void)
+{
+    int ret = rust_init();
+    if (ret == 0)
+    {
+        printf("Hello RT-Thread Rust!\n");
+    }
+    return ret;
+}
+#ifdef RUST_INIT_COMPONENT
+INIT_APP_EXPORT(rust_component_init);
+#endif

components/rust/core/src/allocator.rs

@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2025-10-10     foxglove     RT-Thread GlobalAlloc implementation
+ */
+
+use crate::api::mem::{mem_alloc, mem_alloc_aligned, mem_free, mem_free_aligned, mem_realloc};
+use core::alloc::{GlobalAlloc, Layout};
+use crate::panic::panic_on_atomic_context;
+use core::ptr;
+use core::ffi::c_void;
+
+pub struct RttAlloc;
+unsafe impl GlobalAlloc for RttAlloc {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        panic_on_atomic_context("alloc");
+        let size = layout.size();
+        let align = layout.align();
+        
+        /* Handle zero-sized allocations */
+        if size == 0 {
+            return ptr::null_mut();
+        }
+        
+        /* Use aligned allocation if alignment is greater than default
+         * RT-Thread's default alignment is typically 4 or 8 bytes */
+        if align > 8 {
+            match mem_alloc_aligned(size, align) {
+                Some(ptr) => ptr as *mut u8,
+                None => ptr::null_mut(),
+            }
+        } else {
+            match mem_alloc(size) {
+                Some(ptr) => ptr as *mut u8,
+                None => ptr::null_mut(),
+            }
+        }
+    }
+    
+    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
+        panic_on_atomic_context("dealloc");
+        if ptr.is_null() {
+            return;
+        }
+        
+        let align = layout.align();
+        
+        /* Use aligned deallocation if the original allocation was aligned */
+        if align > 8 {
+            mem_free_aligned(ptr as *mut c_void);
+        } else {
+            mem_free(ptr as *mut c_void);
+        }
+    }
+    
+    unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
+        panic_on_atomic_context("realloc");
+        /* Handle zero-sized new allocation */  
+        if new_size == 0 {
+            self.dealloc(ptr, layout);
+            return ptr::null_mut();
+        }
+        
+        /* Handle null pointer (equivalent to alloc) */
+        if ptr.is_null() {
+            let new_layout = Layout::from_size_align_unchecked(new_size, layout.align());
+            return self.alloc(new_layout);
+        }
+        
+        /* For aligned allocations, we need to handle realloc manually
+         * since RT-Thread's rt_realloc may not preserve alignment */
+        let align = layout.align();
+        if align > 8 {
+            let new_ptr = match mem_alloc_aligned(new_size, align) {
+                Some(ptr) => ptr as *mut u8,
+                None => return ptr::null_mut(),
+            };
+            
+            /* Copy data from old to new */ 
+            let copy_size = core::cmp::min(layout.size(), new_size);
+            ptr::copy_nonoverlapping(ptr, new_ptr, copy_size);
+            
+            mem_free_aligned(ptr as *mut c_void);
+            
+            new_ptr
+        } else {
+            match mem_realloc(ptr as *mut c_void, new_size) {
+                Some(new_ptr) => new_ptr as *mut u8,
+                None => ptr::null_mut(),
+            }
+        }
+    }
+}

components/rust/core/src/api/base.rs

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       notes
+ * 2025-10-10     foxglove     latest version
+ */
+use crate::bindings::*;
+
+/* Error type from rt-thread C code */
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub enum RttCResult {
+    Ok = RT_EOK as isize,
+    Error = -(RT_ERROR as isize),
+    TimeOut = -(RT_ETIMEOUT as isize),
+    Full = -(RT_EFULL as isize),
+    Empty = -(RT_EEMPTY as isize),
+    NoMem = -(RT_ENOMEM as isize),
+    NoSys = -(RT_ENOSYS as isize),
+    Busy = -(RT_EBUSY as isize),
+    IO = -(RT_EIO as isize),
+    INTR = -(RT_EINTR as isize),
+    INVAL = -(RT_EINVAL as isize),
+
+    NotValidCode = -100,
+}
+/* NOTE Match to `enum Error` */
+impl From<i32> for RttCResult {
+    fn from(a: i32) -> Self {
+        let ret = match a {
+            0 => RttCResult::Ok,
+            -1 => RttCResult::Error,
+            -2 => RttCResult::TimeOut,
+            -3 => RttCResult::Full,
+            -4 => RttCResult::Empty,
+            -5 => RttCResult::NoMem,
+            -6 => RttCResult::NoSys,
+            -7 => RttCResult::Busy,
+            -8 => RttCResult::IO,
+            -9 => RttCResult::INTR,
+            -10 => RttCResult::INVAL,
+            _ => RttCResult::NotValidCode,
+        };
+        ret
+    }
+}
+
+impl From<i64> for RttCResult {
+    fn from(a: i64) -> Self {
+        if a >= 0 {
+            RttCResult::Ok
+        } else {
+            match a {
+                -1 => RttCResult::Error,
+                -2 => RttCResult::TimeOut,
+                -3 => RttCResult::Full,
+                -4 => RttCResult::Empty,
+                -5 => RttCResult::NoMem,
+                -6 => RttCResult::NoSys,
+                -7 => RttCResult::Busy,
+                -8 => RttCResult::IO,
+                -9 => RttCResult::INTR,
+                -10 => RttCResult::INVAL,
+                _ => RttCResult::NotValidCode,
+            }
+        }
+    }
+}
+
+pub fn is_eok(val: RttCResult) -> bool {
+    if let RttCResult::Ok = val {
+        true
+    } else {
+        false
+    }
+}

components/rust/core/src/api/interrupt.rs

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       notes
+ * 2025-10-10     foxglove     latest version
+ */
+use crate::bindings::*;
+
+#[cfg(not(feature = "smp"))]
+unsafe fn irq_close() -> rt_base_t {
+    rt_hw_interrupt_disable()
+}
+#[cfg(feature = "smp")]
+unsafe fn irq_close() -> rt_base_t {
+    rt_cpus_lock()
+}
+
+#[cfg(not(feature = "smp"))]
+unsafe fn irq_open(f: rt_base_t) {
+    rt_hw_interrupt_enable(f)
+}
+#[cfg(feature = "smp")]
+unsafe fn irq_open(f: rt_base_t) {
+    rt_cpus_unlock(f)
+}
+
+pub fn no_irq<F, T>(f: F) -> T
+where
+    F: FnOnce() -> T,
+{
+    let level;
+    let out;
+    unsafe { level = irq_close() }
+    out = f();
+    unsafe { irq_open(level) }
+    out
+}
+
+#[derive(Debug, Copy, Clone)]
+pub struct InterruptFlag(rt_base_t);
+
+pub const INTERRUPT_FLAG_INIT: InterruptFlag = InterruptFlag { 0: 0 as _ };
+
+pub fn interrupt_disable() -> InterruptFlag {
+    unsafe { InterruptFlag(irq_close()) }
+}
+
+pub fn interrupt_enable(f: InterruptFlag) {
+    unsafe { irq_open(f.0) }
+}
+
+pub fn interrupt_enter() {
+    unsafe {
+        rt_interrupt_enter();
+    }
+}
+
+pub fn interrupt_leave() {
+    unsafe {
+        rt_interrupt_leave();
+    }
+}
+
+pub fn is_irq_context() -> bool {
+    unsafe { rt_interrupt_get_nest() != 0 }
+}

components/rust/core/src/api/libloading.rs

@@ -0,0 +1,238 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2025-10-14     foxglove     libdl safe wrapper (libloading-like)
+ */
+
+/*! Minimal `libloading`-style safe wrapper around RT-Thread libdl.
+Provides RAII `Library` and typed `Symbol<T>` for dlsym.
+*/
+
+extern crate alloc;
+
+use core::ffi::{c_char, c_int, c_void};
+use core::ffi::CStr;
+use core::marker::PhantomData;
+use core::mem::forget;
+use core::ops::Deref;
+
+use alloc::ffi::CString;
+use alloc::vec::Vec;
+
+use crate::bindings::libc;
+
+pub use crate::bindings::libc::{RTLD_GLOBAL, RTLD_LAZY, RTLD_LOCAL, RTLD_NOW};
+
+/* Error type for dynamic loading operations */
+pub enum DlError {
+    /* dlopen failed; contains last error C-string pointer */
+    Open(*const c_char),
+    /* dlsym failed; contains last error C-string pointer */
+    Symbol(*const c_char),
+    /* dlclose returned non-zero; contains return code */
+    Close(c_int),
+}
+
+impl core::fmt::Debug for DlError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        core::fmt::Display::fmt(self, f)
+    }
+}
+
+impl core::fmt::Display for DlError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            &DlError::Open(ptr) | &DlError::Symbol(ptr) => {
+                if ptr.is_null() {
+                    write!(f, "[libdl open/sym error: none]")
+                } else {
+                    unsafe {
+                        // `ptr` is a raw C string pointer
+                        let cstr = CStr::from_ptr(ptr);
+                        match cstr.to_str() {
+                            Ok(s) => write!(f, "{}", s),
+                            Err(_) => write!(f, "[libdl error: invalid UTF-8]")
+                        }
+                    }
+                }
+            }
+            DlError::Close(rc) => write!(f, "dlclose rc={}", rc),
+        }
+    }
+}
+
+/* RAII wrapper for a `dlopen` handle */
+pub struct Library {
+    handle: *mut c_void,
+}
+
+impl Library {
+    /* Create a new library using default flags (`RTLD_NOW | RTLD_GLOBAL`).
+     * Accepts a Rust string path and converts internally to a C string.
+     */
+    pub fn new(path: &str) -> Result<Self, DlError> {
+        let cstr = match CString::new(path) {
+            Ok(s) => s,
+            Err(_) => {
+                return Err(DlError::Open(core::ptr::null()));
+            }
+        };
+        unsafe { Self::open_global(cstr.as_ptr()) }
+    }
+    /* Open a dynamic module with given flags
+     * Safety: `path` must be a valid, NUL-terminated C string pointer
+     */
+    pub unsafe fn open(path: *const c_char, flags: c_int) -> Result<Self, DlError> {
+        let h = libc::dlopen(path, flags);
+        if h.is_null() {
+            Err(DlError::Open(libc::last_error_ptr()))
+        } else {
+            Ok(Library { handle: h })
+        }
+    }
+
+    /* Convenience open using `RTLD_NOW | RTLD_GLOBAL` */
+    pub unsafe fn open_global(path: *const c_char) -> Result<Self, DlError> {
+        Self::open(path, RTLD_NOW | RTLD_GLOBAL)
+    }
+
+    /* Resolve a typed symbol from the library using a C string pointer.
+     * Safety: Caller must ensure `T` matches the actual symbol type and `symbol` is NUL-terminated.
+     */
+    pub unsafe fn get_ptr<T>(&self, symbol: *const c_char) -> Result<Symbol<'_, T>, DlError> {
+        let sym = libc::dlsym(self.handle, symbol);
+        if sym.is_null() {
+            Err(DlError::Symbol(libc::last_error_ptr()))
+        } else {
+            Ok(Symbol {
+                raw: sym,
+                _lib: PhantomData,
+                _ty: PhantomData,
+            })
+        }
+    }
+
+    /* Resolve a typed symbol from the library using a byte slice name.
+     * If the slice is not NUL-terminated, a temporary buffer is allocated.
+     */
+    pub fn get<T>(&self, symbol: &[u8]) -> Result<Symbol<'_, T>, DlError> {
+        let (ptr, _guard_buf): (*const c_char, Option<Vec<u8>>) = if symbol.last().copied() == Some(0) {
+            (symbol.as_ptr() as *const c_char, None)
+        } else {
+            let mut buf = Vec::with_capacity(symbol.len() + 1);
+            buf.extend_from_slice(symbol);
+            buf.push(0);
+            (buf.as_ptr() as *const c_char, Some(buf))
+        };
+        let sym = unsafe { libc::dlsym(self.handle, ptr) };
+        if sym.is_null() {
+            Err(DlError::Symbol(libc::last_error_ptr()))
+        } else {
+            Ok(Symbol {
+                raw: sym,
+                _lib: PhantomData,
+                _ty: PhantomData,
+            })
+        }
+    }
+
+    /* Check if handle is null */
+    pub fn is_null(&self) -> bool {
+        self.handle.is_null()
+    }
+
+    /* Consume and close the library explicitly */
+    pub unsafe fn close(self) -> Result<(), DlError> {
+        let h = self.handle;
+        forget(self);
+        let rc = libc::dlclose(h);
+        if rc == 1 {
+            Ok(())
+        } else {
+            Err(DlError::Close(rc))
+        }
+    }
+
+    /* Leak the handle out (caller manages lifetime) */
+    pub unsafe fn into_raw(self) -> *mut c_void {
+        let h = self.handle;
+        forget(self);
+        h
+    }
+}
+
+impl Drop for Library {
+    fn drop(&mut self) {
+        unsafe {
+            if !self.handle.is_null() {
+                let _ = libc::dlclose(self.handle);
+                self.handle = core::ptr::null_mut();
+            }
+        }
+    }
+}
+
+/* RAII wrapper for a symbol tied to a `Library` lifetime.
+ * Stores the raw pointer and performs typed conversion at the use site.
+ */
+pub struct Symbol<'lib, T> {
+    raw: *mut c_void,
+    _lib: PhantomData<&'lib Library>,
+    _ty: PhantomData<T>,
+}
+
+impl<'lib, T> Symbol<'lib, T> {
+    /* Check if the underlying pointer is null */
+    pub fn is_null(&self) -> bool {
+        self.raw.is_null()
+    }
+
+    /* Get the raw pointer as `*mut c_void` */
+    pub fn as_raw(&self) -> *mut c_void {
+        self.raw
+    }
+
+    /* Cast the raw pointer to a different pointer type
+     * Safety: Caller must ensure `U` is the correct target type.
+     */
+    pub unsafe fn as_ptr<U>(&self) -> *mut U {
+        self.raw as *mut U
+    }
+
+    /* Convert to the typed value (e.g., function pointer) at use site
+    Safety: `T` must be the correct type for the symbol.
+    */
+    pub unsafe fn to_value(&self) -> T
+    where
+        T: Sized + Copy,
+    {
+        // Bitwise-copy the pointer value into a `T` without using `transmute`.
+        // This relies on `T` (e.g., extern "C" fn ...) having the same representation size.
+        let src: *const T = (&self.raw as *const *mut c_void) as *const T;
+        core::ptr::read(src)
+    }
+
+    pub fn into_raw(self) -> *mut c_void {
+        let p = self.raw;
+        forget(self);
+        p
+    }
+}
+
+impl<'lib, T> Deref for Symbol<'lib, T> {
+    type Target = T;
+    fn deref(&self) -> &Self::Target {
+        /* Reinterpret the `raw` pointer storage as a value of type `T`. */
+        /* Safety: This is safe if `T` is a pointer-sized function pointer or compatible pointer type. */
+        unsafe { &*((&self.raw as *const *mut c_void) as *const T) }
+    }
+}
+
+#[inline]
+pub fn last_error() -> *const c_char {
+    libc::last_error_ptr()
+}

components/rust/core/src/api/mem.rs

@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2025-10-10     foxglove     memory management API
+ */
+
+use crate::bindings::*;
+use core::ffi::c_void;
+
+pub fn mem_alloc(bytes: usize) -> Option<*mut c_void> {
+    if bytes == 0 {
+        return None;
+    }
+    
+    let ptr = unsafe { rt_malloc(bytes as rt_size_t) };
+    if ptr.is_null() {
+        None
+    } else {
+        Some(ptr)
+    }
+}
+
+pub fn mem_calloc(count: usize, size: usize) -> Option<*mut c_void> {
+    if count == 0 || size == 0 {
+        return None;
+    }
+    
+    let ptr = unsafe { rt_calloc(count as rt_size_t, size as rt_size_t) };
+    if ptr.is_null() {
+        None
+    } else {
+        Some(ptr)
+    }
+}
+
+pub fn mem_alloc_aligned(bytes: usize, align: usize) -> Option<*mut c_void> {
+    if bytes == 0 || align == 0 || !align.is_power_of_two() {
+        return None;
+    }
+    
+    let ptr = unsafe { rt_malloc_align(bytes as rt_size_t, align as rt_size_t) };
+    if ptr.is_null() {
+        None
+    } else {
+        Some(ptr)
+    }
+}
+
+pub fn mem_realloc(ptr: *mut c_void, new_size: usize) -> Option<*mut c_void> {
+    if new_size == 0 {
+        if !ptr.is_null() {
+            mem_free(ptr);
+        }
+        return None;
+    }
+    
+    let new_ptr = unsafe { rt_realloc(ptr, new_size as rt_size_t) };
+    if new_ptr.is_null() {
+        None
+    } else {
+        Some(new_ptr)
+    }
+}
+
+pub fn mem_free(ptr: *mut c_void) {
+    if !ptr.is_null() {
+        unsafe { rt_free(ptr) };
+    }
+}
+
+pub fn mem_free_aligned(ptr: *mut c_void) {
+    if !ptr.is_null() {
+        unsafe { rt_free_align(ptr) };
+    }
+}

components/rust/core/src/api/mod.rs

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       notes
+ * 2025-10-10     foxglove     API module
+ */
+pub mod base;
+pub mod interrupt;
+pub mod mem;
+pub mod thread;
+pub mod mutex;
+pub mod sem;
+pub mod queue;
+pub mod libloading;
+
+
+pub use base::*;
+pub use interrupt::*;
+pub use mem::*;
+pub use thread::*;
+pub use mutex::*;
+pub use sem::*;
+pub use queue::*;
+pub use libloading::*;

components/rust/core/src/api/mutex.rs

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       notes
+ * 2025-10-10     foxglove     Mutex API
+ */
+use crate::api::RttCResult;
+use crate::bindings::*;
+use core::ptr;
+use alloc::ffi::CString;
+
+pub type APIRawMutex = rt_mutex_t;
+
+#[inline]
+pub fn mutex_create(name: &str) -> Option<APIRawMutex> {
+    let s = CString::new(name).unwrap();
+    let raw;
+    unsafe {
+        raw = rt_mutex_create(s.as_ptr(), 1);
+    }
+    if raw == ptr::null_mut() {
+        None
+    } else {
+        Some(raw)
+    }
+}
+
+#[inline]
+pub fn mutex_delete(handle: APIRawMutex) {
+    unsafe {
+        rt_mutex_delete(handle);
+    }
+}
+
+#[inline]
+pub fn mutex_take(handle: APIRawMutex, tick: isize) -> RttCResult {
+    unsafe { rt_mutex_take(handle, tick as _).into() }
+}
+
+#[inline]
+pub fn mutex_release(handle: APIRawMutex) {
+    unsafe {
+        rt_mutex_release(handle);
+    }
+}

components/rust/core/src/api/queue.rs

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       notes
+ * 2025-10-10     foxglove     Queue API
+ */
+
+use crate::api::RttCResult;
+use core::ffi::c_void;
+use crate::bindings::*;
+use core::ptr;
+use alloc::ffi::CString;
+
+pub type APIRawQueue = rt_mq_t;
+
+#[inline]
+pub(crate) fn queue_create(name: &str, len: u64, message_size: u64) -> Option<APIRawQueue> {
+    let s = CString::new(name).unwrap();
+    let raw;
+    unsafe { raw = rt_mq_create(s.as_ptr(), message_size, len, 0) }
+    if raw == ptr::null_mut() {
+        None
+    } else {
+        Some(raw)
+    }
+}
+
+#[inline]
+pub(crate) fn queue_send_wait(
+    handle: APIRawQueue,
+    msg: *const c_void,
+    msg_size: u64,
+    tick: i32,
+) -> RttCResult {
+    unsafe { rt_mq_send_wait(handle, msg, msg_size, tick).into() }
+}
+
+#[inline]
+pub(crate) fn queue_receive_wait(
+    handle: APIRawQueue,
+    msg: *mut c_void,
+    msg_size: u64,
+    tick: i32,
+) -> RttCResult {
+    unsafe { rt_mq_recv(handle, msg, msg_size, tick).into() }
+}
+
+#[inline]
+pub(crate) fn queue_delete(handle: APIRawQueue) {
+    unsafe {
+        rt_mq_delete(handle);
+    }
+}

components/rust/core/src/api/sem.rs

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       notes
+ * 2025-10-10     foxglove     Semaphore API
+ */
+use crate::api::RttCResult;
+use crate::bindings::*;
+use core::ptr;
+use alloc::ffi::CString;
+
+pub type APIRawSem = rt_sem_t;
+
+ #[inline]
+pub(crate) fn semaphore_create(name: &str) -> Option<APIRawSem> {
+    let s = CString::new(name).unwrap();
+    let raw;
+    unsafe {
+        raw = rt_sem_create(s.as_ptr(), 0, 0);
+    }
+    return if raw == ptr::null_mut() {
+        None
+    } else {
+        Some(raw)
+    };
+}
+
+ #[inline]
+pub(crate) fn semaphore_try_take(handle: APIRawSem) -> RttCResult {
+    unsafe { rt_sem_trytake(handle).into() }
+}
+
+ #[inline]
+pub(crate) fn semaphore_take(handle: APIRawSem, tick: u32) -> RttCResult {
+    unsafe { rt_sem_take(handle, tick).into() }
+}
+
+ #[inline]
+pub(crate) fn semaphore_release(handle: APIRawSem) -> RttCResult {
+    unsafe { rt_sem_release(handle).into() }
+}
+
+ #[inline]
+pub(crate) fn semaphore_delete(handle: APIRawSem) {
+    unsafe {
+        let _ = rt_sem_delete(handle);
+    }
+}

components/rust/core/src/api/thread.rs

@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       notes
+ * 2025-10-10     foxglove     Thread API
+ */
+use super::base::*;
+use crate::bindings::*;
+use core::ptr;
+use core::ffi::c_void;
+use alloc::ffi::CString;
+
+/* Thread handle, defined by RT-Thread C code */
+pub type APIRawThread = rt_thread_t;
+/* Thread entry function, defined by RT-Thread C code */
+pub type ThreadEntry = extern "C" fn(parameter: *mut c_void);
+
+#[inline]
+pub fn thread_create(
+    name: &str,
+    entry: ThreadEntry,
+    param: *mut c_void,
+    stack_size: u32,
+    priority: u8,
+    tick: u32,
+) -> Option<APIRawThread> {
+    let name = CString::new(name).unwrap();
+    let raw;
+    unsafe {
+        raw = rt_thread_create(
+            name.as_ptr(),
+            entry,
+            param,
+            stack_size as crate::bindings::librt::rt_size_t,
+            priority,
+            tick,
+        );
+    }
+    if raw == ptr::null_mut() {
+        None
+    } else {
+        Some(raw)
+    }
+}
+
+#[inline]
+pub fn thread_delete(th: APIRawThread) -> RttCResult {
+    unsafe { rt_thread_delete(th).into() }
+}
+
+#[inline]
+pub fn thread_self() -> Option<APIRawThread> {
+    let ret;
+    unsafe {
+        ret = rt_thread_self();
+    }
+    if ret == ptr::null_mut() {
+        None
+    } else {
+        Some(ret)
+    }
+}
+
+#[inline]
+pub fn thread_startup(th: APIRawThread) -> RttCResult {
+    unsafe { rt_thread_startup(th).into() }
+}
+
+#[inline]
+pub fn thread_delay(ticks: usize) -> RttCResult {
+    unsafe { rt_thread_delay(ticks as _).into() }
+}
+
+#[inline]
+pub fn thread_m_delay(ms: i32) -> RttCResult {
+    unsafe { rt_thread_mdelay(ms as _).into() }
+}
+
+#[inline]
+pub fn thread_yield() {
+    unsafe {
+        rt_thread_yield();
+    }
+}
+
+#[inline]
+pub fn thread_suspend(th: APIRawThread) -> RttCResult {
+    unsafe { rt_thread_suspend(th).into() }
+}
+
+#[inline]
+pub fn thread_resume(th: APIRawThread) -> RttCResult {
+    unsafe { rt_thread_resume(th).into() }
+}

components/rust/core/src/bindings/libc.rs

@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       foxglove
+ * 2025-09-15     foxglove     1.0 version
+ * 2025-09-23     foxglove     1.1 version, add libdl bindings
+ */
+
+/*! C standard library API bindings
+
+Provides Rust wrappers for standard C library functions
+*/
+
+#![allow(non_camel_case_types)]
+
+pub use core::ffi::{c_char, c_int, c_void, c_long, c_ulong};
+
+pub const RTLD_LAZY: c_int = 0x00000;       /* Lazy function call binding */
+pub const RTLD_NOW: c_int = 0x00001;        /* Immediate function call binding */
+pub const RTLD_GLOBAL: c_int = 0x10000;     /* Make symbols globally available */
+pub const RTLD_LOCAL: c_int = 0x00000;      /* Default local */
+pub const O_RDONLY: c_int = 0x0000;         /* open for reading only */
+pub const O_WRONLY: c_int = 0x0001;         /* open for writing only */
+pub const O_RDWR: c_int = 0x0002;           /* open for reading and writing */
+pub const O_APPEND: c_int = 0x0008;         /* writes done at eof */
+pub const O_CREAT: c_int = 0x0100;          /* create and open file */
+pub const O_TRUNC: c_int = 0x0200;          /* open and truncate */
+pub const O_EXCL: c_int = 0x0400;           /* open only if file doesn't already exist */
+pub type size_t = c_ulong;
+pub type ssize_t = c_long;
+pub type off_t = c_long;
+pub const SEEK_SET: c_int = 0;
+pub const SEEK_CUR: c_int = 1;
+pub const SEEK_END: c_int = 2;
+/* ============== time functions ============== */
+pub type time_t = c_long;
+pub type suseconds_t = c_int;
+#[repr(C)]
+pub struct timeval {
+    pub tv_sec: time_t,
+    pub tv_usec: suseconds_t,
+}
+
+/* ============== libdl functions ============== */
+unsafe extern "C" {
+    pub fn dlopen(filename: *const c_char, flag: c_int) -> *mut c_void;
+    pub fn dlsym(handle: *mut c_void, symbol: *const c_char) -> *mut c_void;
+    pub fn dlclose(handle: *mut c_void) -> c_int;
+    pub fn dlerror() -> *const c_char;
+}
+unsafe extern "C" {
+    pub fn open(path: *const c_char, oflag: c_int, ...) -> c_int;
+    pub fn close(fd: c_int) -> c_int;
+    pub fn read(fd: c_int, buf: *mut c_void, count: size_t) -> ssize_t;
+    pub fn write(fd: c_int, buf: *const c_void, count: size_t) -> ssize_t;
+    pub fn lseek(fd: c_int, offset: off_t, whence: c_int) -> off_t;
+    pub fn fsync(fd: c_int) -> c_int;
+    pub fn ftruncate(fd: c_int, length: off_t) -> c_int;
+}
+
+/* ============== time functions ============== */
+unsafe extern "C" {
+    /* Use local types instead of crate-root paths to avoid E0412 */
+    pub fn gettimeofday(tp: *mut timeval, tz: *mut c_void) -> c_int;
+}
+
+/* Helper: get last libdl error C-string pointer
+ * Safe wrapper around `dlerror()` returning the raw pointer for printing.
+ */
+#[inline]
+pub fn last_error_ptr() -> *const c_char {
+    unsafe { dlerror() }
+}

components/rust/core/src/bindings/librt.rs

@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       foxglove
+ * 2025-09-15     foxglove     1.0 version
+ */
+
+/*! RT-Thread OS API bindings
+
+Provides Rust wrappers for RT-Thread kernel and device driver APIs
+*/
+
+#![allow(non_camel_case_types)]
+
+use core::ffi::{c_char, c_int, c_uint, c_void, c_long, c_ulong, c_uchar};
+
+/* RT-Thread basic type definitions */
+pub type rt_base_t = c_long;
+pub type rt_ubase_t = c_ulong;
+pub type rt_err_t = rt_base_t;
+pub type rt_uint32_t = c_uint;
+pub type rt_int32_t = c_int;
+pub type rt_uint8_t  = c_uchar;
+pub type rt_tick_t = rt_uint32_t;
+pub type rt_size_t = rt_ubase_t;
+
+pub type rt_thread_t = *mut c_void;
+pub type rt_sem_t = *mut c_void;
+pub type rt_mutex_t = *mut c_void;
+pub type rt_device_t = *mut c_void;
+pub type rt_mq_t = *mut c_void;
+
+/* RT-Thread error codes */
+pub const RT_EOK: rt_err_t = 0;
+pub const RT_ERROR: rt_err_t = 1;
+pub const RT_ETIMEOUT: rt_err_t = 2;
+pub const RT_EFULL: rt_err_t = 3;
+pub const RT_EEMPTY: rt_err_t = 4;
+pub const RT_ENOMEM: rt_err_t = 5;
+pub const RT_ENOSYS: rt_err_t = 6;
+pub const RT_EBUSY: rt_err_t = 7;
+pub const RT_EIO: rt_err_t = 8;
+pub const RT_EINTR: rt_err_t = 9;
+pub const RT_EINVAL: rt_err_t = 10;
+
+/* ============== Kernel object management ============== */
+unsafe extern "C" {
+    pub fn rt_object_get_type(object: *mut c_void) -> u8;
+    pub fn rt_object_find(name: *const c_char, object_type: u8) -> *mut c_void;
+}
+
+/* ============== Thread management ============== */
+unsafe extern "C" {
+    pub fn rt_thread_create(
+        name: *const c_char,
+        entry: extern "C" fn(*mut c_void),
+        parameter: *mut c_void,
+        stack_size: rt_size_t,
+        priority: rt_uint8_t,
+        tick: rt_tick_t,
+    ) -> rt_thread_t;
+    
+    pub fn rt_thread_delete(thread: rt_thread_t) -> rt_err_t;
+    pub fn rt_thread_startup(thread: rt_thread_t) -> rt_err_t;
+    pub fn rt_thread_self() -> rt_thread_t;
+    pub fn rt_thread_yield() -> rt_err_t;
+    pub fn rt_thread_delay(tick: rt_tick_t) -> rt_err_t;
+    pub fn rt_thread_mdelay(ms: rt_uint32_t) -> rt_err_t;
+    pub fn rt_thread_suspend(thread: rt_thread_t) -> rt_err_t;
+    pub fn rt_thread_resume(thread: rt_thread_t) -> rt_err_t;
+}
+
+/* ============== Semaphore management ============== */
+unsafe extern "C" {
+    pub fn rt_sem_create(name: *const c_char, value: rt_uint32_t, flag: rt_uint8_t) -> rt_sem_t;
+    pub fn rt_sem_delete(sem: rt_sem_t) -> rt_err_t;
+    pub fn rt_sem_take(sem: rt_sem_t, time: rt_tick_t) -> rt_err_t;
+    pub fn rt_sem_trytake(sem: rt_sem_t) -> rt_err_t;
+    pub fn rt_sem_release(sem: rt_sem_t) -> rt_err_t;
+}
+
+/* ============== Mutex management ============== */    
+unsafe extern "C" {
+    pub fn rt_mutex_create(name: *const c_char, flag: rt_uint8_t) -> rt_mutex_t;
+    pub fn rt_mutex_delete(mutex: rt_mutex_t) -> rt_err_t;
+    pub fn rt_mutex_take(mutex: rt_mutex_t, time: rt_tick_t) -> rt_err_t;
+    pub fn rt_mutex_release(mutex: rt_mutex_t) -> rt_err_t;
+}
+/* ============== Message queue management ============== */
+unsafe extern "C" {
+    pub fn rt_mq_create(name: *const c_char, msg_size: rt_size_t, max_msgs: rt_size_t, flag: rt_uint8_t) -> rt_mq_t;
+    pub fn rt_mq_send(mq: rt_mq_t, buffer: *const c_void, size: rt_size_t) -> rt_err_t;
+    pub fn rt_mq_send_wait(mq: rt_mq_t, buffer: *const c_void, size: rt_size_t, timeout: rt_int32_t) -> rt_err_t;
+    pub fn rt_mq_recv(mq: rt_mq_t, buffer: *mut c_void, size: rt_size_t, timeout: rt_int32_t) -> rt_base_t;
+    pub fn rt_mq_delete(mq: rt_mq_t) -> rt_err_t;
+    pub fn rt_mq_detach(mq: rt_mq_t) -> rt_err_t;
+}
+/* ============== Memory management ============== */
+unsafe extern "C" {
+    pub fn rt_malloc(size: rt_size_t) -> *mut c_void;
+    pub fn rt_free(ptr: *mut c_void);
+    pub fn rt_realloc(ptr: *mut c_void, newsize: rt_size_t) -> *mut c_void;
+    pub fn rt_calloc(count: rt_size_t, size: rt_size_t) -> *mut c_void;
+    pub fn rt_malloc_align(size: rt_size_t, align: rt_size_t) -> *mut c_void;
+    pub fn rt_free_align(ptr: *mut c_void);
+}
+
+/* ============== Device management ============== */
+unsafe extern "C" {
+    pub fn rt_device_find(name: *const c_char) -> rt_device_t;
+    pub fn rt_device_open(dev: rt_device_t, oflag: u16) -> rt_err_t;
+    pub fn rt_device_close(dev: rt_device_t) -> rt_err_t;
+    pub fn rt_device_read(
+        dev: rt_device_t,
+        pos: c_ulong,
+        buffer: *mut c_void,
+        size: rt_size_t,
+    ) -> rt_size_t;
+    pub fn rt_device_write(
+        dev: rt_device_t,
+        pos: c_ulong,
+        buffer: *const c_void,
+        size: rt_size_t,
+    ) -> rt_size_t;
+    pub fn rt_device_control(dev: rt_device_t, cmd: c_int, arg: *mut c_void) -> rt_err_t;
+}
+
+/* ============== System tick ============== */
+unsafe extern "C" {
+    pub fn rt_tick_get() -> rt_tick_t;
+    pub fn rt_tick_from_millisecond(ms: c_int) -> rt_tick_t;
+}
+
+/* ============== Debug output ============== */
+unsafe extern "C" {
+    pub fn rt_kprintf(fmt: *const u8, ...) -> c_int;
+    pub fn rt_kputs(str: *const u8) -> c_int;
+}
+
+/* ============== Interrupt management ============== */
+unsafe extern "C" {
+    pub fn rt_hw_interrupt_disable() -> rt_base_t;
+    pub fn rt_hw_interrupt_enable(level: rt_base_t);
+    pub fn rt_cpus_lock() -> rt_base_t;
+    pub fn rt_cpus_unlock(level: rt_base_t);
+    pub fn rt_interrupt_enter();
+    pub fn rt_interrupt_leave();
+    pub fn rt_interrupt_get_nest() -> u8;
+}

components/rust/core/src/bindings/mod.rs

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       notes
+ * 2025-10-10     foxglove     Bindings module
+ */
+pub mod libc;
+pub mod librt;
+
+/* Explicitly re-export only the needed items from librt to avoid namespace pollution. */
+/* Basic RT-Thread types */
+pub use librt::{
+    rt_base_t, rt_ubase_t, rt_err_t, rt_uint32_t, rt_int32_t, rt_uint8_t, 
+    rt_tick_t, rt_size_t, rt_thread_t, rt_sem_t, rt_mutex_t, rt_device_t, rt_mq_t
+};
+
+/* RT-Thread error codes */
+pub use librt::{
+    RT_EOK, RT_ERROR, RT_ETIMEOUT, RT_EFULL, RT_EEMPTY, RT_ENOMEM, 
+    RT_ENOSYS, RT_EBUSY, RT_EIO, RT_EINTR, RT_EINVAL
+};
+
+/* Thread management functions */
+pub use librt::{
+    rt_thread_create, rt_thread_delete, rt_thread_startup, rt_thread_self,
+    rt_thread_yield, rt_thread_delay, rt_thread_mdelay, rt_thread_suspend, rt_thread_resume
+};
+
+/* Semaphore management functions */
+pub use librt::{
+    rt_sem_create, rt_sem_delete, rt_sem_take, rt_sem_trytake, rt_sem_release
+};
+
+/* Mutex management functions */
+pub use librt::{
+    rt_mutex_create, rt_mutex_delete, rt_mutex_take, rt_mutex_release
+};
+
+/* Message queue management functions */
+pub use librt::{
+    rt_mq_create, rt_mq_send, rt_mq_send_wait, rt_mq_recv, rt_mq_delete, rt_mq_detach
+};
+
+/* Memory management functions */
+pub use librt::{
+    rt_malloc, rt_free, rt_realloc, rt_calloc, rt_malloc_align, rt_free_align,
+    rt_safe_malloc, rt_safe_free
+};
+
+/* Device management functions */
+pub use librt::{
+    rt_device_find, rt_device_open, rt_device_close, rt_device_read, 
+    rt_device_write, rt_device_control
+};
+
+/* System tick functions */     
+pub use librt::{
+    rt_tick_get, rt_tick_from_millisecond
+};
+
+/* Debug output functions */
+pub use librt::{
+    rt_kprintf, rt_kputs
+};
+
+/* Interrupt management functions */
+pub use librt::{
+    rt_hw_interrupt_disable, rt_hw_interrupt_enable, rt_cpus_lock, rt_cpus_unlock,
+    rt_interrupt_enter, rt_interrupt_leave, rt_interrupt_get_nest
+};
+
+/* Object management functions */
+pub use librt::{
+    rt_object_get_type, rt_object_find
+};

components/rust/core/src/fs.rs

@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       notes
+ * 2025-10-10     foxglove     micro rust log component
+ */
+use alloc::string::{String, ToString};
+use alloc::ffi::CString;
+use crate::RTResult;
+use crate::RTTError::{FileCloseErr, FileFlushErr, FileOpenErr, FileReadErr, FileSeekErr, FileSetLengthErr, FileWriteErr};
+use crate::bindings::libc;
+use core::ffi::{c_void, c_int};
+
+pub struct File {
+    pub fd: i32,
+}
+
+pub struct OpenOptions {
+    pub path: String,
+    pub read: bool,
+    pub write: bool,
+    pub create: bool,
+    pub append: bool,
+    pub truncate: bool,
+}
+
+impl OpenOptions {
+    pub fn new() -> Self {
+        Self { path: String::new(), read: false, write: false, create: false, append: false, truncate: false }
+    }
+
+    pub fn read(&mut self, read: bool) -> &mut Self { self.read = read; self }
+    pub fn write(&mut self, write: bool) -> &mut Self { self.write = write; self }
+    pub fn create(&mut self, create: bool) -> &mut Self { self.create = create; self }
+    pub fn append(&mut self, append: bool) -> &mut Self { self.append = append; self }
+    pub fn truncate(&mut self, truncate: bool) -> &mut Self { self.truncate = truncate; self }
+
+    fn flags(&self) -> c_int {
+        let mut flags: c_int = 0;
+        flags |= if self.read && self.write { libc::O_RDWR } else if self.write { libc::O_WRONLY } else { libc::O_RDONLY };
+        if self.create { flags |= libc::O_CREAT; }
+        if self.append { flags |= libc::O_APPEND; }
+        if self.truncate { flags |= libc::O_TRUNC; }
+        flags
+    }
+
+    pub fn open(&mut self, path: &str) -> RTResult<File> {
+        self.path = path.to_string();
+        let cpath = match CString::new(self.path.clone()) { Ok(s) => s, Err(_) => return Err(FileOpenErr) };
+        let oflags = self.flags();
+        let fd = unsafe { libc::open(cpath.as_ptr(), oflags, 0o666 as c_int) };
+        if fd < 0 { Err(FileOpenErr) } else { Ok(File { fd }) }
+    }
+}
+
+impl Drop for File {
+    fn drop(&mut self) {
+        unsafe { libc::close(self.fd); }
+    }
+}
+
+impl File {
+    pub fn read_to_string(&self) -> RTResult<String> {
+        let mut buf = [0u8; 256];
+        let mut out = String::new();
+        self.seek(0)?;
+        loop {
+            let n = self.read(&mut buf)?;
+            if n == 0 { break; }
+            let s = alloc::string::String::from_utf8_lossy(&buf[..n]).into_owned();
+            out.push_str(&s);
+        }
+        Ok(out)
+    }
+
+    pub fn write_all(&self, buf: &str) -> RTResult<()> {
+        let mut written = 0usize;
+        let bytes = buf.as_bytes();
+        while written < bytes.len() {
+            let n = self.write(&bytes[written..])?;
+            written += n;
+        }
+        Ok(())
+    }
+
+    pub fn read(&self, buf: &mut [u8]) -> RTResult<usize> {
+        let n = unsafe { libc::read(self.fd, buf.as_mut_ptr() as *mut c_void, buf.len() as libc::size_t) };
+        if n < 0 { Err(FileReadErr) } else { Ok(n as usize) }
+    }
+
+    pub fn write(&self, buf: &[u8]) -> RTResult<usize> {
+        let n = unsafe { libc::write(self.fd, buf.as_ptr() as *const c_void, buf.len() as libc::size_t) };
+        if n < 0 { Err(FileWriteErr) } else { Ok(n as usize) }
+    }
+
+    pub fn seek(&self, offset: i64) -> RTResult<i64> {
+        let n = unsafe { libc::lseek(self.fd, offset as libc::off_t, libc::SEEK_SET) };
+        if n < 0 { Err(FileSeekErr) } else { Ok(n) }
+    }
+
+    pub fn flush(&self) -> RTResult<()> {
+        let n = unsafe { libc::fsync(self.fd) };
+        if n < 0 { Err(FileFlushErr) } else { Ok(()) }
+    }
+
+    pub fn set_len(&self, len: i64) -> RTResult<()> {
+        let n = unsafe { libc::ftruncate(self.fd, len as libc::off_t) };
+        if n < 0 { Err(FileSetLengthErr) } else { Ok(()) }
+    }
+
+    pub fn close(&self) -> RTResult<()> {
+        let n = unsafe { libc::close(self.fd) };
+        if n < 0 { Err(FileCloseErr) } else { Ok(()) }
+    }
+}

components/rust/core/src/init.rs

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2025-09-15     foxglove     1.0 version
+ */
+
+/* Rust component initialization module
+ * Handles initialization of the Rust component within RT-Thread.
+ */
+
+use crate::println;
+
+#[no_mangle]
+pub extern "C" fn rust_init() -> i32 {
+    println!("[rust_init]: Rust component initialized!");    
+    0
+}

components/rust/core/src/lib.rs

@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       notes
+ * 2025-09-15     foxglove     1.0 version
+ * 2025-09-25     foxglove     1.1 version
+ * 2025-10-10     foxglove     latest version
+ */
+
+/* RT-Thread Rust core library
+
+Provides basic system support functionality including file system, network,
+and device interfaces. Designed for embedded devices running RT-Thread.
+*/
+
+#![no_std]
+#![feature(alloc_error_handler)]
+#![feature(linkage)]
+#![allow(dead_code)]
+
+pub extern crate alloc;
+
+#[doc = "Alloc by rt-thread"]
+#[global_allocator]
+static GLOBAL: allocator::RttAlloc = allocator::RttAlloc;
+pub mod api;
+pub mod bindings;
+
+pub mod init;
+pub mod allocator;
+pub mod mutex;
+pub mod out;
+pub mod fs;
+pub mod panic;
+pub mod param;
+pub mod queue;
+pub mod sem;
+pub mod thread;
+pub mod time;
+pub mod libloader;
+
+mod prelude;
+pub use prelude::v1::*;
+
+/* Re-export initialization function */
+pub use init::rust_init;
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub enum RTTError {
+    ThreadStartupErr,
+    MutexTakeTimeout,
+    SemaphoreTakeTimeout,
+    QueueSendTimeout,
+    QueueReceiveTimeout,
+    OutOfMemory,
+
+    DeviceNotFound,
+    DeviceOpenFailed,
+    DeviceCloseFailed,
+    DeviceReadFailed,
+    DeviceWriteFailed,
+    DeviceTransFailed,
+    DeviceConfigFailed,
+    DeviceSetRxCallBackFailed,
+    DeviceSetTxCallBackFailed,
+
+    FileOpenErr,
+    FileCloseErr,
+    FileReadErr,
+    FileWriteErr,
+    FileSeekErr,
+    FileFlushErr,
+    FileDeleteErr,
+    FileSetLengthErr,
+    FileSyncErr,
+
+    FuncUnDefine,
+}
+
+pub type RTResult<T> = Result<T, RTTError>;

components/rust/core/src/libloader.rs

@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2025-10-14     foxglove     High-level libdl facade (libloader-style)
+ */
+
+use core::ffi::{c_char, c_int};
+pub use crate::api::libloading as libloading;
+pub use libloading::{RTLD_GLOBAL, RTLD_LAZY, RTLD_LOCAL, RTLD_NOW, last_error};
+use libloading::{DlError, Library, Symbol};
+use crate::println;
+
+/** Open a module with `RTLD_NOW | RTLD_GLOBAL` convenience flags.
+
+Safety: `path` must be a valid NUL-terminated C string pointer.
+*/
+pub unsafe fn dl_open(path: *const c_char) -> Result<Library, DlError> {
+    Library::open_global(path)
+}
+
+/** Open a module with custom flags.
+
+Safety: `path` must be a valid NUL-terminated C string pointer.
+*/
+pub unsafe fn dl_open_with_flags(path: *const c_char, flags: c_int) -> Result<Library, DlError> {
+    Library::open(path, flags)
+}
+
+/** Resolve a typed symbol from a library.
+
+Safety: Caller must ensure `T` matches the actual symbol type.
+*/
+pub unsafe fn dl_sym<'lib, T>(lib: &'lib Library, symbol: *const c_char) -> Result<Symbol<'lib, T>, DlError> {
+    lib.get_ptr(symbol)
+}
+
+pub fn dl_print_last_error() {
+    println!("libdl error: {}", libloading::DlError::Open(last_error()));
+}
+
+/** Use a library for a scoped operation; the library is closed on drop.
+
+Safety: `path` must be a valid NUL-terminated C string pointer.
+*/
+pub unsafe fn with_library<R, F>(path: *const c_char, flags: c_int, f: F) -> Result<R, DlError>
+where
+    F: FnOnce(&Library) -> R,
+{
+    let lib = Library::open(path, flags)?;
+    let result = f(&lib);
+    /* Drop will handle closing; return the result */
+    Ok(result)
+}
+
+#[macro_export]
+/** Get a function from a dynamic link library
+ * *You need `use libloader::libloading` first*
+ * * `lib_path`: the path of DLL
+ * * `fn_name`: The function name from dll
+ * * `call_name`: The call function name of `fn_name`
+ * * `ret`: return type of the function **if the function don't have return value, use "()" instead**
+ * * `(value: type)`: **(variadic argument)** The arguments of the function from dll
+ */
+macro_rules! get_libfn {
+    ($lib_path: expr, $fn_name: expr, $call_name: ident, $ret: ty, $($v: ident: $t:ty),*) => {
+        pub fn $call_name($($v: $t),*) -> $ret {
+            let lib = $crate::libloader::libloading::Library::new($lib_path).unwrap();
+            let func: $crate::libloader::libloading::Symbol<fn($($t,)*) -> $ret> = lib.get($fn_name.as_bytes()).unwrap();
+            func($($v,)*)
+        }
+    };
+    ($lib_path: expr, $fn_name: expr, $call_name:ident, $ret: ty) => {
+        pub fn $call_name() -> $ret {
+            let lib = $crate::libloader::libloading::Library::new($lib_path).unwrap();
+            let func: $crate::libloader::libloading::Symbol<fn() -> $ret> = lib.get($fn_name.as_bytes()).unwrap();
+            func()
+        }
+    };
+}

components/rust/core/src/mutex.rs

@@ -0,0 +1,224 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2025-10-10     foxglove     RT-Thread Mutex implementation
+ */
+use crate::api::*;
+use crate::{panic::panic_on_atomic_context, RTTError};
+use alloc::fmt;
+pub use alloc::sync::{Arc, Weak};
+use core::cell::UnsafeCell;
+use core::ops::{Deref, DerefMut};
+use core::sync::atomic::*;
+
+const RT_WAITING_FOREVER: isize = -1;
+
+unsafe impl<T: Send, M: RawMutexOps + Sized> Send for Mutex<T, M> {}
+unsafe impl<T: Send, M: RawMutexOps + Sized> Sync for Mutex<T, M> {}
+
+pub struct Mutex<T: ?Sized, M = SleepMutex>
+where
+    M: RawMutexOps + Sized,
+{
+    mutex: M,
+    data: UnsafeCell<T>,
+}
+
+/* Impl for Default Mutex<M = SleepMutex, NAME = UnnamedObj> */
+impl<T> Mutex<T> {
+    pub fn new(t: T) -> Result<Self, RTTError> {
+        Ok(Mutex {
+            mutex: SleepMutex::create("Unnamed")?,
+            data: UnsafeCell::new(t),
+        })
+    }
+
+    pub fn new_with_name(t: T, name: &str) -> Result<Self, RTTError> {
+        Ok(Mutex {
+            mutex: SleepMutex::create(name)?,
+            data: UnsafeCell::new(t),
+        })
+    }
+
+    pub fn try_lock(&self, max_wait: isize) -> Result<MutexGuard<'_, SleepMutex, T>, RTTError> {
+        self.mutex.take(max_wait)?;
+        Ok(MutexGuard {
+            __mutex: &self.mutex,
+            __data: &self.data,
+        })
+    }
+
+    pub fn lock(&self) -> Result<MutexGuard<'_, SleepMutex, T>, RTTError> {
+        self.mutex.take(RT_WAITING_FOREVER)?;
+        Ok(MutexGuard {
+            __mutex: &self.mutex,
+            __data: &self.data,
+        })
+    }
+}
+
+/* Impl for all Mutex */
+impl<T, M: RawMutexOps> Mutex<T, M> {
+    pub fn spec_new(t: T) -> Result<Self, RTTError> {
+        Ok(Mutex {
+            mutex: M::create("Unnamed")?,
+            data: UnsafeCell::new(t),
+        })
+    }
+
+    pub fn spec_new_with_name(t: T, name: &str) -> Result<Self, RTTError> {
+        Ok(Mutex {
+            mutex: M::create(name)?,
+            data: UnsafeCell::new(t),
+        })
+    }
+
+    pub fn spec_try_lock(&self, max_wait: isize) -> Result<MutexGuard<'_, M, T>, RTTError> {
+        self.mutex.take(max_wait)?;
+        Ok(MutexGuard {
+            __mutex: &self.mutex,
+            __data: &self.data,
+        })
+    }
+
+    pub fn spec_lock(&self) -> Result<MutexGuard<'_, M, T>, RTTError> {
+        self.mutex.take(RT_WAITING_FOREVER)?;
+        Ok(MutexGuard {
+            __mutex: &self.mutex,
+            __data: &self.data,
+        })
+    }
+}
+
+impl<T: ?Sized> fmt::Debug for Mutex<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "Mutex address: {:?}", self.mutex)
+    }
+}
+
+pub struct MutexGuard<'a, M: RawMutexOps + 'a, T: ?Sized + 'a> {
+    __mutex: &'a M,
+    __data: &'a UnsafeCell<T>,
+}
+
+impl<'mutex, M: RawMutexOps, T: ?Sized> Deref for MutexGuard<'mutex, M, T> {
+    type Target = T;
+    fn deref(&self) -> &T {
+        unsafe { &*self.__data.get() }
+    }
+}
+
+impl<'mutex, M: RawMutexOps, T: ?Sized> DerefMut for MutexGuard<'mutex, M, T> {
+    fn deref_mut(&mut self) -> &mut T {
+        unsafe { &mut *self.__data.get() }
+    }
+}
+
+impl<'a, M: RawMutexOps, T: ?Sized> Drop for MutexGuard<'a, M, T> {
+    fn drop(&mut self) {
+        self.__mutex.release();
+    }
+}
+
+pub type CommonMutex = SleepMutex;
+pub struct SleepMutex(APIRawMutex);
+
+impl fmt::Debug for SleepMutex {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{:?}", self.0)
+    }
+}
+
+pub struct AtomicMutex(UnsafeCell<InterruptFlag>, AtomicBool);
+
+pub trait RawMutexOps: Sized {
+    fn create(name: &str) -> Result<Self, RTTError>;
+    fn take(&self, max_wait: isize) -> Result<(), RTTError>;
+    fn release(&self);
+    fn drop(&mut self);
+}
+
+impl RawMutexOps for AtomicMutex {
+    fn create(_name: &str) -> Result<Self, RTTError> {
+        Ok(AtomicMutex {
+            0: UnsafeCell::new(INTERRUPT_FLAG_INIT),
+            1: AtomicBool::new(false),
+        })
+    }
+
+    fn take(&self, max_wait: isize) -> Result<(), RTTError> {
+        let f;
+        unsafe {
+            f = self.0.get();
+            *f = interrupt_disable();
+        }
+        let ret = if max_wait == RT_WAITING_FOREVER {
+            while self
+                .1
+                .compare_exchange_weak(false, true, Ordering::Acquire, Ordering::Relaxed)
+                .is_err()
+            {
+                while self.1.load(Ordering::Relaxed) {}
+            }
+            Ok(())
+        } else {
+            if self
+                .1
+                .compare_exchange_weak(false, true, Ordering::Acquire, Ordering::Relaxed)
+                .is_ok()
+            {
+                Ok(())
+            } else {
+                unsafe {
+                    interrupt_enable(*f);
+                }
+                Err(RTTError::MutexTakeTimeout)
+            }
+        };
+
+        return ret;
+    }
+
+    fn release(&self) {
+        self.1.store(false, Ordering::Release);
+        let f;
+        unsafe {
+            f = self.0.get();
+            interrupt_enable(*f);
+        }
+    }
+
+    fn drop(&mut self) {}
+}
+
+impl RawMutexOps for SleepMutex {
+    fn create(name: &str) -> Result<Self, RTTError> {
+        panic_on_atomic_context("create");
+        mutex_create(name)
+            .ok_or(RTTError::OutOfMemory)
+            .map(|m| SleepMutex(m))
+    }
+
+    fn take(&self, max_wait: isize) -> Result<(), RTTError> {
+        panic_on_atomic_context("take");
+        let ret = mutex_take(self.0, max_wait);
+        if !is_eok(ret) {
+            return Err(RTTError::MutexTakeTimeout);
+        }
+        Ok(())
+    }
+
+    fn release(&self) {
+        panic_on_atomic_context("release");
+        mutex_release(self.0);
+    }
+
+    fn drop(&mut self) {
+        panic_on_atomic_context("drop");
+        mutex_delete(self.0);
+    }
+}

components/rust/core/src/out.rs

@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2025-10-10     foxglove     RT-Thread Output implementation
+ */
+use crate::bindings::librt::rt_kprintf;
+use core::fmt::{self, Write};
+use core::cmp::min;
+
+fn up_cast(a: usize, b: usize) -> usize {
+    let r = a / b;
+    return if a % b == 0 { r } else { r + 1 };
+}
+
+fn puts(str: &str, kp: fn(s: *const u8)) {
+    let str = str.as_bytes();
+    let mut buf = [0 as u8; 129];
+    for i in 0..up_cast(str.len(), 128) {
+        let end = min(128, str.len() - i * 128);
+        for j in 0..end {
+            buf[j] = str[(j + i * 128) as usize];
+        }
+        buf[end] = 0;
+        kp(buf.as_ptr())
+    }
+}
+
+struct StdOut;
+
+impl fmt::Write for StdOut {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        fn rtt_kputs(s: *const u8) {
+            unsafe {
+                /* Use kprintf with "%s" format to avoid dependency on rt_kputs symbol */
+                rt_kprintf(b"%s\0".as_ptr(), s);
+            }
+        }
+        puts(s, rtt_kputs);
+        Ok(())
+    }
+}
+
+pub fn _print(args: fmt::Arguments) {
+    unsafe {
+        StdOut.write_fmt(args).unwrap_unchecked();
+    }
+}
+
+#[macro_export]
+macro_rules! print {
+    ($($arg:tt)*) => ({
+        $crate::out::_print(format_args!($($arg)*));
+    });
+}
+
+#[macro_export]
+macro_rules! println {
+    () => ({
+        $crate::out::_print(format_args!("\n"));
+    });
+    ($($arg:tt)*) => ({
+        $crate::out::_print(format_args!("{}\n", format_args!($($arg)*)));
+    });
+}

components/rust/core/src/panic.rs

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2025-10-10     foxglove     RT-Thread Panic implementation
+ */
+use crate::print;
+
+pub fn panic_on_atomic_context(s: &str) {
+    use crate::api::is_irq_context;
+    if is_irq_context() {
+        panic!("In irq context {}", s);
+    }
+}
+
+#[panic_handler]
+#[inline(never)]
+fn panic(info: &core::panic::PanicInfo) -> ! {
+    print!("{:}", info);
+    __rust_panic()
+}
+
+#[linkage = "weak"]
+#[unsafe(no_mangle)]
+fn __rust_panic() -> ! {
+    /* Default weak panic handler: loops forever to halt execution. */
+    print!("Entered weak panic handler: system will halt.");
+    loop {}
+}

components/rust/core/src/param.rs

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       notes
+ * 2025-10-10     foxglove     Parameter module
+ */
+
+use alloc::vec::Vec;
+use core::iter::IntoIterator;
+use core::ops::Deref;
+
+#[derive(Debug)]
+pub struct ParamItem(&'static [u8]);
+
+impl Deref for ParamItem {
+    type Target = [u8];
+    fn deref(&self) -> &Self::Target {
+        return self.0;
+    }
+}
+
+impl ParamItem {
+    pub fn new(raw: &'static [u8]) -> Self {
+        ParamItem(raw)
+    }
+}
+
+pub type Param = <Vec<ParamItem> as IntoIterator>::IntoIter;

components/rust/core/src/prelude/mod.rs

@@ -0,0 +1,11 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       notes
+ * 2025-10-10     foxglove     Prelude module
+ */
+#[path = "no_std.rs"]
+pub mod v1;

components/rust/core/src/prelude/no_std.rs

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       notes
+ * 2025-10-10     foxglove     Prelude module
+ */
+pub use core::cell::RefCell;
+pub use core::cell::UnsafeCell;
+pub use core::cmp::*;
+pub use core::fmt;
+pub use core::ptr::write_bytes;
+pub use core::iter::Iterator;
+pub use core::marker::PhantomData;
+pub use core::mem;
+pub use core::num::Wrapping;
+pub use core::ops::Range;
+pub use core::ops::{Deref, DerefMut};
+
+pub use alloc::boxed::Box;
+pub use alloc::rc::Rc;
+pub use alloc::sync::{Arc, Weak};
+
+pub use alloc::collections;
+pub use alloc::string;
+pub use alloc::vec;

components/rust/core/src/queue.rs

@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2025-10-10     foxglove     RT-Thread Queue implementation
+ */
+
+use crate::api::*;
+use crate::{panic::panic_on_atomic_context, RTTError};
+use core::cell::UnsafeCell;
+use core::marker::PhantomData;
+use core::mem::{size_of, MaybeUninit};
+use core::ffi::c_void;
+
+const RT_WAITING_FOREVER: isize = -1;
+
+unsafe impl<T> Send for Queue<T> where T: Send {}
+unsafe impl<T> Sync for Queue<T> where T: Send {}
+
+#[derive(Debug)]
+pub struct Queue<T> {
+    queue: APIRawQueue,
+    item_type: PhantomData<UnsafeCell<T>>,
+}
+
+impl<T> Queue<T> {
+    pub fn new(max_size: usize) -> Result<Queue<T>, RTTError> {
+        queue_create("Unnamed", max_size as _, size_of::<T>() as _)
+            .ok_or(RTTError::OutOfMemory)
+            .map(|m| Queue {
+                queue: m,
+                item_type: PhantomData,
+            })
+    }
+
+    pub fn new_with_name(name: &str, max_size: usize) -> Result<Queue<T>, RTTError> {
+        queue_create(name, max_size as _, size_of::<T>() as _)
+            .ok_or(RTTError::OutOfMemory)
+            .map(|m| Queue {
+                queue: m,
+                item_type: PhantomData,
+            })
+    }
+
+    pub fn try_send(&self, item: T) -> Result<(), (RTTError, T)> {
+        self._send(item, 0)
+    }
+
+    pub fn send(&self, item: T, max_wait: i32) -> Result<(), (RTTError, T)> {
+        panic_on_atomic_context("send");
+        self._send(item, max_wait)
+    }
+
+    pub fn send_wait_forever(&self, item: T) -> Result<(), (RTTError, T)> {
+        panic_on_atomic_context("send_wait_forever");
+        self._send(item, RT_WAITING_FOREVER as _)
+    }
+
+    fn _send(&self, item: T, max_wait: i32) -> Result<(), (RTTError, T)> {
+        let inner = MaybeUninit::new(item);
+        let ret = queue_send_wait(
+            self.queue,
+            inner.as_ptr() as *const c_void,
+            size_of::<T>() as _,
+            max_wait,
+        );
+        return if !is_eok(ret) {
+            unsafe { Err((RTTError::QueueSendTimeout, inner.assume_init())) }
+        } else {
+            Ok(())
+        };
+    }
+
+    pub fn try_recv(&self) -> Result<T, RTTError> {
+        self._receive(0)
+    }
+
+    pub fn recv(&self, max_wait: i32) -> Result<T, RTTError> {
+        panic_on_atomic_context("recv");
+        self._receive(max_wait)
+    }
+
+    pub fn recv_wait_forever(&self) -> Result<T, RTTError> {
+        panic_on_atomic_context("recv_wait_forever");
+        self._receive(RT_WAITING_FOREVER as _)
+    }
+
+    fn _receive(&self, max_wait: i32) -> Result<T, RTTError> {
+        let mut inner = MaybeUninit::<T>::uninit();
+        let ret = queue_receive_wait(
+            self.queue,
+            inner.as_mut_ptr() as *mut c_void,
+            size_of::<T>() as _,
+            max_wait,
+        );
+        return if is_eok(ret) {
+            Ok(unsafe { inner.assume_init() })
+        } else {
+            Err(RTTError::QueueReceiveTimeout)
+        };
+    }
+}
+
+impl<T> Drop for Queue<T> {
+    fn drop(&mut self) {
+        queue_delete(self.queue);
+    }
+}

components/rust/core/src/sem.rs

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2025-10-10     foxglove     RT-Thread Semaphore implementation
+ */
+#![allow(dead_code)]
+
+use crate::api::*;
+use crate::{panic::panic_on_atomic_context, RTTError};
+use core::cell::UnsafeCell;
+use core::marker::PhantomData;
+
+const RT_WAITING_FOREVER: i32 = -1;
+
+unsafe impl Send for Semaphore {}
+unsafe impl Sync for Semaphore {}
+
+pub struct Semaphore {
+    data: PhantomData<*const UnsafeCell<usize>>,
+    sem: APIRawSem
+}
+
+impl Semaphore {
+    pub fn new() -> Result<Self, RTTError> {
+        Self::new_with_name("unknown")
+    }
+
+    pub fn new_with_name(name: &str) -> Result<Self, RTTError> {
+        panic_on_atomic_context("new_with_name");
+        semaphore_create(name)
+            .ok_or(RTTError::OutOfMemory)
+            .map(|m| Semaphore {
+                data: Default::default(),
+                sem: m
+            })
+    }
+
+    pub fn try_take(&self) -> Result<(), RTTError> {
+        let m = semaphore_try_take(self.sem);
+        if !is_eok(m) {
+            return Err(RTTError::SemaphoreTakeTimeout);
+        }
+        Ok(())
+    }
+
+    pub fn take_wait_forever(&self) -> Result<(), RTTError> {
+        panic_on_atomic_context("sem take_wait_forever");
+        let ret = semaphore_take(self.sem, RT_WAITING_FOREVER as u32);
+
+        if !is_eok(ret) {
+            return Err(RTTError::SemaphoreTakeTimeout);
+        }
+
+        Ok(())
+    }
+
+    pub fn take(&self, max_wait: i32) -> Result<(), RTTError> {
+        panic_on_atomic_context("sem take");
+        let ret = semaphore_take(self.sem, max_wait as u32);
+
+        if !is_eok(ret) {
+            return Err(RTTError::SemaphoreTakeTimeout);
+        }
+
+        Ok(())
+    }
+
+    pub fn release(&self) {
+        semaphore_release(self.sem);
+    }
+}
+
+impl Drop for Semaphore {
+    fn drop(&mut self) {
+        semaphore_delete(self.sem)
+    }
+}

components/rust/core/src/thread.rs

@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2025-10-10     foxglove     RT-Thread Thread implementation
+ */
+use crate::alloc::boxed::Box;
+use crate::api::*;
+use crate::{RTResult, RTTError};
+use alloc::string::String;
+use core::mem;
+use core::ffi::c_void;
+
+#[derive(Debug)]
+pub struct Thread(APIRawThread);
+
+impl Thread {
+    pub fn delay(tick: usize) {
+        let _ = thread_delay(tick);
+    }
+
+    pub fn ms_delay(ms: usize) {
+        let _ = thread_m_delay(ms as i32);
+    }
+
+    pub fn new() -> ThreadBuilder {
+        ThreadBuilder {
+            th_name: "uname".into(),
+            th_stack_size: 4096,
+            th_priority: 10,
+            th_ticks: 10,
+        }
+    }
+
+    pub fn r#yield() {
+        thread_yield();
+    }
+
+    pub fn delete_thread(th: Self) {
+        let _ = thread_delete(th.0);
+    }
+
+    pub fn delete(&self) {
+        let _ = thread_delete(self.0);
+    }
+
+    unsafe fn spawn_inner(
+        name: String,
+        stack_size: u32,
+        priority: u8,
+        ticks: u32,
+        func: Box<dyn FnOnce()>,
+    ) -> Result<Self, RTTError> {
+        let func = Box::new(func);
+        let param = &*func as *const _ as *mut _;
+
+        extern "C" fn thread_func(param: *mut c_void) {
+            unsafe {
+                let run = Box::from_raw(param as *mut Box<dyn FnOnce()>);
+                run();
+            }
+        }
+
+        let th_handle = thread_create(
+            name.as_ref(),
+            thread_func,
+            param,
+            stack_size,
+            priority,
+            ticks,
+        )
+        .ok_or(RTTError::OutOfMemory)?;
+
+        let ret = match Self::_startup(th_handle) {
+            Ok(_) => {
+                mem::forget(func);
+                Ok(Thread(th_handle))
+            }
+            Err(e) => Err(e),
+        };
+
+        return ret;
+    }
+
+    fn _startup(th: APIRawThread) -> Result<(), RTTError> {
+        let ret = thread_startup(th);
+        return if is_eok(ret) {
+            Ok(())
+        } else {
+            Err(RTTError::ThreadStartupErr)
+        };
+    }
+
+    pub fn spawn<F>(
+        name: String,
+        stack_size: u32,
+        priority: u8,
+        ticks: u32,
+        func: F,
+    ) -> RTResult<Thread>
+    where
+        F: FnOnce() -> () + Send + 'static,
+    {
+        unsafe { Self::spawn_inner(name, stack_size, priority, ticks, Box::new(func)) }
+    }
+}
+
+unsafe impl Send for Thread {}
+
+pub struct ThreadBuilder {
+    th_name: String,
+    th_stack_size: u32,
+    th_priority: u8,
+    th_ticks: u32,
+}
+
+impl ThreadBuilder {
+    pub fn name(&mut self, name: &str) -> &mut Self {
+        self.th_name = name.into();
+        self
+    }
+
+    pub fn stack_size(&mut self, stack_size: u32) -> &mut Self {
+        self.th_stack_size = stack_size;
+        self
+    }
+
+    pub fn priority(&mut self, priority: u8) -> &mut Self {
+        self.th_priority = priority;
+        self
+    }
+
+    pub fn ticks(&mut self, ticks: u32) -> &mut Self {
+        self.th_ticks = ticks;
+        self
+    }
+
+    pub fn start<F>(&self, func: F) -> RTResult<Thread>
+    where
+        F: FnOnce() -> (),
+        F: Send + 'static,
+    {
+        Thread::spawn(
+            self.th_name.clone(),
+            self.th_stack_size,
+            self.th_priority,
+            self.th_ticks,
+            func,
+        )
+    }
+}

components/rust/core/src/time.rs

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2025-10-10     foxglove     RT-Thread Time implementation
+ */
+use crate::api::*;
+use crate::bindings::libc;
+use core::time::Duration;
+
+pub fn sleep(time: Duration) {
+    let mut time = time.as_millis();
+    const MAX_DELAY: u128 = i32::MAX as u128;
+    const MAX_DELAY_P1: u128 = i32::MAX as u128 + 1;
+    loop {
+        match time {
+            1..=MAX_DELAY => {
+                let _ = thread_m_delay(time as i32);
+                return;
+            }
+            0 => return,
+            MAX_DELAY_P1..=u128::MAX => {
+                let _ = thread_m_delay(i32::MAX);
+                time -= i32::MAX as u128;
+            }
+        }
+    }
+}
+
+pub fn get_time() -> Duration {
+    let mut tv = libc::timeval {
+        tv_sec: 0,
+        tv_usec: 0,
+    };
+    unsafe {
+        libc::gettimeofday(&mut tv, core::ptr::null_mut());
+    }
+    Duration::new(tv.tv_sec as u64, tv.tv_usec as u32 * 1000)
+}

components/rust/docs/1.tools/tools.md

@@ -0,0 +1,86 @@
+# RT-Thread to Rust Feature Configuration System
+
+This document explains how to use example configuration files to manage the mapping relationship between RT-Thread component configurations and Rust features.
+
+## Overview
+
+The configuration system allows you to extend the mapping relationship between RT-Thread component configuration items and Rust features through example configuration files, ensuring that only applications that depend on related components will enable corresponding features. Users can add new component configuration mappings as needed. This makes the system more modular and extensible.
+
+## Core Components
+
+### 1. Configuration Mapping Table (CONFIG_FEATURE_MAP)
+
+The `CONFIG_FEATURE_MAP` located in `tools/feature_config_examples.py` defines the basic mapping relationship from RT-Thread component configuration items to Rust features:
+
+```python
+CONFIG_FEATURE_MAP = {
+    'RUST_LOG_COMPONENT': {
+        'feature': 'enable-log',
+        'dependencies': ['em_component_log'],
+        'description': 'Enable Rust logging component integration'
+    },
+}
+```
+
+### 2. Dependency Check Mechanism
+
+The system automatically checks the application's `Cargo.toml` file to ensure that only applications that depend on related components will enable corresponding features.
+
+## How to Add New Components
+
+### Using Example Configuration Files
+
+1. View the example configurations in `feature_config_examples.py`
+2. Modify the example configuration file as needed, adding the component configuration mappings you require
+3. The system will automatically load the mappings from the example configuration file
+4. Ensure that related component dependencies are added to the application's `Cargo.toml`
+
+## Configuration Item Format
+
+Each configuration item contains the following fields:
+
+- `feature`: The name of the Rust feature to enable
+- `dependencies`: Optional, list of components that the application must depend on
+- `description`: Optional, description of the configuration item
+
+## Example Scenario
+
+1. Add the `RUST_LOG_COMPONENT` configuration item in RT-Thread's Kconfig
+2. Add the corresponding mapping in `feature_config_examples.py`:
+
+```python
+CONFIG_FEATURE_MAP.update({
+    'RUST_LOG_COMPONENT': {
+        'feature': 'enable-log',
+        'dependencies': ['em_component_log'],
+        'description': 'Enable Rust logging component integration'
+    },
+})
+```
+
+3. In the `Cargo.toml` of a Rust application that needs logging functionality:
+
+```toml
+[features]
+enable-log = ["em_component_log/enable-log"]
+
+[dependencies]
+em_component_log = { path = "PATH/TO/components/log" }
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Feature not enabled**: Check if the application depends on the related components
+2. **Build failure**: Ensure that the corresponding features are defined in the application's `Cargo.toml`
+3. **Configuration not taking effect**: Verify that the RT-Thread configuration item is correctly enabled
+4. **Example configuration not loaded**: Check if the `feature_config_examples.py` file exists and has correct syntax
+
+### Debugging Steps
+
+1. Check the configuration loading information in the build logs
+2. Verify the syntax of the example configuration file
+3. Check the feature enabling information in the build logs
+4. Verify the application's `Cargo.toml` configuration
+5. Confirm the RT-Thread configuration item status

components/rust/docs/1.tools/tools_cn.md

@@ -0,0 +1,87 @@
+# RT-Thread to Rust Feature Configuration System
+
+这个文档说明如何使用示例配置文件来管理 RT-Thread 组件配置与 Rust features 之间的映射关系。
+
+## 概述
+
+配置系统允许你通过示例配置文件来扩展 RT-Thread 组件配置项与 Rust features 的映射关系，并确保只有依赖了相关组件的应用才会启用对应的 features，用户可以根据需要添加新的组件配置映射。这使得系统更加模块化和可扩展。
+
+## 核心组件
+
+
+### 1. 配置映射表 (CONFIG_FEATURE_MAP)
+
+位于 `tools/feature_config_examples.py` 中的 `CONFIG_FEATURE_MAP` 定义了 RT-Thread 组件配置项到 Rust features 的基础映射关系：
+
+```python
+CONFIG_FEATURE_MAP = {
+    'RUST_LOG_COMPONENT': {
+        'feature': 'enable-log',
+        'dependencies': ['em_component_log'],
+        'description': 'Enable Rust logging component integration'
+    },
+}
+```
+
+### 2. 依赖检查机制
+
+系统会自动检查应用程序的 `Cargo.toml` 文件，确保只有依赖了相关组件的应用才会启用对应的 features。
+
+## 如何添加新的组件
+
+### 使用示例配置文件
+
+1. 查看 `feature_config_examples.py` 中的示例配置
+2. 根据需要修改示例配置文件，添加你需要的组件配置映射
+3. 系统会自动加载示例配置文件中的映射
+4. 确保在应用程序的 `Cargo.toml` 中添加了相关组件的依赖
+
+## 配置项格式
+
+每个配置项包含以下字段：
+
+- `feature`: 要启用的 Rust feature 名称
+- `dependencies`: 可选，应用程序必须依赖的组件列表
+- `description`: 可选，配置项的描述
+
+## 示例场景
+
+1. 在 RT-Thread 的 Kconfig 中添加 `RUST_LOG_COMPONENT` 配置项
+2. 在 `feature_config_examples.py` 中添加对应的映射：
+
+```python
+CONFIG_FEATURE_MAP.update({
+    'RUST_LOG_COMPONENT': {
+        'feature': 'enable-log',
+        'dependencies': ['em_component_log'],
+        'description': 'Enable Rust logging component integration'
+    },
+})
+```
+
+3. 在需要日志功能的 Rust 应用的 `Cargo.toml` 中：
+
+```toml
+[features]
+enable-log = ["em_component_log/enable-log"]
+
+[dependencies]
+em_component_log = { path = "PATH/TO/components/log" }
+```
+
+## 故障排除
+
+### 常见问题
+
+1. **Feature 未启用**: 检查应用是否依赖了相关组件
+2. **构建失败**: 确保应用的 `Cargo.toml` 中定义了相应的 features
+3. **配置不生效**: 验证 RT-Thread 配置项是否正确启用
+4. **示例配置未加载**: 检查 `feature_config_examples.py` 文件是否存在且语法正确
+
+### 调试步骤
+
+1. 检查构建日志中的配置加载信息
+2. 验证示例配置文件的语法
+3. 检查构建日志中的 feature 启用信息
+4. 验证应用的 `Cargo.toml` 配置
+5. 确认 RT-Thread 配置项状态

components/rust/docs/2.applications/application.md

@@ -0,0 +1,123 @@
+# RT-Thread Rust Example User Applications
+
+This directory contains a series of example user applications and components that demonstrate Rust programming capabilities in RT-Thread. These examples showcase how to use the Rust programming language for system programming in the RT-Thread real-time operating system.
+
+## Directory Structure
+
+```
+example_usrapp/
+├── SConscript              # SCons build script
+├── fs/                     # File system operation examples
+├── loadlib/                # Dynamic library loading examples
+├── mutex/                  # Mutex synchronization examples
+├── param/                  # Parameter handling examples
+├── queue/                  # Message queue examples
+├── semaphore/              # Semaphore synchronization examples
+└── thread/                 # Thread management examples
+```
+
+## Build and Run
+
+### Prerequisites
+
+1. Ensure Rust support is enabled in RT-Thread configuration (`RT_USING_RUST`), and enable examples compilation (`RT_USING_RUST_EXAMPLES`) and application examples compilation (`RT_RUST_BUILD_APPLICATIONS`).
+2. Install Rust toolchain and related dependencies
+3. Configure the correct cross-compilation environment
+
+### Build Steps
+
+1. Execute in the RT-Thread project root directory:
+   ```bash
+   scons -j$(nproc)
+   ```
+
+2. The build system will automatically:
+   - Detect enabled RT-Thread configurations
+   - Enable corresponding Rust features based on configuration
+   - Compile all example applications as static libraries
+   - Link to the final firmware image
+
+### Running Examples
+
+After RT-Thread system startup, you can run various examples through the command line:
+
+```bash
+# View all available examples
+help
+
+# Run thread example
+rust_thread_demo
+
+# Run file system example
+rust_file_demo
+
+# Other examples similarly...
+```
+
+## Technical Features
+
+### Dependency Management
+
+All example applications depend on the following core components:
+- `rt-rust`: RT-Thread Rust binding library
+- `macro_main`: Main function macro support
+
+The `fs` example also depends on the logging component:
+- `em_component_log`: Logging component
+
+### Feature Configuration
+
+- Support for conditional compilation features
+- Automatic feature detection and enabling
+- Modular functionality configuration
+
+### Build System Integration
+
+- Fully integrated with SCons build system
+- Support for clean and incremental builds
+- Automatic dependency management
+
+## Development Guide
+
+### Adding New Examples
+
+1. Create a new directory under `example_usrapp/`
+2. Add `Cargo.toml` configuration file
+3. Implement example code in `src/lib.rs`
+4. Use `#[macro_main_use]` macro to define entry point
+
+### Example Template
+
+```rust
+#![no_std]
+
+use macro_main::macro_main_use;
+use rt_rust::param::Param;
+use rt_rust::println;
+
+#[macro_main_use(
+    name = "your_demo_name",
+    component = "Whether it's a component example",
+    app = "Whether it's a user application example",
+    cmd = true,
+    desc = "Your demo description."
+)]
+fn main(_param: Param) {
+    println!("Hello from your demo!");
+    // Your example code...
+}
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Compilation failure**: Check if Rust toolchain is correctly installed
+2. **Linking errors**: Confirm cross-compilation target configuration is correct
+3. **Runtime errors**: Check stack size and memory configuration
+
+### Debugging Suggestions
+
+1. Use `println!` for basic debug output
+2. Enable logging features to get detailed information
+3. Check if RT-Thread configuration items are correctly enabled

components/rust/docs/2.applications/application_cn.md

@@ -0,0 +1,123 @@
+# RT-Thread Rust 示例用户应用程序
+
+这个目录包含了一系列用于演示 RT-Thread 中 Rust 编程功能的示例用户应用程序和组件。这些示例展示了如何在 RT-Thread 实时操作系统中使用 Rust 语言进行系统编程。
+
+## 目录结构
+
+```
+example_usrapp/
+├── SConscript              # SCons 构建脚本
+├── fs/                     # 文件系统操作示例
+├── loadlib/                # 动态库加载示例
+├── mutex/                  # 互斥锁同步示例
+├── param/                  # 参数处理示例
+├── queue/                  # 消息队列示例
+├── semaphore/              # 信号量同步示例
+└── thread/                 # 线程管理示例
+```
+
+## 构建和运行
+
+### 前提条件
+
+1. 确保 RT-Thread 配置中启用了 Rust 支持 (`RT_USING_RUST`)，并且开启 examples 编译(`RT_USING_RUST_EXAMPLES`)中的应用(`RT_RUST_BUILD_APPLICATIONS`)
+2. 安装 Rust 工具链和相关依赖
+3. 配置正确的交叉编译环境
+
+### 构建步骤
+
+1. 在 RT-Thread 项目根目录执行：
+   ```bash
+   scons -j$(nproc)
+   ```
+
+2. 构建系统会自动：
+   - 检测启用的 RT-Thread 配置
+   - 根据配置启用相应的 Rust 特性
+   - 编译所有示例应用为静态库
+   - 链接到最终的固件镜像
+
+### 运行示例
+
+在 RT-Thread 系统启动后，可以通过命令行运行各个示例：
+
+```bash
+# 查看所有可用示例
+help
+
+# 运行线程示例
+rust_thread_demo
+
+# 运行文件系统示例
+rust_file_demo
+
+# 其他示例类似...
+```
+
+## 技术特性
+
+### 依赖管理
+
+所有示例应用都依赖以下核心组件：
+- `rt-rust`: RT-Thread Rust 绑定库
+- `rt-macro`: 主函数宏支持
+
+`fs`示例还依赖日志组件：
+- `em_component_log`: 日志组件
+
+### 特性配置
+
+- 支持条件编译特性
+- 自动特性检测和启用
+- 模块化的功能配置
+
+### 构建系统集成
+
+- 与 SCons 构建系统完全集成
+- 支持清理和增量构建
+- 自动依赖管理
+
+## 开发指南
+
+### 添加新示例
+
+1. 在 `example_usrapp/` 下创建新目录
+2. 添加 `Cargo.toml` 配置文件
+3. 在 `src/lib.rs` 中实现示例代码
+4. 使用 `#[macro_main_use]` 宏定义入口点
+
+### 示例模板
+
+```rust
+#![no_std]
+
+use macro_main::macro_main_use;
+use rt_rust::param::Param;
+use rt_rust::println;
+
+#[macro_main_use(
+    name = "your_demo_name",
+    component = "是否为组件示例",
+    app = "是否为用户应用示例",
+    cmd = true,
+    desc = "Your demo description."
+)]
+fn main(_param: Param) {
+    println!("Hello from your demo!");
+    // 你的示例代码...
+}
+```
+
+## 故障排除
+
+### 常见问题
+
+1. **编译失败**: 检查 Rust 工具链是否正确安装
+2. **链接错误**: 确认交叉编译目标配置正确
+3. **运行时错误**: 检查栈大小和内存配置
+
+### 调试建议
+
+1. 使用 `println!` 进行基本调试输出
+2. 启用日志特性获取详细信息
+3. 检查 RT-Thread 配置项是否正确启用

components/rust/docs/3.components/component.md

@@ -0,0 +1,226 @@
+# Example Component - RT-Thread Rust Component Example
+
+## Overview
+
+`example_component` is a Rust component example based on RT-Thread, demonstrating how to implement, register, and manage Rust components in RT-Thread systems. This project adopts a unified component registration architecture that avoids component duplicate registration issues and supports conditional compilation based on RT-Thread configuration.
+
+## Project Structure
+
+```
+example_component/
+├── SConscript                      # SCons build script
+├── component_registry/             # Unified component registry
+│   ├── Cargo.toml                  # Registry configuration
+│   └── src/
+│       └── lib.rs                  # Registry implementation
+├── log/                            # Log component example
+│   ├── Cargo.toml                  # Log component configuration
+│   └── src/
+│       ├── lib.rs                  # Log component implementation
+│       └── logging.rs              # Logging functionality module
+└── tools/                          # Build tools
+    ├── build_component.py          # Component build tool
+    └── feature_config_component.py # Feature configuration
+```
+
+## Core Features
+
+### 1. Unified Component Registration Architecture
+
+- **Avoid Duplicate Registration**: Unified management of all component registrations through `component_registry`, avoiding conflicts caused by multiple component duplicate registrations
+- **Conditional Compilation Support**: Selectively compile and register components based on RT-Thread configuration
+- **Modular Design**: Each component is implemented independently and managed uniformly through the registry
+
+### 2. Feature Configuration System
+
+- **Based on RT-Thread Configuration**: Feature enablement is entirely based on RT-Thread configuration items, requiring no additional configuration
+- **Automatic Feature Mapping**: Build system automatically maps RT-Thread configuration to Rust features
+- **Dependency Checking**: Automatically checks component dependencies to ensure build consistency
+
+### 3. Build System Integration
+
+- **SCons Integration**: Fully integrated with RT-Thread's SCons build system
+- **Incremental Build**: Supports clean and incremental builds
+- **Cross Compilation**: Supports cross-compilation for target architectures like RISC-V
+
+## Component Details
+
+### Component Registry
+
+`component_registry` is the core of the entire architecture, responsible for unified management of all component registrations.
+
+#### Main Functions
+
+1. **Unified Entry Point**: Provides `rust_component_registry` as the unified registration entry for all components
+2. **Conditional Compilation**: Only includes and registers corresponding components when respective features are enabled
+3. **Avoid Conflicts**: Ensures each component is registered only once
+
+### Log Component
+
+The `log` component provides Rust-style logging functionality, including multiple log levels and command-line interface.
+
+#### Main Functions
+
+1. **Multi-level Logging**: Supports INFO, WARN, ERROR, DEBUG, TRACE and other log levels
+2. **Command-line Interface**: Provides commands like `log_info`, `log_warn`, `log_error`
+3. **Conditional Compilation**: Only compiles when `enable-log` feature is enabled
+
+#### Usage Examples
+
+```rust
+// Using log macros in code
+info!("This is an info log");
+warn!("This is a warning log");
+error!("This is an error log");
+```
+
+#### Command-line Usage
+
+```bash
+# Using in RT-Thread command line
+msh> log_info    # Print info log
+msh> log_warn    # Print warning log
+msh> log_error   # Print error log
+```
+
+## Feature Configuration
+
+### Configuration Mapping
+
+The mapping from RT-Thread configuration to Rust features is defined in `tools/feature_config_component.py`:
+
+```python
+CONFIG_COMPONENT_FEATURE_MAP = {
+    'RUST_LOG_COMPONENT': {
+        'feature': 'enable-log',
+        'dependency': 'em_component_log',
+        'description': 'Enable Rust log component integration'
+    }
+}
+```
+
+### Enabling Components
+
+To enable the log component, set in RT-Thread configuration:
+
+```c
+// Set through menuconfig
+Enable Rust component support -> Auto-initialize Rust log component
+```
+
+## Development Guide
+
+### Adding New Components
+
+1. **Create Component Directory**
+   ```bash
+   cargo new --lib example_component/new_component
+   cd example_component/new_component
+   ```
+
+2. **Create Cargo.toml**
+   ```toml
+   [package]
+   name = "em_component_new"
+   version = "0.1.0"
+   edition = "2021"
+
+   [lib]
+   name = "em_component_new"
+   crate-type = ["staticlib"]
+
+   [dependencies]
+   rt-rust = { path = "../../rust" }
+   macro_main = { path = "../../rust/macro-main" }
+
+   [features]
+   default = []
+   enable-new = []
+   ```
+
+3. **Implement Component Functionality**
+   ```rust
+   // src/new.rs
+   // New component implementation code
+
+   // src/lib.rs
+   #![no_std]
+   // Export required libraries
+   ```
+
+4. **Update Feature Configuration**
+   ```python
+   # Add to tools/feature_config_component.py
+   CONFIG_COMPONENT_FEATURE_MAP = {
+       # ... existing configuration ...
+       'RUST_NEW_COMPONENT': {
+           'feature': 'enable-new',
+           'dependency': 'em_component_new',
+           'description': 'Enable new component integration'
+       }
+   }
+   ```
+
+5. **Update Registry**
+   ```toml
+   # Add to component_registry/Cargo.toml
+   [dependencies]
+   em_component_new = { path = "../new_component", optional = true }
+
+   [features]
+   enable-new = ["em_component_new", "em_component_new/enable-new"]
+   ```
+
+   ```rust
+   // Register in component_registry/src/lib.rs
+   #[cfg(feature = "enable-new")]
+   use em_component_new;
+
+   fn component_registry_main() {
+       #[cfg(feature = "enable-new")]
+       {
+           println!("Component registry: New component enabled");
+       }
+       // ... other components ...
+   }
+   ```
+
+### Component Development Best Practices
+
+1. **Use Conditional Compilation**: All functionality should be wrapped with `#[cfg(feature = "...")]`
+2. **Avoid Direct Registration**: Don't use component registration macros directly in components, let `component_registry` manage uniformly
+3. **Provide Command Interface**: Provide command-line interfaces for component functionality for easy testing and usage
+4. **Complete Documentation**: Provide detailed documentation and usage examples for each component
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Compilation Failure**
+   - Check if Rust toolchain is correctly installed
+   - Confirm target architecture (e.g., `riscv64imac-unknown-none-elf`) is installed
+   - Check if dependency paths are correct
+
+2. **Features Not Enabled**
+   - Confirm corresponding macro definitions are set in RT-Thread configuration
+   - Check mapping configuration in `feature_config_component.py`
+   - Review feature enablement information in build logs
+
+3. **Linking Errors**
+   - Confirm all dependent components are correctly built
+   - Check dependency configuration in `Cargo.toml`
+   - Verify library file paths and names
+
+## Dependency Relationships
+
+```
+RT-Thread Config
+      ↓
+Feature Mapping
+      ↓
+Rust Features
+      ↓
+Component Registry ← Individual Components
+      ↓
+RT-Thread System
+```

components/rust/docs/3.components/component_cn.md

@@ -0,0 +1,227 @@
+# Example Component - RT-Thread Rust 组件示例
+
+## 概述
+
+`example_component` 是一个基于 RT-Thread 的 Rust 组件示例，展示了如何在 RT-Thread 系统中实现、注册和管理 Rust 组件。该项目采用统一的组件注册架构，避免了组件重复注册问题，并支持基于 RT-Thread 配置的条件编译。
+
+## 项目结构
+
+```
+example_component/
+├── SConscript                      # SCons 构建脚本
+├── component_registry/             # 统一组件注册程序
+│   ├── Cargo.toml                  # 注册程序配置
+│   └── src/
+│       └── lib.rs                  # 注册程序实现
+├── log/                            # 日志组件示例
+│   ├── Cargo.toml                  # 日志组件配置
+│   └── src/
+│       ├── lib.rs                  # 日志组件实现
+│       └── logging.rs              # 日志功能模块
+└── tools/                          # 构建工具
+    ├── build_component.py          # 组件构建工具
+    └── feature_config_component.py # 特性配置
+```
+
+## 核心特性
+
+### 1. 统一组件注册架构
+
+- **避免重复注册**: 通过 `component_registry` 统一管理所有组件的注册，避免多个组件重复注册导致的冲突
+- **条件编译支持**: 根据 RT-Thread 配置选择性编译和注册组件
+- **模块化设计**: 每个组件独立实现，通过注册程序统一管理
+
+### 2. 特性配置系统
+
+- **基于 RT-Thread 配置**: 特性启用完全基于 RT-Thread 的配置项，无需额外配置
+- **自动特性映射**: 构建系统自动将 RT-Thread 配置映射为 Rust 特性
+- **依赖检查**: 自动检查组件依赖关系，确保构建一致性
+
+### 3. 构建系统集成
+
+- **SCons 集成**: 与 RT-Thread 的 SCons 构建系统完全集成
+- **增量构建**: 支持清理和增量构建
+- **交叉编译**: 支持 RISC-V 等目标架构的交叉编译
+
+## 组件详解
+
+### Component Registry (组件注册程序)
+
+`component_registry` 是整个架构的核心，负责统一管理所有组件的注册。
+
+#### 主要功能
+
+1. **统一入口点**: 提供 `rust_component_registry` 作为所有组件的统一注册入口
+2. **条件编译**: 只在相应特性启用时才包含和注册对应组件
+3. **避免冲突**: 确保每个组件只被注册一次
+
+
+### Log Component (日志组件)
+
+`log` 组件提供了 Rust 风格的日志功能，包括多个日志级别和命令行接口。
+
+#### 主要功能
+
+1. **多级别日志**: 支持 INFO、WARN、ERROR、DEBUG、TRACE 等日志级别
+2. **命令行接口**: 提供 `log_info`、`log_warn`、`log_error` 等命令
+3. **条件编译**: 只在 `enable-log` 特性启用时编译
+
+#### 使用示例
+
+```rust
+// 在代码中使用日志宏
+info!("这是一条信息日志");
+warn!("这是一条警告日志");
+error!("这是一条错误日志");
+```
+
+#### 命令行使用
+
+```bash
+# 在 RT-Thread 命令行中使用
+msh> log_info    # 打印信息日志
+msh> log_warn    # 打印警告日志
+msh> log_error   # 打印错误日志
+```
+
+## 特性配置
+
+### 配置映射
+
+在 `tools/feature_config_component.py` 中定义了 RT-Thread 配置到 Rust 特性的映射：
+
+```python
+CONFIG_COMPONENT_FEATURE_MAP = {
+    'RUST_LOG_COMPONENT': {
+        'feature': 'enable-log',
+        'dependency': 'em_component_log',
+        'description': 'Enable Rust log component integration'
+    }
+}
+```
+
+### 启用组件
+
+要启用日志组件，需要在 RT-Thread 配置中设置：
+
+```c
+// 通过 menuconfig 设置
+Enable Rust component support -> Auto-initialize Rust log component
+```
+
+## 开发指南
+
+### 添加新组件
+
+1. **创建组件目录**
+   ```bash
+   cargo new --lib example_component/new_component
+   cd example_component/new_component
+   ```
+
+2. **创建 Cargo.toml**
+   ```toml
+   [package]
+   name = "em_component_new"
+   version = "0.1.0"
+   edition = "2021"
+
+   [lib]
+   name = "em_component_new"
+   crate-type = ["staticlib"]
+
+   [dependencies]
+   rt-rust = { path = "../../rust" }
+   macro_main = { path = "../../rust/macro-main" }
+
+   [features]
+   default = []
+   enable-new = []
+   ```
+
+3. **实现组件功能**
+   ```rust
+   // src/new.rs
+   // 新组件的实现代码
+
+   // src/lib.rs
+   #![no_std]
+   // 导出需要的库
+   ```
+
+4. **更新特性配置**
+   ```python
+   # 在 tools/feature_config_component.py 中添加
+   CONFIG_COMPONENT_FEATURE_MAP = {
+       # ... 现有配置 ...
+       'RUST_NEW_COMPONENT': {
+           'feature': 'enable-new',
+           'dependency': 'em_component_new',
+           'description': 'Enable new component integration'
+       }
+   }
+   ```
+
+5. **更新注册程序**
+   ```toml
+   # 在 component_registry/Cargo.toml 中添加
+   [dependencies]
+   em_component_new = { path = "../new_component", optional = true }
+
+   [features]
+   enable-new = ["em_component_new", "em_component_new/enable-new"]
+   ```
+
+   ```rust
+   // 在 component_registry/src/lib.rs 中注册
+   #[cfg(feature = "enable-new")]
+   use em_component_new;
+
+   fn component_registry_main() {
+       #[cfg(feature = "enable-new")]
+       {
+           println!("Component registry: New component enabled");
+       }
+       // ... 其他组件 ...
+   }
+   ```
+
+### 组件开发最佳实践
+
+1. **使用条件编译**: 所有功能都应该用 `#[cfg(feature = "...")]` 包装
+2. **避免直接注册**: 不要在组件中直接使用组件注册宏，让 `component_registry` 统一管理
+3. **提供命令接口**: 为组件功能提供命令行接口，方便测试和使用
+4. **文档完整**: 为每个组件提供详细的文档和使用示例
+
+## 故障排除
+
+### 常见问题
+
+1. **编译失败**
+   - 检查 Rust 工具链是否正确安装
+   - 确认目标架构 (如 `riscv64imac-unknown-none-elf`) 已安装
+   - 检查依赖路径是否正确
+
+2. **特性未启用**
+   - 确认 RT-Thread 配置中已设置相应的宏定义
+   - 检查 `feature_config_component.py` 中的映射配置
+   - 查看构建日志中的特性启用信息
+
+3. **链接错误**
+   - 确认所有依赖组件都已正确构建
+   - 检查 `Cargo.toml` 中的依赖配置
+   - 验证库文件路径和名称
+
+## 依赖关系
+
+```
+RT-Thread Config
+      ↓
+Feature Mapping
+      ↓
+Rust Features
+      ↓
+Component Registry ← Individual Components
+      ↓
+RT-Thread System
+```

components/rust/docs/4.modules/modules.md

@@ -0,0 +1,47 @@
+# Writing a Rust Dynamic Library Usable by RT-Thread
+
+1. Set up the project
+Create a new `cargo` project as usual. There are some flags to tell `cargo` to generate a system library instead of a regular Rust target.
+
+```toml
+[lib]
+name = "your_crate"
+crate-type = ["cdylib"]      # generate a dynamic library
+# crate-type = ["staticlib"] # generate a static library
+```
+
+Add the following to `config.toml` to specify the target platform:
+
+```toml
+[build]
+target = "your_target"
+```
+
+2. Enable RT-Thread dynamic module loading
+To load dynamic modules in RT-Thread, enable it in `Kconfig`:
+```
+RT-Thread Components → C/C++ and POSIX layer 
+    → POSIX (Portable Operating System Interface) layer 
+        → Enable dynamic module APIs, dlopen()/dlsym()/dlclose() etc
+```
+
+3. Enable the filesystem
+To place dynamic modules into RT-Thread, enable a filesystem in `Kconfig`:
+```
+RT-Thread online packages → system packages 
+    → lwext4: an excellent choice of ext2/3/4 filesystem for microcontrollers.
+```
+
+## Using the rust library
+
+Add `rt_rust` dependency in `Cargo.toml`:
+
+```toml
+[dependencies]
+rt_rust = { path = "PATH/TO/rust/rt-rust" }
+```
+
+Currently the macro-main library is not supported because it causes entry detection issues.
+
+## References
+- [The Embedded Rust Book](https://xxchang.github.io/book/interoperability/rust-with-c.html#extern-c)

components/rust/docs/4.modules/modules_cn.md

@@ -0,0 +1,47 @@
+# 编写RT-Thread可以使用的rust动态库
+
+1. 设置项目
+像往常一样创建一个新的`cargo`项目。有一些标志可以告诉`cargo`去生成一个系统库，而不是常规的rust目标文件。
+
+```toml
+[lib]
+name = "your_crate"
+crate-type = ["cdylib"]      # 生成动态链接库
+# crate-type = ["staticlib"] # 生成静态链接库
+```
+
+在 `config.toml` 中添加以下内容，以指定目标平台
+
+```toml
+[build]
+target = "your_target
+```
+
+2. 开启 RT-Thread 加载动态模块功能
+为了能够在 RT-Thread 中加载动态模块，需要在 `Kconfig` 中开启 
+```
+RT-Thread Components → C/C++ and POSIX layer 
+    → POSIX (Portable Operating System Interface) layer 
+        → Enable dynamic module APIs, dlopen()/dlsym()/dlclose() etc
+```
+
+3. 打开文件系统
+为了能够将动态模块放入 RT-Thread 中，需要在 `Kconfig` 中开启文件系统。
+
+```
+RT-Thread online packages → system packages 
+    → lwext4: an excellent choice of ext2/3/4 filesystem for microcontrollers.
+```
+
+## rust库的使用
+ 
+在 `Cargo.toml` 中添加 `rt_rust` 依赖
+
+```toml
+[dependencies]
+rt_rust = { path = "PATH/TO/rust/rt-rust" }
+```
+
+目前不支持macro-main库的使用，因为它会导致入口识别错误。
+## 参考资料
+- [The Embedded Rust Book](https://xxchang.github.io/book/interoperability/rust-with-c.html#extern-c)

components/rust/docs/5.rt-macro/rt-macros.md

@@ -0,0 +1,103 @@
+# rt_macros Usage Guide
+
+rt_macros is a collection of Rust procedural macros for RT-Thread. It helps export Rust functions as system entry points, initialization entries, or shell commands in a `no_std` environment, so they integrate cleanly with RT-Thread’s startup and command mechanisms.
+
+## Background and Goals
+
+In `no_std` mode, the traditional `main` function is not directly available. rt_macros generates C-ABI-compatible wrapper entries and the required link-section items so RT-Thread can discover and invoke the corresponding Rust logic during startup or shell command scanning.
+
+## Provided Macros (aligned with RT-Thread conventions)
+
+- `rt_thread_main!`: Marks the Rust main-thread entry.
+  - Function signature: `fn()` (no parameters, no return value).
+  - Constraints: no `const`, `unsafe`, `async`, varargs; no explicit ABI; no generics; default visibility (non-`pub`).
+  - Purpose: exports an entry that RT-Thread can recognize and call as the main thread.
+
+- `rt_component_export!`: Exports a component initialization entry.
+  - Function signature: `fn()`.
+  - Same constraints; optional parameter: `name = "..."` (used to generate internal symbol names).
+  - Link section: places the function pointer into `.rti_fn.4`, executed during the component initialization phase.
+
+- `rt_app_export!`: Exports an application initialization entry.
+  - Function signature: `fn()`.
+  - Same constraints; optional parameter: `name = "..."`.
+  - Link section: places the function pointer into `.rti_fn.6`, executed during the application initialization phase.
+
+- `msh_cmd_export!`: Exports an RT-Thread shell command.
+  - Function signature: `fn(args: vec::IntoIter<rt_rust::param::ParamItem>)`.
+  - Attributes: `name` (required, command name), `desc` (optional, command description).
+  - Link sections and data:
+    - Generates a command descriptor struct placed into `FSymTab`.
+    - Command name and description are `\0`-terminated byte arrays placed into `.rodata.name`.
+  - Invocation wrapper: generates an `extern "C"` wrapper `(argc, argv)`, converts `argv` to `Vec<ParamItem>`, and calls the original Rust command function.
+
+## Link Sections and Startup Flow
+
+- Component init entries: `.rti_fn.4`
+- Application init entries: `.rti_fn.6`
+- Shell command table: `FSymTab`
+- Shell name/description strings: `.rodata.name`
+
+During startup or shell scanning, RT-Thread traverses these sections to register or invoke the corresponding Rust logic.
+
+## Usage Examples
+
+### Main-thread entry
+```rust
+use rt_macros::rt_thread_main;
+
+#[rt_thread_main]
+fn main() {
+    // Main thread logic here
+}
+```
+
+### Component export
+```rust
+use rt_macros::rt_component_export;
+
+#[rt_component_export(name = "rust_component_registry")]
+fn my_component_init() {
+    // Component init logic
+}
+```
+
+### Application export
+```rust
+use rt_macros::rt_app_export;
+
+#[rt_app_export(name = "rust_app_example")]
+fn my_app_init() {
+    // Application init logic
+}
+```
+
+### Shell command export
+```rust
+use rt_macros::msh_cmd_export;
+
+#[msh_cmd_export(name = "hello", desc = "Say hello")]
+fn hello_cmd(args: vec::IntoIter<rt_rust::param::ParamItem>) {
+    // Handle args and print output, etc.
+}
+```
+
+## Interacting with C Code
+
+When calling exported Rust entries from C, declare the prototype and use `extern "C"` for the calling convention, for example:
+
+```c
+extern "C" void rust_function_name(void);
+```
+
+The command export macro generates a wrapper with `(argc, argv)`; RT-Thread’s command system calls this wrapper and passes the arguments to the original Rust function.
+
+## Common Issues and Diagnostics
+
+- Compile-time errors: the macros produce explicit diagnostics if the function signature does not match (e.g., must be `fn()` or a specific parameter shape). Adjust the function to meet the requirements above.
+- Visibility requirement: keep the entry function at default (non-`pub`) visibility to satisfy macro constraints.
+- `alloc` dependency: the shell command macro uses `alloc::vec::Vec`, ensure an allocator is available at runtime (RT-Thread usually provides one).
+
+## References
+
+- [RUST support for rt-thread](https://github.com/rust-for-rtthread/rtt_rust)

components/rust/docs/5.rt-macro/rt-macros_cn.md

@@ -0,0 +1,103 @@
+# rt_macros 使用说明
+
+rt_macros 是为 RT-Thread 提供的 Rust 过程宏集合，帮助在 `no_std` 环境下将 Rust 函数以约定的方式导出为系统入口、初始化段或 Shell 命令，从而与 RT-Thread 的启动与命令机制顺畅对接。
+
+## 背景与目标
+
+在 `no_std` 模式下不能直接使用传统的 `main` 函数。rt_macros 通过过程宏生成符合 C ABI 的包装入口，以及必要的链接段条目，让 RT-Thread 能在启动期或命令扫描阶段发现并调用对应的 Rust 逻辑。
+
+## 提供的宏（参考RT-Thread的声明）
+
+- `rt_thread_main!`：标记 Rust 主线程入口。
+  - 函数签名：`fn()`（无参数、无返回值）。
+  - 约束：不支持 `const`、`unsafe`、`async`、变参；不可使用显式 ABI；不可含泛型；函数可见性需为默认（非 `pub`）。
+  - 作用：导出可由 RT-Thread 识别和调用的主线程入口。
+
+- `rt_component_export!`：导出为组件初始化入口。
+  - 函数签名：`fn()`。
+  - 约束同上；可选参数：`name = "..."`（用于生成内部符号名称）。
+  - 链接段：将函数指针落入 `.rti_fn.4` 段，供组件初始化阶段调用。
+
+- `rt_app_export!`：导出为应用初始化入口。
+  - 函数签名：`fn()`。
+  - 约束同上；可选参数：`name = "..."`。
+  - 链接段：将函数指针落入 `.rti_fn.6` 段，供应用初始化阶段调用。
+
+- `msh_cmd_export!`：导出为 RT-Thread Shell 命令。
+  - 函数签名：`fn(args: vec::IntoIter<rt_rust::param::ParamItem>)`。
+  - 属性参数：`name`（必填，命令名），`desc`（可选，命令描述）。
+  - 链接段与数据：
+    - 生成命令描述结构体并落入 `FSymTab` 段。
+    - 命令名与描述以以 `\0` 结尾的字节数组形式落入 `.rodata.name` 段。
+  - 调用封装：生成 `extern "C"` 包装函数 `(argc, argv)`，把 `argv` 转换为 `Vec<ParamItem>`，再调用原始 Rust 命令函数。
+
+## 链接段与启动流程
+
+- 组件初始化入口：`.rti_fn.4`
+- 应用初始化入口：`.rti_fn.6`
+- Shell 命令表：`FSymTab`
+- Shell 名称/描述字符串：`.rodata.name`
+
+RT-Thread 在启动或命令表扫描时，会遍历对应段的条目并完成调用或注册，从而将 Rust 编写的逻辑纳入系统。
+
+## 使用示例
+
+### 主线程入口
+```rust
+use rt_macros::rt_thread_main;
+
+#[rt_thread_main]
+fn main() {
+    // 在此编写主线程逻辑
+}
+```
+
+### 组件导出
+```rust
+use rt_macros::rt_component_export;
+
+#[rt_component_export(name = "rust_component_registry")]
+fn my_component_init() {
+    // 组件初始化逻辑
+}
+```
+
+### 应用导出
+```rust
+use rt_macros::rt_app_export;
+
+#[rt_app_export(name = "rust_app_example")]
+fn my_app_init() {
+    // 应用初始化逻辑
+}
+```
+
+### Shell 命令导出
+```rust
+use rt_macros::msh_cmd_export;
+
+#[msh_cmd_export(name = "hello", desc = "Say hello")]
+fn hello_cmd(args: vec::IntoIter<rt_rust::param::ParamItem>) {
+    // 命令处理逻辑，例如解析 args 并打印输出
+}
+```
+
+## 与 C 代码的交互
+
+当需要从 C 调用导出的 Rust 入口时，应在 C 侧声明原型并使用 `extern "C"` 指定调用约定，例如：
+
+```c
+extern "C" void rust_function_name(void);
+```
+
+命令导出宏会生成 `(argc, argv)` 形式的包装函数，RT-Thread 的命令系统会调用该包装函数并将参数传递给原始 Rust 函数。
+
+## 常见问题与诊断
+
+- 编译期报错：宏会在函数签名不符合约束时给出明确的错误信息（例如必须为 `fn()` 或必须为特定的参数形式）。请按上文的签名要求调整。
+- 可见性要求：入口函数应保持默认（非 `pub`），以满足宏的约束。
+- `alloc` 依赖：Shell 命令宏内部使用 `alloc::vec::Vec`，需确保运行环境提供分配器（RT-Thread 通常可满足）。
+
+## 参考实现
+
+- [RUST support for rt-thread](https://github.com/rust-for-rtthread/rtt_rust)

components/rust/examples/Kconfig

@@ -0,0 +1,104 @@
+menuconfig RT_USING_RUST_EXAMPLES
+    bool "Enable Rust Examples"
+    depends on RT_USING_RUST
+    default n
+    help
+        Enable Rust example applications, components, and modules.
+
+if RT_USING_RUST_EXAMPLES
+
+    config RT_RUST_BUILD_ALL_EXAMPLES
+        bool "Build All Examples"
+        default n
+        help
+            Build all available Rust examples.
+
+    menu "Application Examples"
+        config RT_RUST_BUILD_APPLICATIONS
+            bool "Build Application Examples"
+            default y
+            depends on RT_USING_FINSH
+            help
+                Build Rust application examples.
+
+        if RT_RUST_BUILD_APPLICATIONS
+            config RT_RUST_EXAMPLE_FS
+                bool "File System Example"
+                default n
+                help
+                    File system operations example.
+
+            config RT_RUST_EXAMPLE_LOADLIB
+                bool "Dynamic Library Loading Example"
+                default n
+                depends on RT_USING_MODULE
+                help
+                    Dynamic library loading and usage example.
+
+            config RT_RUST_EXAMPLE_MUTEX
+                bool "Mutex Example"
+                default y
+                help
+                    Mutex synchronization example.
+
+            config RT_RUST_EXAMPLE_PARAM
+                bool "Parameter Example"
+                default y
+                help
+                    Basic parameter handling example.
+
+            config RT_RUST_EXAMPLE_QUEUE
+                bool "Queue Example"
+                default y
+                help
+                    Message queue example.
+
+            config RT_RUST_EXAMPLE_SEMAPHORE
+                bool "Semaphore Example"
+                default y
+                help
+                    Semaphore synchronization example.
+
+            config RT_RUST_EXAMPLE_THREAD
+                bool "Thread Example"
+                default y
+                help
+                    Thread creation and management example.
+        endif
+    endmenu
+
+    menu "Component Examples"
+        config RT_RUST_BUILD_COMPONENTS
+            bool "Build Component Examples"
+            default y
+            help
+                Build Rust component examples.
+
+        if RT_RUST_BUILD_COMPONENTS
+            config RUST_LOG_COMPONENT
+                bool "Auto-initialize Rust log component"
+                default y
+                help
+                    Automatically initialize Rust log component during RT-Thread startup.
+        endif
+    endmenu
+
+    menu "Module Examples"
+        config RT_RUST_BUILD_MODULES
+            bool "Build Module Examples"
+            default n
+            depends on RT_USING_MODULE
+            help
+                Build Rust dynamic module examples.
+
+        if RT_RUST_BUILD_MODULES
+            config RT_RUST_MODULE_SIMPLE_MODULE
+                bool "Simple Module"
+                default y
+                help
+                    Basic dynamic module template.
+
+        endif
+    endmenu
+
+endif

components/rust/examples/SConscript

@@ -0,0 +1,22 @@
+# RT-Thread building script for Rust examples
+
+import os
+from building import *
+
+Import('rtconfig')
+
+cwd    = GetCurrentDir()
+group  = []
+entries = os.listdir(cwd)
+
+subdirs = ['application', 'component', 'modules']
+
+for subdir in subdirs:
+    if subdir in entries:
+        result = SConscript(os.path.join(subdir, 'SConscript'))
+        if isinstance(result, (list, tuple)):
+            group.extend(result)
+        else:
+            group.append(result)
+
+Return('group')

components/rust/examples/application/SConscript

@@ -0,0 +1,70 @@
+import os
+import sys
+from building import *
+
+cwd = GetCurrentDir()
+
+# Import usrapp build module and build support
+sys.path.append(os.path.join(cwd, '../../tools'))
+from build_usrapp import build_example_usrapp
+from build_support import clean_rust_build
+
+
+def _has(sym: str) -> bool:
+    try:
+        return bool(GetDepend([sym]))
+    except Exception:
+        return bool(GetDepend(sym))
+
+
+def load_extended_feature_configs():
+    """
+    Load extended feature configurations if available.
+    This allows users to add custom configuration mappings.
+    """
+    try:
+        from feature_config_examples import setup_all_example_features
+        setup_all_example_features()
+        print("Extended feature configurations loaded successfully.")
+    except ImportError:
+        print("Using default feature configurations.")
+
+group = []
+
+if not _has('RT_RUST_BUILD_APPLICATIONS'):
+    Return('group')
+
+# Load extended feature configurations
+load_extended_feature_configs()
+
+src = []
+LIBS = []
+LIBPATH = []
+LINKFLAGS = ""
+
+if GetOption('clean'):
+    app_build_dir = clean_rust_build(Dir('#').abspath, "example_usrapp")
+    if os.path.exists(app_build_dir):
+        print(f'Registering {app_build_dir} for cleanup')
+        Clean('.', app_build_dir)
+    else:
+        print('No example_usrapp build artifacts to clean')
+else:
+    import rtconfig
+    LIBS, LIBPATH, LINKFLAGS = build_example_usrapp(
+        cwd=cwd,
+        has_func=_has,
+        rtconfig=rtconfig,
+        build_root=os.path.join(Dir('#').abspath, "build", "example_usrapp")
+    )
+
+group = DefineGroup(
+    'example_usrapp', 
+    src, 
+    depend=['RT_USING_RUST'], 
+    LIBS=LIBS, 
+    LIBPATH=LIBPATH, 
+    LINKFLAGS=LINKFLAGS
+)
+
+Return('group')

components/rust/examples/application/fs/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "em_fs"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+name = "em_fs"
+crate-type = ["staticlib"]
+
+[features]
+default = []
+enable-log = ["em_component_log/enable-log"]
+
+[dependencies]
+rt-rust = { path = "../../../core" }
+rt_macros = { path = "../../../rt_macros" }
+em_component_log = { path = "../../component/log"}

components/rust/examples/application/fs/src/lib.rs

@@ -0,0 +1,73 @@
+
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       notes
+ * 2025-10-20     foxglove     Rust file operation test.
+ * 2025-10-29     foxglove     Updated to demonstrate new modular macro interface
+ */
+#![no_std]
+
+extern crate alloc;
+
+use rt_macros::msh_cmd_export;
+use rt_rust::{fs, println};
+use rt_rust::param::Param;
+use em_component_log::{info, error};
+
+#[msh_cmd_export(name = "rust_file_demo", desc = "Rust example app.")]
+fn main(_param: Param) {
+    println!("[rust_file_test] start");
+
+    let mut file = match fs::OpenOptions::new()
+        .read(true)
+        .write(true)
+        .create(true)
+        .append(false)
+        .truncate(true)
+        .open("test.txt")
+    {
+        Ok(f) => {
+            info!("open test.txt ok");
+            f
+        }
+        Err(e) => {
+            error!("open error: {:?}", e);
+            return;
+        }
+    };
+
+    if let Err(e) = file.write_all("Hello from FS wrapper!\n") {
+        error!("write_all error: {:?}", e);
+        return;
+    }
+    info!("write_all done");
+
+    if let Err(e) = file.flush() {
+        error!("flush error: {:?}", e);
+    } else {
+        info!("flush ok");
+    }
+
+    match file.read_to_string() {
+        Ok(s) => info!("read_back: {}", s),
+        Err(e) => error!("read_to_string error: {:?}", e),
+    }
+
+    if let Err(e) = file.set_len(5) {
+        error!("truncate error: {:?}", e);
+    } else {
+        info!("truncate to 5 ok");
+    }
+
+    if let Err(e) = file.close() {
+        error!("close error: {:?}", e);
+    } else {
+        info!("close ok");
+    }
+
+    info!("[rust_file_test] end");
+}

components/rust/examples/application/loadlib/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "em_loadlib"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+name = "em_loadlib"
+crate-type = ["staticlib"]
+
+[dependencies]
+rt-rust = { path = "../../../core" }
+rt_macros = { path = "../../../rt_macros" }

components/rust/examples/application/loadlib/src/lib.rs

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       notes
+ * 2025-10-10     foxglove     load library example
+ * 2025-10-29     foxglove     Updated to demonstrate new modular macro interface
+ */
+#![no_std]
+
+extern crate alloc;
+
+use rt_macros::msh_cmd_export;
+use rt_rust::println;
+use rt_rust::get_libfn;
+use core::ffi::{c_int, c_char};
+use rt_rust::param::Param;
+
+#[msh_cmd_export(name = "rust_dl_demo", desc = "Rust dynamic library demo")]
+fn main(_param: Param) {
+    println!("\n=== Dynamic Library Demo ===");
+
+    get_libfn!("/hello.mo", "main", my_hello, ());
+    my_hello();
+
+    get_libfn!("/libmylib.mo", "rust_mylib_add", my_add, c_int, a: c_int, b: c_int);
+    let s = my_add(15, 20);
+    println!("my_add(15, 20) = {}", s);
+
+    get_libfn!("/libmylib.mo", "rust_mylib_println", my_println, (), s: *const c_char);
+    my_println(b"rustlib: Hello World\0".as_ptr() as *const c_char);
+}

components/rust/examples/application/mutex/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "em_mutex"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+name = "em_mutex"
+crate-type = ["staticlib"]
+
+[dependencies]
+rt-rust = { path = "../../../core" }
+rt_macros = { path = "../../../rt_macros" }

components/rust/examples/application/mutex/src/lib.rs

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       notes
+ * 2025-10-10     foxglove     mutex test demo
+ * 2025-10-29     foxglove     Updated to demonstrate new modular macro interface
+ */
+#![no_std]
+
+extern crate alloc;
+
+use alloc::sync::Arc;
+use core::time::Duration;
+use rt_macros::msh_cmd_export;
+use rt_rust::mutex::Mutex;
+use rt_rust::param::Param;
+use rt_rust::println;
+use rt_rust::thread;
+use rt_rust::time;
+
+#[msh_cmd_export(name = "rust_mutex_demo", desc = "Rust example app.")]
+fn main(_param: Param) {
+    let counter = Arc::new(Mutex::new(0).unwrap());
+    let run = move || loop {
+        time::sleep(Duration::new(2, 0));
+        {
+            let mut c = counter.lock().unwrap();
+            *c += 1;
+            println!("{}", *c);
+        }
+    };
+
+    let _ = thread::Thread::new()
+        .name("thread 1")
+        .stack_size(2048)
+        .start(run.clone());
+    time::sleep(Duration::new(1, 0));
+    let _ = thread::Thread::new()
+        .name("thread 2")
+        .stack_size(2048)
+        .start(run.clone());
+}

components/rust/examples/application/param/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "em_param"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+name = "em_param"
+crate-type = ["staticlib"]
+
+[dependencies]
+rt-rust = { path = "../../../core" }
+rt_macros = { path = "../../../rt_macros" }
+

components/rust/examples/application/param/src/lib.rs

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       notes
+ * 2025-10-10     foxglove     param test demo
+ * 2025-10-29     foxglove     Updated to demonstrate new modular macro interface
+ */
+#![no_std]
+
+extern crate alloc;
+
+use alloc::string::String;
+use rt_macros::{rt_app_export, msh_cmd_export};
+use rt_rust::param::Param;
+use rt_rust::println;
+
+// 演示新的模块化宏接口 - 使用 msh_cmd_export 导出参数测试命令
+#[msh_cmd_export(name = "rust_param_demo", desc = "Rust parameter demo")]
+fn main(param: Param) {
+    for i in param {
+        println!("{}", String::from_utf8_lossy(&*i))
+    }
+}

components/rust/examples/application/queue/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "em_queue"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+name = "em_queue"
+crate-type = ["staticlib"]
+
+[dependencies]
+rt-rust = { path = "../../../core" }
+rt_macros = { path = "../../../rt_macros" }

components/rust/examples/application/queue/src/lib.rs

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       notes
+ * 2025-10-10     foxglove     queue test demo
+ * 2025-10-29     foxglove     Updated to demonstrate new modular macro interface
+ */
+#![no_std]
+
+extern crate alloc;
+
+use alloc::string::String;
+use alloc::sync::Arc;
+use core::time::Duration;
+use rt_macros::msh_cmd_export;
+use rt_rust::queue::Queue;
+use rt_rust::param::Param;
+use rt_rust::println;
+use rt_rust::thread;
+use rt_rust::time;
+
+#[msh_cmd_export(name = "rust_queue_demo", desc = "Rust example app.")]
+fn main(_param: Param) {
+    let send = Arc::new(Queue::new(2).unwrap());
+    let recv = send.clone();
+
+    let _ = thread::Thread::new()
+        .name("thread 1")
+        .stack_size(1024)
+        .start(move || {
+            loop {
+                time::sleep(Duration::new(1, 0));
+                send.send(String::from("msg"), 0).unwrap();
+            }
+        });
+    time::sleep(Duration::new(1, 0));
+    let _ = thread::Thread::new()
+        .name("thread 2")
+        .stack_size(1024)
+        .start(move || {
+            loop {
+                println!("waiting!");
+                let a = recv.recv_wait_forever().unwrap();
+                println!("recv {}", a);
+            }
+        });
+}
+

components/rust/examples/application/semaphore/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "em_sem"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+name = "em_sem"
+crate-type = ["staticlib"]
+
+[dependencies]
+rt-rust = { path = "../../../core" }
+rt_macros = { path = "../../../rt_macros" }

components/rust/examples/application/semaphore/src/lib.rs

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       notes
+ * 2025-10-10     foxglove     semaphore test demo
+ * 2025-10-29     foxglove     Updated to demonstrate new modular macro interface
+ */
+#![no_std]
+
+extern crate alloc;
+
+use alloc::sync::Arc;
+use core::time::Duration;
+use rt_macros::msh_cmd_export;
+use rt_rust::sem::Semaphore;
+use rt_rust::param::Param;
+use rt_rust::println;
+use rt_rust::thread;
+use rt_rust::time;
+
+#[msh_cmd_export(name = "rust_sem_demo", desc = "Rust example app.")]
+fn main(_param: Param) {
+    let send = Arc::new(Semaphore::new().unwrap());
+    let recv = send.clone();
+
+    let _ = thread::Thread::new()
+        .name("thread 1")
+        .stack_size(1024)
+        .start(move || {
+            loop {
+                time::sleep(Duration::new(1, 0));
+                send.release()
+            }
+        });
+    time::sleep(Duration::new(1, 0));
+    let _ = thread::Thread::new()
+        .name("thread 2")
+        .stack_size(1024)
+        .start(move || {
+            loop {
+                println!("waiting!");
+                recv.take_wait_forever().unwrap();
+                println!("recv a sem!")
+            }
+        });
+}
+

components/rust/examples/application/thread/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "em_thread"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+name = "em_thread"
+crate-type = ["staticlib"]
+
+[dependencies]
+rt-rust = { path = "../../../core" }
+rt_macros = { path = "../../../rt_macros" }

components/rust/examples/application/thread/src/lib.rs

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       notes
+ * 2025-10-10     foxglove     thread test demo
+ * 2025-10-29     foxglove     Updated to demonstrate new modular macro interface
+ */
+#![no_std]
+
+use core::time::Duration;
+use rt_macros::msh_cmd_export;
+use rt_rust::param::Param;
+use rt_rust::println;
+use rt_rust::thread;
+use rt_rust::time;
+
+#[msh_cmd_export(name = "rust_thread_demo", desc = "Rust example app.")]
+fn main(_param: Param) {
+    let _ = thread::Thread::new()
+        .name("thread 1")
+        .stack_size(1024)
+        .start(move || {
+            loop {
+                println!("thread a will sleep 1s");
+                time::sleep(Duration::new(1, 0));
+            }
+        });
+
+    let _ = thread::Thread::new()
+        .name("thread 2")
+        .stack_size(1024)
+        .start(move || {
+            loop {
+                println!("thread b will sleep 3s");
+                time::sleep(Duration::new(3, 0));
+            }
+        });
+}

components/rust/examples/component/SConscript

@@ -0,0 +1,71 @@
+import os
+import sys
+from building import *
+
+cwd = GetCurrentDir()
+
+# Import component build module and build support
+sys.path.append(os.path.join(cwd, '../../tools'))
+from build_component import build_example_component
+from build_support import clean_rust_build
+
+# Load feature configurations
+try:
+    from feature_config_component import setup_all_component_features
+    setup_all_component_features()
+except ImportError:
+    print("Warning: Could not load component feature configurations")
+
+
+def _has(sym: str) -> bool:
+    """Helper function to check if a configuration symbol is enabled."""
+    try:
+        return bool(GetDepend([sym]))
+    except Exception:
+        return bool(GetDepend(sym))
+
+
+# Early return if Rust or log component is not enabled
+if not _has('RT_USING_RUST'):
+    group = []
+    Return('group')
+
+if not _has('RUST_LOG_COMPONENT'):
+    group = []
+    Return('group')
+
+# Source files – component glue code if needed
+src = []
+LIBS = []
+LIBPATH = []
+LINKFLAGS = ""
+
+# Handle clean operation
+if GetOption('clean'):
+    comp_build_dir = clean_rust_build(Dir('#').abspath, "example_component")
+    if os.path.exists(comp_build_dir):
+        print(f'Registering {comp_build_dir} for cleanup')
+        Clean('.', comp_build_dir)
+    else:
+        print('No example_component build artifacts to clean')
+else:
+    # Build the component using the extracted build module
+    import rtconfig
+    LIBS, LIBPATH, LINKFLAGS = build_example_component(
+        cwd=cwd,
+        has_func=_has,
+        rtconfig=rtconfig,
+        build_root=os.path.join(Dir('#').abspath, "build", "example_component")
+    )
+
+# Define component group for SCons
+group = DefineGroup(
+    'example_component_log', 
+    src, 
+    depend=['RT_USING_RUST'], 
+    LIBS=LIBS, 
+    LIBPATH=LIBPATH, 
+    LINKFLAGS=LINKFLAGS
+)
+
+Return('group')

components/rust/examples/component/component_registry/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "em_component_registry"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+name = "em_component_registry"
+crate-type = ["staticlib"]
+
+[dependencies]
+rt-rust = { path = "../../../core" }
+rt_macros = { path = "../../../rt_macros" }
+
+# Optional dependencies - only included when features are enabled
+em_component_log = { path = "../log", optional = true }
+
+[features]
+default = []
+enable-log = ["em_component_log", "em_component_log/enable-log"]

components/rust/examples/component/component_registry/src/lib.rs

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       notes
+ * 2025-10-25     foxglove     Component registry for unified component registration
+ * 2025-10-29     foxglove     Updated to demonstrate new modular macro interface
+ */
+#![no_std]
+
+extern crate alloc;
+
+/* Demonstrate the new modular macro interface */
+use rt_macros::rt_component_export;
+use rt_rust::param::{Param, ParamItem};
+use rt_rust::println;
+
+/* Re-export component functionality for other modules */
+#[cfg(feature = "enable-log")]
+pub use em_component_log::*;
+#[cfg(feature = "enable-log")]
+use em_component_log::logging::Level;
+
+/** Unified component registration entrypoint */
+#[cfg(feature = "enable-log")]
+#[rt_component_export(name = "rust_component_registry")]
+fn init_registry_component() {
+    println!("[logging component init] hello world");
+    log!(Level::Info, "hello world");
+    info!("hello world");
+    warn!("hello world");
+    error!("hello world");
+    trace!("hello world");
+    debug!("hello world");
+}
+
+/** Provide a no-op implementation when no component feature is enabled */
+#[cfg(not(feature = "enable-log"))]
+pub extern "C" fn component_init() {
+    /* Empty implementation to ensure the library still links */
+}

components/rust/examples/component/log/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "em_component_log"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+name = "em_component_log"
+crate-type = ["rlib", "staticlib"]
+
+[features]
+default = []
+enable-log = []
+
+[dependencies]
+rt-rust = { path = "../../../core" }

components/rust/examples/component/log/src/lib.rs

@@ -0,0 +1,30 @@
+
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       notes
+ * 2025-10-23     foxglove     log component demo
+ */
+#![no_std]
+
+extern crate alloc;
+
+/* When the `enable-log` feature is enabled, expose logging module and helpers */
+#[cfg(feature = "enable-log")]
+pub mod logging;
+#[cfg(feature = "enable-log")]
+use rt_rust::println;
+#[cfg(feature = "enable-log")]
+use crate::logging::Level;
+
+/* Import panic handler parameters from rt_rust library */
+use rt_rust::param::{Param, ParamItem};
+
+/* Provide a no-op implementation when the `enable-log` feature is disabled */
+#[cfg(not(feature = "enable-log"))]
+pub extern "C" fn component_init() {
+    /* Empty implementation to ensure the library still links */
+}

components/rust/examples/component/log/src/logging.rs

@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2006-2024, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       notes
+ * 2025-10-20     foxglove     micro rust log component
+ */
+/* Basic logging primitives and console output helpers */
+use alloc::string::String;
+use rt_rust::println;
+
+#[repr(usize)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum Level {
+    Error = 1,
+    Warn = 2,
+    Info = 3,
+    Debug = 4,
+    Trace = 5,
+}
+
+/* Top-level logging macro */
+#[macro_export]
+macro_rules! log {
+    ($level:expr, $($arg:tt)*) => ({
+        $crate::logging::_log($level, format_args!($($arg)*));
+    });
+}
+
+/* Error-level logging */
+#[macro_export]
+macro_rules! error {
+    ($($arg:tt)*) => ({
+        $crate::logging::_log($crate::logging::Level::Error, format_args!($($arg)*));
+    });
+}
+
+/* Warning-level logging */
+#[macro_export]
+macro_rules! warn {
+    ($($arg:tt)*) => ({
+        $crate::logging::_log($crate::logging::Level::Warn, format_args!($($arg)*));
+    });
+}
+
+/* Info-level logging */
+#[macro_export]
+macro_rules! info {
+    ($($arg:tt)*) => ({
+        $crate::logging::_log($crate::logging::Level::Info, format_args!($($arg)*));
+    });
+}
+
+/* Debug-level logging */
+#[macro_export]
+macro_rules! debug {
+    ($($arg:tt)*) => ({
+        $crate::logging::_log($crate::logging::Level::Debug, format_args!($($arg)*));
+    });
+}
+
+/* Trace-level logging */
+#[macro_export]
+macro_rules! trace {
+    ($($arg:tt)*) => ({
+        $crate::logging::_log($crate::logging::Level::Trace, format_args!($($arg)*));
+    });
+}
+
+/* Internal logging handler: formats message and prints with color */
+pub fn _log(level: Level, args: core::fmt::Arguments) {
+    use core::fmt::Write;
+    use rt_rust::time;
+    let mut s = String::new();
+    write!(&mut s, "[{:?}][{:?}]", level, time::get_time()).unwrap();
+    write!(&mut s, "{}", args).unwrap();
+    match level {
+        Level::Error => {
+            println!("\x1b[1;31m{}\x1b[0m", s);
+        }
+        Level::Warn => {
+            println!("\x1b[1;33m{}\x1b[0m", s);
+        }
+        Level::Info => {
+            println!("\x1b[1;32m{}\x1b[0m", s);
+        }
+        Level::Debug => {
+            println!("\x1b[1;34m{}\x1b[0m", s);
+        }
+        Level::Trace => {
+            println!("\x1b[1;30m{}\x1b[0m", s);
+        }
+    }
+}

components/rust/examples/modules/SConscript

@@ -0,0 +1,159 @@
+import os
+import sys
+import subprocess
+import toml
+from building import *
+
+cwd = GetCurrentDir()
+
+RUSTC_FLAGS = {
+    "linker": "-C linker=ld.lld",
+    "panic": "-C panic=abort",
+}
+
+CARGO_CMD = {
+    "base": "cargo build",
+    "build_std": "-Z build-std=core,alloc,panic_abort",
+    "target_flag": "--target",
+    "target_arch": "%s",  
+    "release_profile": "--release",
+    "debug_profile": "",  # No additional flag for debug mode
+}
+
+tools_dir = os.path.join(cwd, '..', '..', 'tools')
+sys.path.insert(0, tools_dir)
+
+from build_support import detect_rust_target, ensure_rust_target_installed, clean_rust_build
+
+def _has(sym: str) -> bool:
+    """Helper function to check if a configuration symbol is enabled"""
+    try:
+        return bool(GetDepend([sym]))
+    except Exception:
+        return bool(GetDepend(sym))
+
+def detect_target_for_dynamic_modules():
+    """
+    Detect the appropriate Rust target for dynamic modules.
+    For dynamic modules, we need Linux targets instead of bare-metal targets.
+    """
+    if detect_rust_target is not None:
+        try:
+            import rtconfig
+            bare_metal_target = detect_rust_target(_has, rtconfig)
+            
+            if bare_metal_target:
+                if "riscv64" in bare_metal_target:
+                    return "riscv64gc-unknown-linux-gnu"
+                elif "riscv32" in bare_metal_target:
+                    return "riscv32gc-unknown-linux-gnu"
+                elif "aarch64" in bare_metal_target:
+                    return "aarch64-unknown-linux-gnu"
+                elif "arm" in bare_metal_target or "thumb" in bare_metal_target:
+                    return "armv7-unknown-linux-gnueabihf"
+        except Exception as e:
+            print(f"Error: Target detection failed: {e}")
+            raise RuntimeError(f"Failed to detect Rust target for dynamic modules: {e}")
+    
+    print("Error: Unable to detect appropriate Rust target for dynamic modules")
+    raise RuntimeError("Target detection failed - no valid target found")
+
+def build_rust_module(module_dir, build_root):
+    """Build a Rust dynamic module with automatic target detection"""
+    cargo_toml_path = os.path.join(module_dir, 'Cargo.toml')
+    if not os.path.exists(cargo_toml_path):
+        return [], [], ""
+    
+    with open(cargo_toml_path, 'r') as f:
+        cargo_config = toml.load(f)
+    
+    module_name = cargo_config['package']['name']
+    
+    # Detect target automatically based on the current configuration
+    target = detect_target_for_dynamic_modules()
+    print(f"Building Rust module '{module_name}' for target: {target}")
+    
+    # Detect debug mode from rtconfig (same as main rust/SConscript)
+    debug = bool(_has('RUST_DEBUG_BUILD'))
+    build_mode = "debug" if debug else "release"
+    print(f"Building in {build_mode} mode")
+    
+    # Use global RUSTFLAGS configuration for dynamic modules
+    rustflags = " ".join(RUSTC_FLAGS.values())
+    
+    # Verify that the target is installed
+    if ensure_rust_target_installed is not None:
+        if not ensure_rust_target_installed(target):
+            print(f"Error: Rust target '{target}' is not installed")
+            print(f"Please install it with: rustup target add {target}")
+            return [], [], ""
+    else:
+        print(f"Warning: Cannot verify if target '{target}' is installed")
+    
+    # Set up build environment
+    env = os.environ.copy()
+    env['RUSTFLAGS'] = rustflags
+    env['CARGO_TARGET_DIR'] = build_root
+    
+    # Build the module with configurable parameters using dictionary configuration
+    build_cmd = [
+        CARGO_CMD["base"].split()[0],  # 'cargo'
+        CARGO_CMD["base"].split()[1],  # 'build'
+        CARGO_CMD["target_flag"],      # '--target'
+        target,                        # actual target architecture
+    ]
+    
+    # Add profile flag based on debug mode
+    profile_flag = CARGO_CMD["debug_profile"] if debug else CARGO_CMD["release_profile"]
+    if profile_flag:
+        build_cmd.append(profile_flag)
+    
+    # Add build-std flag if specified
+    if CARGO_CMD["build_std"]:
+        build_std_parts = CARGO_CMD["build_std"].split()
+        build_cmd.extend(build_std_parts)  
+    
+    try:
+        subprocess.run(build_cmd, cwd=module_dir, env=env, check=True, capture_output=True)
+        lib_dir = os.path.join(build_root, target, build_mode)
+        return [module_name], [lib_dir], ""
+    except subprocess.CalledProcessError:
+        return [], [], ""
+
+# Check dependencies
+if not _has('RT_RUST_BUILD_MODULES'):
+    Return([])
+
+build_root = os.path.join(Dir('#').abspath, "build", "rust_modules")
+
+# Handle clean operation
+if GetOption('clean'):
+    if clean_rust_build is not None:
+        modules_build_dir = clean_rust_build(Dir('#').abspath, "rust_modules")
+        if os.path.exists(modules_build_dir):
+            print(f'Registering {modules_build_dir} for cleanup')
+            Clean('.', modules_build_dir)
+        else:
+            print('No rust_modules build artifacts to clean')
+    else:
+        print('Warning: clean_rust_build function not available')
+else:
+    # Build all Rust modules in subdirectories
+    modules_built = []
+    for item in os.listdir(cwd):
+        item_path = os.path.join(cwd, item)
+        if os.path.isdir(item_path) and os.path.exists(os.path.join(item_path, 'Cargo.toml')):
+            result = build_rust_module(item_path, build_root)
+            if result[0]:
+                modules_built.extend(result[0])
+
+    if modules_built:
+        print(f"Successfully built {len(modules_built)} Rust dynamic module(s): {', '.join(modules_built)}")
+
+group = DefineGroup(
+    'rust_modules', 
+    [], 
+    depend=['RT_RUST_BUILD_MODULES']
+)
+
+Return('group')

components/rust/examples/modules/example_lib/.gitignore

@@ -0,0 +1,37 @@
+# Rust build artifacts (now in build/rust)
+/target/
+**/*.rs.bk
+*.pdb
+
+# Cargo lock file (optional - uncomment if you want to exclude it)
+# Cargo.lock
+
+# Build directories
+/build/
+*.o
+*.a
+*.so
+*.dylib
+*.dll
+
+# IDE specific files
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# Debug files
+*.dSYM/
+*.su
+*.idb
+*.pdb
+
+# Backup files
+*.bak
+*.tmp
+*.temp
+
+# Log files
+*.log

components/rust/examples/modules/example_lib/Cargo.toml

@@ -0,0 +1,12 @@
+[workspace]
+
+[package]
+name = "examplelib"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+rt-rust = { path = "../../.." }

components/rust/examples/modules/example_lib/src/lib.rs

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2006-2024, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       notes
+ * 2025-10-10     foxglove     Basic library module template
+ */
+#![no_std]
+/* Bring rt-rust's println! macro into scope */ 
+use rt_rust::println;
+use core::ffi::{c_char, CStr};
+#[unsafe(no_mangle)]
+pub extern "C" fn rust_mylib_println(s: *const c_char) {
+    if s.is_null() {
+        println!("");
+    } else {
+            let cs = unsafe {CStr::from_ptr(s)};
+            match cs.to_str() {
+                Ok(msg) => println!("{}", msg),
+                Err(_) => println!("[invalid UTF-8]"),
+            }
+    }
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn rust_mylib_add(a: usize, b: usize) -> usize {
+    a + b
+}

components/rust/rt_macros/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "rt_macros"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+proc_macro = true
+
+[dependencies]
+quote = "1.0"
+proc-macro2 = "1.0"
+darling = "0.13.0"
+
+[dependencies.syn]
+version = "1.0"
+features = ["extra-traits", "full"]

components/rust/rt_macros/src/lib.rs

@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       notes
+ * 2025-10-29   foxglove     Modular macro library for RT-Thread Rust
+ */
+
+/*! RT-Thread Rust Macro Library
+
+This library provides Rust macros for RT-Thread system, including:
+
+- `rt_thread_main!` - Main thread entry macro
+- `rt_component_export!` - Component export macro
+- `rt_app_export!` - Application export macro
+- `msh_cmd_export!` - Shell command export macro
+
+## Usage Examples
+
+### Main Thread Entry
+```rust
+use rt_macros::rt_thread_main;
+
+#[rt_thread_main]
+fn main() {
+    println!("Hello RT-Thread!");
+}
+```
+
+### Component Export
+```rust
+use rt_macros::rt_component_export;
+
+#[rt_component_export]
+fn my_component_init() {
+    // Component initialization code
+}
+```
+
+### Application Export
+```rust
+use rt_macros::rt_app_export;
+
+#[rt_app_export]
+fn my_app_init() {
+    // Application initialization code
+}
+```
+
+### Shell Command Export
+```rust
+use rt_macros::msh_cmd_export;
+
+#[msh_cmd_export(name = "hello", desc = "Say hello")]
+fn hello_cmd(args: vec::IntoIter<rt_rust::param::ParamItem>) {
+    println!("Hello from shell command!");
+}
+```
+*/
+
+#[macro_use]
+extern crate quote;
+
+use proc_macro::TokenStream;
+
+/* Import modular macro definitions */
+mod macros;
+
+/* Modular macro definitions */
+/* RT-Thread main thread entry macro */
+#[proc_macro_attribute]
+pub fn rt_thread_main(args: TokenStream, input: TokenStream) -> TokenStream {
+    macros::main::rt_thread_main(args, input)
+}
+
+/* RT-Thread component export macro */
+#[proc_macro_attribute]
+pub fn rt_component_export(args: TokenStream, input: TokenStream) -> TokenStream {
+    macros::component::rt_component_export(args, input)
+}
+
+/* RT-Thread application export macro */
+#[proc_macro_attribute]
+pub fn rt_app_export(args: TokenStream, input: TokenStream) -> TokenStream {
+    macros::app::rt_app_export(args, input)
+}
+
+/* MSH command export macro */
+#[proc_macro_attribute]
+pub fn msh_cmd_export(args: TokenStream, input: TokenStream) -> TokenStream {
+    macros::cmd::msh_cmd_export(args, input)
+}

components/rust/rt_macros/src/macros/app.rs

@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       notes
+ * 2025-10-29     foxglove     Application export macro module
+ */
+
+use darling::FromMeta;
+use proc_macro::TokenStream;
+use proc_macro2::Span;
+use syn::{parse_macro_input, spanned::Spanned, ReturnType, Visibility, Meta};
+use syn::parse::Parser;
+use syn::NestedMeta as DarlingNestedMeta;
+
+#[derive(Debug, FromMeta)]
+struct AppArgs {
+    #[darling(default)]
+    name: Option<String>,
+}
+
+/** RT-Thread application export macro
+ 
+ Used to export a function as an RT-Thread application initialization entry
+ 
+ Usage:
+ ```rust
+ #[rt_app_export]
+ fn my_app_init() {
+     // Application initialization logic
+ }
+ ```
+ 
+ Or specify a name:
+ ```rust
+ #[rt_app_export(name = "my_app")]
+ fn my_app_init() {
+     // Application initialization logic
+ }
+ ```
+*/
+pub fn rt_app_export(args: TokenStream, input: TokenStream) -> TokenStream {
+    let f = parse_macro_input!(input as syn::ItemFn);
+    let parser = syn::punctuated::Punctuated::<Meta, syn::token::Comma>::parse_terminated;
+    let raw_meta = match parser.parse(args) {
+        Ok(v) => v,
+        Err(e) => return e.to_compile_error().into(),
+    };
+    let raw_arg: Vec<DarlingNestedMeta> = raw_meta
+        .into_iter()
+        .map(DarlingNestedMeta::Meta)
+        .collect();
+    let parg = AppArgs::from_list(&raw_arg).map_err(|e| e.write_errors());
+    let arg = match parg {
+        Ok(x) => x,
+        Err(e) => {
+            return e.into();
+        }
+    };
+
+    if arg.name.is_none() {
+        return syn::parse::Error::new(
+            Span::call_site(),
+            "`#[rt_app_export]` macro must have attribute `name`",
+        )
+        .to_compile_error()
+        .into();
+    }
+
+    let app_seg_name = format_ident!("__{}_app_seg", arg.name.as_ref().unwrap());
+    let app_func_name = format_ident!("__{}_app_func", arg.name.as_ref().unwrap());
+    let app_struct_name = format_ident!("__{}_app_seg_struct", arg.name.as_ref().unwrap());
+    let mod_name = format_ident!("__app_func_{}_", arg.name.as_ref().unwrap());
+    let call_func_name = f.sig.ident.clone();
+
+    /* Check function signature */  
+    let valid_signature = f.sig.constness.is_none()
+        && f.sig.unsafety.is_none()
+        && f.sig.asyncness.is_none()
+        && f.vis == Visibility::Inherited
+        && f.sig.abi.is_none()
+        && f.sig.inputs.is_empty()
+        && f.sig.generics.params.is_empty()
+        && f.sig.generics.where_clause.is_none()
+        && f.sig.variadic.is_none()
+        && match f.sig.output {
+            ReturnType::Default => true,
+            _ => false,
+        };
+
+    if !valid_signature {
+        return syn::parse::Error::new(
+            f.span(),
+            "`#[rt_app_export]` function must have signature `fn()`",
+        )
+        .to_compile_error()
+        .into();
+    }
+
+    let attrs = f.attrs.clone();
+
+    let origin = quote!(
+        #(#attrs)*
+        #f
+    );
+
+    let app_seg = quote!(
+        struct #app_struct_name (*const ());
+        unsafe impl Sync for #app_struct_name{}
+
+        #[no_mangle]
+        pub unsafe extern "C" fn #app_func_name() -> i32 {
+            #call_func_name();
+            0
+        }
+
+        #[link_section = ".rti_fn.6"]
+        #[no_mangle]
+        static #app_seg_name: #app_struct_name
+            = #app_struct_name (#app_func_name as *const ());
+    );
+
+    quote!(
+        #origin
+        mod #mod_name {
+            use super::#call_func_name;
+            use core::marker::Sync;
+
+            #app_seg
+        }
+    )
+    .into()
+}

components/rust/rt_macros/src/macros/cmd.rs

@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       notes
+ * 2025-10-29     foxglove     Command export macro module
+ */
+
+use darling::FromMeta;
+use proc_macro::TokenStream;
+use proc_macro2::{Literal, Span};
+use syn::{parse_macro_input, spanned::Spanned, ReturnType, Visibility, Meta};
+use syn::parse::Parser;
+use syn::NestedMeta as DarlingNestedMeta;
+
+#[derive(Debug, FromMeta)]
+struct CmdArgs {
+    #[darling(default)]
+    name: Option<String>,
+    #[darling(default)]
+    desc: Option<String>,
+}
+
+/** RT-Thread Shell command export macro
+ 
+ Used to export a function as an RT-Thread Shell command
+ 
+ Usage:
+ ```rust
+ #[msh_cmd_export(name = "my_cmd", desc = "My command description")]
+ fn my_command(args: vec::IntoIter<rt_rust::param::ParamItem>) {
+     // Command logic
+ }
+ ```
+*/
+pub fn msh_cmd_export(args: TokenStream, input: TokenStream) -> TokenStream {
+    let f = parse_macro_input!(input as syn::ItemFn);
+    let parser = syn::punctuated::Punctuated::<Meta, syn::token::Comma>::parse_terminated;
+    let raw_meta = match parser.parse(args) {
+        Ok(v) => v,
+        Err(e) => return e.to_compile_error().into(),
+    };
+    let raw_arg: Vec<DarlingNestedMeta> = raw_meta
+        .into_iter()
+        .map(DarlingNestedMeta::Meta)
+        .collect();
+    let parg = CmdArgs::from_list(&raw_arg).map_err(|e| e.write_errors());
+    let arg = match parg {
+        Ok(x) => x,
+        Err(e) => {
+            return e.into();
+        }
+    };
+
+    if arg.name.is_none() {
+        return syn::parse::Error::new(
+            Span::call_site(),
+            "`#[msh_cmd_export]` macro must have attribute `name`",
+        )
+        .to_compile_error()
+        .into();
+    }
+
+    let main_func_name = format_ident!("__{}_main_func", arg.name.as_ref().unwrap());
+    let cmd_seg_name = format_ident!("__{}_cmd_seg", arg.name.as_ref().unwrap());
+    let cmd_struct_name = format_ident!("__{}_cmd_seg_struct", arg.name.as_ref().unwrap());
+    let cmd_namestr_name = format_ident!("__{}_cmd_namestr", arg.name.as_ref().unwrap());
+    let cmd_descstr_name = format_ident!("__{}_cmd_descstr", arg.name.as_ref().unwrap());
+    let mod_name = format_ident!("__cmd_func_{}_", arg.name.as_ref().unwrap());
+    let call_func_name = f.sig.ident.clone();
+
+    /* Check function signature */
+    let valid_signature = f.sig.constness.is_none()
+        && f.sig.unsafety.is_none()
+        && f.sig.asyncness.is_none()
+        && f.vis == Visibility::Inherited
+        && f.sig.abi.is_none()
+        && f.sig.inputs.len() == 1
+        && f.sig.generics.params.is_empty()
+        && f.sig.generics.where_clause.is_none()
+        && f.sig.variadic.is_none()
+        && match f.sig.output {
+            ReturnType::Default => true,
+            _ => false,
+        };
+
+    if !valid_signature {
+        return syn::parse::Error::new(
+            f.span(),
+            "`#[msh_cmd_export]` function must have signature `fn(args: vec::IntoIter<rt_rust::param::ParamItem>)`",
+        )
+        .to_compile_error()
+        .into();
+    }
+
+    let attrs = f.attrs.clone();
+
+    let origin = quote!(
+        #(#attrs)*
+        #f
+    );
+
+    let desc = arg.desc.map_or(String::from("No desc\0"), |mut x| {
+        x.push_str("\0");
+        x
+    });
+    let r_desc = Literal::byte_string(desc.as_bytes());
+
+    let mut cmd_name = arg.name.as_ref().unwrap().clone();
+    cmd_name.push_str("\0");
+    let r_cmd_name = Literal::byte_string(cmd_name.as_bytes());
+
+    let desc_len = desc.len();
+    let cmd_name_len = cmd_name.len();
+
+    let core = quote!(
+        #[no_mangle]
+        pub unsafe extern "C" fn #main_func_name(argc: u32, argv: *const *const u8) {
+            use core::iter::Iterator;
+            use rt_rust::param::ParamItem;
+            let vec = {
+                (0..argc as isize)
+                    .map(|i| {
+                        let mut len = 0usize;
+                        loop {
+                            if *(*argv.offset(i)).offset(len as isize) != b'\0' {
+                                len += 1;
+                            } else {
+                                break
+                            }
+                        }
+                        ParamItem::new(core::slice::from_raw_parts::<'static, _>(*argv.offset(i), len))
+                    })
+                    .collect::<Vec<_>>()
+            };
+            #call_func_name(vec.into_iter())
+        }
+    );
+
+    let cmd_seg = quote!(
+        #[link_section = ".rodata.name"]
+        #[no_mangle]
+        static #cmd_namestr_name: [u8; #cmd_name_len] = *#r_cmd_name;
+        #[link_section = ".rodata.name"]
+        #[no_mangle]
+        static #cmd_descstr_name: [u8; #desc_len] = *#r_desc;
+
+        #[repr(C)]
+        struct #cmd_struct_name {
+            name: *const u8,
+            desc: *const u8,
+            opt: *const core::ffi::c_void,
+            func: extern "C" fn(argc: u32, argv: *const *const u8) -> i32,
+        }
+        unsafe impl Sync for #cmd_struct_name{}
+
+        extern "C" fn __wrap_main(argc: u32, argv: *const *const u8) -> i32 {
+            unsafe { #main_func_name(argc, argv); }
+            0
+        }
+
+        #[link_section = "FSymTab"]
+        #[no_mangle]
+        static #cmd_seg_name: #cmd_struct_name = #cmd_struct_name {
+            name: #cmd_namestr_name.as_ptr(),
+            desc: #cmd_descstr_name.as_ptr(),
+            opt: core::ptr::null(),
+            func: __wrap_main,
+        };
+    );
+
+    quote!(
+        #origin
+        mod #mod_name {
+            use super::#call_func_name;
+            use core::marker::Sync;
+            extern crate alloc;
+            use alloc::vec::Vec;
+            use core::iter::IntoIterator;
+
+            #core
+            #cmd_seg
+        }
+    )
+    .into()
+}

components/rust/rt_macros/src/macros/component.rs

@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       notes
+ * 2025-10-29     foxglove     Component export macro module
+ */
+
+use darling::FromMeta;
+use proc_macro::TokenStream;
+use proc_macro2::Span;
+use syn::{parse_macro_input, spanned::Spanned, ReturnType, Visibility, Meta};
+use syn::parse::Parser;
+use syn::NestedMeta as DarlingNestedMeta;
+
+#[derive(Debug, FromMeta)]
+struct ComponentArgs {
+    #[darling(default)]
+    name: Option<String>,
+}
+
+/** RT-Thread component export macro
+ 
+ Used to export a function as an RT-Thread component initialization entry
+ 
+ Usage:
+ ```rust
+ #[rt_component_export]
+ fn my_component_init() {
+     // Component initialization logic
+ }
+ ```
+ 
+ Or specify a name:
+ ```rust
+ #[rt_component_export(name = "my_component")]
+ fn my_component_init() {
+     // Component initialization logic
+ }
+ ```
+*/
+pub fn rt_component_export(args: TokenStream, input: TokenStream) -> TokenStream {
+    let f = parse_macro_input!(input as syn::ItemFn);
+    let parser = syn::punctuated::Punctuated::<Meta, syn::token::Comma>::parse_terminated;
+    let raw_meta = match parser.parse(args) {
+        Ok(v) => v,
+        Err(e) => return e.to_compile_error().into(),
+    };
+    let raw_arg: Vec<DarlingNestedMeta> = raw_meta
+        .into_iter()
+        .map(DarlingNestedMeta::Meta)
+        .collect();
+    let parg = ComponentArgs::from_list(&raw_arg).map_err(|e| e.write_errors());
+    let arg = match parg {
+        Ok(x) => x,
+        Err(e) => {
+            return e.into();
+        }
+    };
+
+    if arg.name.is_none() {
+        return syn::parse::Error::new(
+            Span::call_site(),
+            "`#[rt_component_export]` macro must have attribute `name`",
+        )
+        .to_compile_error()
+        .into();
+    }
+
+    let component_seg_name = format_ident!("__{}_component_seg", arg.name.as_ref().unwrap());
+    let component_func_name = format_ident!("__{}_component_func", arg.name.as_ref().unwrap());
+    let component_struct_name = format_ident!("__{}_component_seg_struct", arg.name.as_ref().unwrap());
+    let mod_name = format_ident!("__component_func_{}_", arg.name.as_ref().unwrap());
+    let call_func_name = f.sig.ident.clone();
+
+    /* Check function signature */
+    let valid_signature = f.sig.constness.is_none()
+        && f.sig.unsafety.is_none()
+        && f.sig.asyncness.is_none()
+        && f.vis == Visibility::Inherited
+        && f.sig.abi.is_none()
+        && f.sig.inputs.is_empty()
+        && f.sig.generics.params.is_empty()
+        && f.sig.generics.where_clause.is_none()
+        && f.sig.variadic.is_none()
+        && match f.sig.output {
+            ReturnType::Default => true,
+            _ => false,
+        };
+
+    if !valid_signature {
+        return syn::parse::Error::new(
+            f.span(),
+            "`#[rt_component_export]` function must have signature `fn()`",
+        )
+        .to_compile_error()
+        .into();
+    }
+
+    let attrs = f.attrs.clone();
+
+    let origin = quote!(
+        #(#attrs)*
+        #f
+    );
+
+    let component_seg = quote!(
+        struct #component_struct_name (*const ());
+        unsafe impl Sync for #component_struct_name{}
+
+        #[no_mangle]
+        pub unsafe extern "C" fn #component_func_name() -> i32 {
+            #call_func_name();
+            0
+        }
+
+        #[link_section = ".rti_fn.4"]
+        #[no_mangle]
+        static #component_seg_name: #component_struct_name
+            = #component_struct_name (#component_func_name as *const ());
+    );
+
+    quote!(
+        #origin
+        mod #mod_name {
+            use super::#call_func_name;
+            use core::marker::Sync;
+
+            #component_seg
+        }
+    )
+    .into()
+}

components/rust/rt_macros/src/macros/main.rs

@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       notes
+ * 2025-10-29     foxglove     Main thread entry macro module
+ */
+
+use darling::FromMeta;
+use proc_macro::TokenStream;
+use proc_macro2::Span;
+use syn::{parse_macro_input, spanned::Spanned, ReturnType, Visibility, Meta};
+use syn::parse::Parser;
+use syn::NestedMeta as DarlingNestedMeta;
+
+#[derive(Debug, FromMeta)]
+struct MainArgs {
+    #[darling(default)]
+    name: Option<String>,
+}
+
+/** RT-Thread main thread entry macro
+ 
+ Used to mark the main entry function of a Rust program, exporting it as 
+ a main thread entry recognizable by RT-Thread
+ 
+ Usage:
+ ```rust
+ #[rt_thread_main]
+ fn main() {
+     // Main thread logic
+ }
+ ```
+ 
+ Or specify a name:
+ ```rust
+ #[rt_thread_main(name = "my_main")]
+ fn main() {
+     // Main thread logic
+ }
+ ```
+*/
+pub fn rt_thread_main(args: TokenStream, input: TokenStream) -> TokenStream {
+    let f = parse_macro_input!(input as syn::ItemFn);
+    let parser = syn::punctuated::Punctuated::<Meta, syn::token::Comma>::parse_terminated;
+    let raw_meta = match parser.parse(args) {
+        Ok(v) => v,
+        Err(e) => return e.to_compile_error().into(),
+    };
+    let raw_arg: Vec<DarlingNestedMeta> = raw_meta
+        .into_iter()
+        .map(DarlingNestedMeta::Meta)
+        .collect();
+    let parg = MainArgs::from_list(&raw_arg).map_err(|e| e.write_errors());
+    let arg = match parg {
+        Ok(x) => x,
+        Err(e) => {
+            return e.into();
+        }
+    };
+
+    if arg.name.is_none() {
+        return syn::parse::Error::new(
+            Span::call_site(),
+            "`#[rt_thread_main]` macro must have attribute `name`",
+        )
+        .to_compile_error()
+        .into();
+    }
+
+    let main_func_name = format_ident!("__{}_main_func", arg.name.as_ref().unwrap());
+    let mod_name = format_ident!("__init_func_{}_", arg.name.as_ref().unwrap());
+    let call_func_name = f.sig.ident.clone();
+
+    /* Check function signature */  
+    let valid_signature = f.sig.constness.is_none()
+        && f.sig.unsafety.is_none()
+        && f.sig.asyncness.is_none()
+        && f.vis == Visibility::Inherited
+        && f.sig.abi.is_none()
+        && f.sig.inputs.is_empty()
+        && f.sig.generics.params.is_empty()
+        && f.sig.generics.where_clause.is_none()
+        && f.sig.variadic.is_none()
+        && match f.sig.output {
+            ReturnType::Default => true,
+            _ => false,
+        };
+
+    if !valid_signature {
+        return syn::parse::Error::new(
+            f.span(),
+            "`#[rt_thread_main]` function must have signature `fn()`",
+        )
+        .to_compile_error()
+        .into();
+    }
+
+    let attrs = f.attrs.clone();
+
+    let origin = quote!(
+        #(#attrs)*
+        #f
+    );
+
+    let core = quote!(
+        #[no_mangle]
+        pub unsafe extern "C" fn #main_func_name(argc: u32, argv: *const *const u8) {
+            use core::iter::Iterator;
+            use rt_rust::param::ParamItem;
+            let vec = {
+                (0..argc as isize)
+                    .map(|i| {
+                        let mut len = 0usize;
+                        loop {
+                            if *(*argv.offset(i)).offset(len as isize) != b'\0' {
+                                len += 1;
+                            } else {
+                                break
+                            }
+                        }
+                        ParamItem::new(core::slice::from_raw_parts::<'static, _>(*argv.offset(i), len))
+                    })
+                    .collect::<Vec<_>>()
+            };
+            #call_func_name(vec.into_iter())
+        }
+    );
+
+    quote!(
+        #origin
+        mod #mod_name {
+            use super::#call_func_name;
+            extern crate alloc;
+            use alloc::vec::Vec;
+            use core::iter::IntoIterator;
+
+            #core
+        }
+    )
+    .into()
+}

components/rust/rt_macros/src/macros/mod.rs

@@ -0,0 +1,14 @@
+/*
+ * Copyright (c) 2006-2025, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       notes
+ * 2025-10-29     foxglove     RT-Thread Rust macro module
+ */
+
+pub mod main;
+pub mod component;
+pub mod app;
+pub mod cmd;

components/rust/tools/__init__.py

@@ -0,0 +1 @@
+# User application build tools package

components/rust/tools/build_component.py

@@ -0,0 +1,200 @@
+import os
+import subprocess
+
+
+# Configuration to feature mapping table for components
+# This table defines which RT-Thread configurations should enable which component features
+# All feature configurations are now defined in feature_config_component.py
+CONFIG_COMPONENT_FEATURE_MAP = {}
+
+
+class ComponentBuildError(Exception):
+    pass
+
+
+def check_component_dependencies(component_dir, required_dependencies):
+    """
+    Check if a component has the required dependencies
+    
+    Args:
+        component_dir: Component directory path
+        required_dependencies: List of dependency names to check
+        
+    Returns:
+        bool: True if all required dependencies are present
+    """
+    if not component_dir or not required_dependencies:
+        return True
+    
+    cargo_toml_path = os.path.join(component_dir, 'Cargo.toml')
+    if not os.path.exists(cargo_toml_path):
+        return False
+    
+    try:
+        import toml
+        with open(cargo_toml_path, 'r') as f:
+            cargo_data = toml.load(f)
+        
+        dependencies = cargo_data.get('dependencies', {})
+        
+        # Check if all required dependencies are present
+        for dep in required_dependencies:
+            if dep not in dependencies:
+                return False
+        
+        return True
+        
+    except Exception as e:
+        print(f"Warning: Failed to parse {cargo_toml_path}: {e}")
+        return False
+
+
+def collect_component_features(has_func, component_dir=None):
+    """
+    Collect component features based on RT-Thread configuration using extensible mapping table
+    
+    Args:
+        has_func: Function to check if a configuration is enabled
+        component_dir: Component directory to check dependencies (optional)
+        
+    Returns:
+        list: List of features to enable
+    """
+    features = []
+    
+    # Iterate through all configured mappings
+    for config_name, config_info in CONFIG_COMPONENT_FEATURE_MAP.items():
+        # Check if this RT-Thread configuration is enabled
+        if has_func(config_name):
+            feature_name = config_info['feature']
+            required_deps = config_info.get('dependencies', [])
+            
+            # If component_dir is provided, check dependencies
+            if component_dir:
+                if check_component_dependencies(component_dir, required_deps):
+                    features.append(feature_name)
+                    print(f"Enabling component feature '{feature_name}' for {config_name} in {os.path.basename(component_dir)}")
+            else:
+                # If no component_dir provided, enable for all (backward compatibility)
+                features.append(feature_name)
+                print(f"Enabling component feature '{feature_name}' for {config_name}")
+    
+    return features
+
+def cargo_build_component_staticlib(rust_dir, target, features, debug, rustflags=None, build_root=None):
+    """
+    Build a Rust component as a static library using Cargo.
+    
+    Args:
+        rust_dir: Directory containing the Rust component
+        target: Rust target architecture
+        features: List of features to enable
+        debug: Whether this is a debug build
+        rustflags: Additional Rust compilation flags
+        build_root: Build root directory (if not provided, will raise error)
+        
+    Returns:
+        str: Path to the built library file, or None if build failed
+    """
+    if not build_root:
+        raise ComponentBuildError("build_root parameter is required")
+    
+    build_root = os.path.abspath(build_root)
+    os.makedirs(build_root, exist_ok=True)
+
+    env = os.environ.copy()
+    if rustflags:
+        prev = env.get("RUSTFLAGS", "").strip()
+        env["RUSTFLAGS"] = (prev + " " + rustflags).strip() if prev else rustflags
+    env["CARGO_TARGET_DIR"] = build_root
+
+    cmd = [
+        "cargo", "build", 
+        "--target", target, 
+        "--manifest-path", os.path.join(rust_dir, "Cargo.toml")
+    ]
+    
+    if not debug:
+        cmd.insert(2, "--release")
+    
+    if features:
+        cmd += ["--no-default-features", "--features", ",".join(features)]
+
+    print("Building example component log (cargo)…")
+    res = subprocess.run(cmd, cwd=rust_dir, env=env, capture_output=True, text=True)
+    
+    if res.returncode != 0:
+        print("Warning: Example component build failed")
+        if res.stderr:
+            print(res.stderr)
+        return None
+
+    mode = "debug" if debug else "release"
+    
+    # Try target-specific path first, then fallback to direct path
+    lib_path = os.path.join(build_root, target, mode, "libem_component_registry.a")
+    if os.path.exists(lib_path):
+        print("Example component log built successfully")
+        return lib_path
+    
+    print("Warning: Library not found at expected location")
+    print(f"Expected: {lib_path}")
+    return None
+
+
+def build_example_component(cwd, has_func, rtconfig, build_root=None):
+    """
+    Build the example component.
+    
+    Args:
+        cwd: Current working directory (component directory)
+        has_func: Function to check if a configuration is enabled
+        rtconfig: RT-Thread configuration module
+        build_root: Optional build root directory
+        
+    Returns:
+        tuple: (LIBS, LIBPATH, LINKFLAGS) for SCons
+    """
+    LIBS = []
+    LIBPATH = []
+    LINKFLAGS = ""
+    
+    # Import build support functions
+    import sys
+    sys.path.append(os.path.join(cwd, '../rust/tools'))
+    from build_support import (
+        detect_rust_target,
+        make_rustflags,
+    )
+    
+    target = detect_rust_target(has_func, rtconfig)
+    
+    # Build mode and features
+    debug = bool(has_func('RUST_DEBUG_BUILD'))
+    
+    # Build the component registry
+    registry_dir = os.path.join(cwd, 'component_registry')
+    features = collect_component_features(has_func, registry_dir)
+    
+    rustflags = make_rustflags(rtconfig, target)
+    
+    rust_lib = cargo_build_component_staticlib(
+        rust_dir=registry_dir, 
+        target=target, 
+        features=features, 
+        debug=debug, 
+        rustflags=rustflags,
+        build_root=build_root
+    )
+    
+    if rust_lib:
+        LIBS = ['em_component_registry']
+        LIBPATH = [os.path.dirname(rust_lib)]
+        # Add LINKFLAGS to ensure component is linked into final binary
+        LINKFLAGS += " -Wl,--whole-archive -lem_component_registry -Wl,--no-whole-archive"
+        LINKFLAGS += " -Wl,--allow-multiple-definition"
+        print('Example component registry library linked successfully')
+    else:
+        print('Warning: Failed to build example component registry library')
+    
+    return LIBS, LIBPATH, LINKFLAGS

components/rust/tools/build_support.py

@@ -0,0 +1,233 @@
+import os
+import subprocess
+
+
+def _parse_cflags(cflags: str):
+    info = {
+        "march": None,
+        "mabi": None,
+        "rv_bits": None,  # 32 or 64
+        "has_f": False,
+        "has_d": False,
+    }
+
+    if not cflags:
+        return info
+
+    parts = cflags.split()
+    for flag in parts:
+        if flag.startswith("-march="):
+            info["march"] = flag.split("=", 1)[1]
+            if "rv32" in info["march"]:
+                info["rv_bits"] = 32
+            elif "rv64" in info["march"]:
+                info["rv_bits"] = 64
+            # crude feature detection
+            m = info["march"]
+            if m:
+                info["has_f"] = ("f" in m)
+                info["has_d"] = ("d" in m)
+        elif flag.startswith("-mabi="):
+            info["mabi"] = flag.split("=", 1)[1]
+            if info["mabi"] in ("ilp32d", "ilp32f", "lp64d", "lp64f"):
+                # floating-point ABI implies FPU availability
+                info["has_f"] = True
+                info["has_d"] = info["mabi"].endswith("d")
+
+    return info
+
+
+def detect_rust_target(has, rtconfig):
+    """
+    Decide the Rust target triple based on RT-Thread Kconfig and rtconfig.*.
+    `has` is a callable: has("SYMBOL") -> bool
+    """
+    # ARM Cortex-M
+    if has("ARCH_ARM"):
+        # FPU hints from flags/macros
+        cflags = getattr(rtconfig, "CFLAGS", "")
+        hard_float = "-mfloat-abi=hard" in cflags or has("ARCH_ARM_FPU") or has("ARCH_FPU_VFP")
+
+        if has("ARCH_ARM_CORTEX_M3"):
+            return "thumbv7m-none-eabi"
+        if has("ARCH_ARM_CORTEX_M4") or has("ARCH_ARM_CORTEX_M7"):
+            return "thumbv7em-none-eabihf" if hard_float else "thumbv7em-none-eabi"
+        if has("ARCH_ARM_CORTEX_M33"):
+            # v8m.main
+            return "thumbv8m.main-none-eabi"
+        if has("ARCH_ARM_CORTEX_A"):
+            return "armv7a-none-eabi"
+
+    # AArch64
+    if has("ARCH_AARCH64") or has("ARCH_ARMV8") or has("ARCH_ARM64"):
+        if has("ARCH_CPU_FLOAT_ABI_SOFT"):
+            return "aarch64-unknown-none-softfloat"
+        return "aarch64-unknown-none"
+    
+    # RISC-V
+    if has("ARCH_RISCV32") or has("ARCH_RISCV64"):
+        cflags = getattr(rtconfig, "CFLAGS", "")
+        info = _parse_cflags(cflags)
+
+        # fallback to Kconfig hint if march not present
+        rv_bits = info["rv_bits"] or (32 if has("ARCH_RISCV32") else 64)
+
+        # ABI must carry f/d to actually use hard-float calling convention
+        abi = info["mabi"] or ""
+        abi_has_fp = abi.endswith("f") or abi.endswith("d")
+
+        if rv_bits == 32:
+            # Only pick *f* target when ABI uses hard-float; otherwise use soft-float even if core has F/D
+            return "riscv32imafc-unknown-none-elf" if abi_has_fp else "riscv32imac-unknown-none-elf"
+        else:
+            # rv64: prefer gc (includes fd) only when ABI uses hard-float
+            return "riscv64gc-unknown-none-elf" if abi_has_fp else "riscv64imac-unknown-none-elf"
+
+    # Fallback by ARCH string or CFLAGS
+    arch = getattr(rtconfig, "ARCH", None)
+    if arch:
+        arch_l = arch.lower()
+        if "aarch64" in arch_l:
+            return "aarch64-unknown-none"
+        if "arm" == arch_l or "armv7" in arch_l:
+            return "armv7a-none-eabi"
+        if "riscv32" in arch_l:
+            return "riscv32imac-unknown-none-elf"
+        if "riscv64" in arch_l or "risc-v" in arch_l:
+            # Many BSPs use "risc-v" token; assume 64-bit for virt64
+            return "riscv64imac-unknown-none-elf"
+
+    # Parse CFLAGS for hints
+    cflags = getattr(rtconfig, "CFLAGS", "")
+    if "-mcpu=cortex-m3" in cflags:
+        return "thumbv7m-none-eabi"
+    if "-mcpu=cortex-m4" in cflags or "-mcpu=cortex-m7" in cflags:
+        if "-mfpu=" in cflags and "-mfloat-abi=hard" in cflags:
+            return "thumbv7em-none-eabihf"
+        return "thumbv7em-none-eabi"
+    if "-march=rv32" in cflags:
+        march_val = None
+        mabi_val = None
+        for flag in cflags.split():
+            if flag.startswith("-march="):
+                march_val = flag[len("-march="):]
+            elif flag.startswith("-mabi="):
+                mabi_val = flag[len("-mabi="):]
+        has_f_or_d = False
+        if march_val and any(x in march_val for x in ("f", "d")):
+            has_f_or_d = True
+        if mabi_val and any(x in mabi_val for x in ("f", "d")):
+            has_f_or_d = True
+        return "riscv32imafc-unknown-none-elf" if has_f_or_d else "riscv32imac-unknown-none-elf"
+    if "-march=rv64" in cflags:
+        march_val = None
+        mabi_val = None
+        for flag in cflags.split():
+            if flag.startswith("-march="):
+                march_val = flag[len("-march="):]
+            elif flag.startswith("-mabi="):
+                mabi_val = flag[len("-mabi="):]
+        has_f_or_d = False
+        if mabi_val and (("lp64d" in mabi_val) or ("lp64f" in mabi_val)):
+            has_f_or_d = True
+        if march_val and any(x in march_val for x in ("f", "d")):
+            has_f_or_d = True
+        if mabi_val and any(x in mabi_val for x in ("f", "d")):
+            has_f_or_d = True
+        if has_f_or_d:
+            return "riscv64gc-unknown-none-elf"
+        return "riscv64imac-unknown-none-elf"
+
+    return None
+
+
+def make_rustflags(rtconfig, target: str):
+    rustflags = [
+        "-C", "opt-level=z",
+        "-C", "panic=abort",
+        "-C", "relocation-model=static",
+    ]
+
+    if "riscv" in target:
+        rustflags += [
+            "-C", "code-model=medium",
+            "-C", "link-dead-code",
+        ]
+        # propagate march/mabi for consistency (use link-arg for staticlib builds – harmless)
+        cflags = getattr(rtconfig, "CFLAGS", "")
+        for flag in cflags.split():
+            if flag.startswith("-march=") or flag.startswith("-mabi="):
+                rustflags += ["-C", f"link-arg={flag}"]
+
+    if "thumb" in target or "aarch64" in target:
+        rustflags += ["-C", "link-arg=-nostartfiles"]
+
+    return " ".join(rustflags)
+
+
+def collect_features(has):
+    feats = []
+    if has("RT_USING_SMP"):
+        feats.append("smp")
+    return feats
+
+
+def verify_rust_toolchain():
+    try:
+        r1 = subprocess.run(["rustc", "--version"], capture_output=True, text=True)
+        r2 = subprocess.run(["cargo", "--version"], capture_output=True, text=True)
+        return r1.returncode == 0 and r2.returncode == 0
+    except Exception:
+        return False
+
+
+def ensure_rust_target_installed(target: str):
+    try:
+        result = subprocess.run(["rustup", "target", "list", "--installed"], capture_output=True, text=True)
+        if result.returncode == 0 and target in result.stdout:
+            return True
+        print(f"Rust target '{target}' is not installed.")
+        print(f"Please install it with: rustup target add {target}")
+    except Exception:
+        print("Warning: Failed to check rustup target list (rustup missing?)")
+    return False
+
+
+def cargo_build_staticlib(rust_dir: str, target: str, features, debug: bool, rustflags: str = None):
+    build_root = os.path.join((os.path.abspath(os.path.join(rust_dir, os.pardir, os.pardir))), "build", "rust")
+    target_dir = os.path.join(build_root, "target")
+    os.makedirs(build_root, exist_ok=True)
+
+    env = os.environ.copy()
+    if rustflags:
+        prev = env.get("RUSTFLAGS", "").strip()
+        env["RUSTFLAGS"] = (prev + " " + rustflags).strip() if prev else rustflags
+    env["CARGO_TARGET_DIR"] = target_dir
+
+    cmd = ["cargo", "build", "--target", target, "--manifest-path", os.path.join(rust_dir, "Cargo.toml")]
+    if not debug:
+        cmd.insert(2, "--release")
+    if features:
+        cmd += ["--no-default-features", "--features", ",".join(features)]
+
+    print("Building Rust component (cargo)…")
+    res = subprocess.run(cmd, cwd=rust_dir, env=env, capture_output=True, text=True)
+    if res.returncode != 0:
+        print("Warning: Rust build failed")
+        if res.stderr:
+            print(res.stderr)
+        return None
+
+    mode = "debug" if debug else "release"
+    lib_path = os.path.join(target_dir, target, mode, "librt_rust.a")
+    if os.path.exists(lib_path):
+        print("Rust component built successfully")
+        return lib_path
+    print("Warning: Library not found at expected location")
+    return None
+
+
+def clean_rust_build(bsp_root: str, artifact_type: str = "rust"):
+    """Return the build directory path for SCons Clean operation"""
+    build_dir = os.path.join(bsp_root, "build", artifact_type)
+    return build_dir

components/rust/tools/build_usrapp.py

@@ -0,0 +1,392 @@
+import os
+import subprocess
+import toml
+import shutil
+
+
+# Configuration to feature mapping table
+# This table defines which RT-Thread configurations should enable which Rust features
+# All feature configurations are now defined in feature_config_examples.py
+CONFIG_FEATURE_MAP = {}
+
+# Application directory to Kconfig mapping table
+# This table defines which Kconfig options control which application directories
+APP_CONFIG_MAP = {
+    'fs': 'RT_RUST_EXAMPLE_FS',
+    'loadlib': 'RT_RUST_EXAMPLE_LOADLIB', 
+    'mutex': 'RT_RUST_EXAMPLE_MUTEX',
+    'param': 'RT_RUST_EXAMPLE_PARAM',
+    'queue': 'RT_RUST_EXAMPLE_QUEUE',
+    'semaphore': 'RT_RUST_EXAMPLE_SEMAPHORE',
+    'thread': 'RT_RUST_EXAMPLE_THREAD'
+}
+
+
+def should_build_app(app_dir, has_func):
+    """
+    Check if an application should be built based on Kconfig configuration
+    
+    Args:
+        app_dir: Application directory path
+        has_func: Function to check if a configuration is enabled
+        
+    Returns:
+        bool: True if the application should be built
+    """
+    # Get the application name from the directory
+    app_name = os.path.basename(app_dir)
+    
+    # Check if there's a specific Kconfig option for this app
+    if app_name in APP_CONFIG_MAP:
+        config_option = APP_CONFIG_MAP[app_name]
+        return has_func(config_option)
+    
+    # If no specific config found, check if applications are enabled in general
+    return has_func('RT_RUST_BUILD_APPLICATIONS')
+
+
+def check_app_dependencies(app_dir, required_dependencies):
+    """
+    Check if an application has the required dependencies
+    
+    Args:
+        app_dir: Application directory path
+        required_dependencies: List of dependency names to check
+        
+    Returns:
+        bool: True if all required dependencies are present
+    """
+    if not app_dir or not required_dependencies:
+        return True
+    
+    cargo_toml_path = os.path.join(app_dir, 'Cargo.toml')
+    if not os.path.exists(cargo_toml_path):
+        return False
+    
+    try:
+        with open(cargo_toml_path, 'r') as f:
+            cargo_data = toml.load(f)
+        
+        dependencies = cargo_data.get('dependencies', {})
+        
+        # Check if all required dependencies are present
+        for dep in required_dependencies:
+            if dep not in dependencies:
+                return False
+        
+        return True
+        
+    except Exception as e:
+        print(f"Warning: Failed to parse {cargo_toml_path}: {e}")
+        return False
+
+
+def collect_features(has_func, app_dir=None):
+    """
+    Collect Rust features based on RT-Thread configuration using extensible mapping table
+    
+    Args:
+        has_func: Function to check if a configuration is enabled
+        app_dir: Application directory to check dependencies (optional)
+        
+    Returns:
+        list: List of features to enable
+    """
+    features = []
+    
+    # Iterate through all configured mappings
+    for config_name, config_info in CONFIG_FEATURE_MAP.items():
+        # Check if this RT-Thread configuration is enabled
+        if has_func(config_name):
+            feature_name = config_info['feature']
+            required_deps = config_info.get('dependencies', [])
+            
+            # If app_dir is provided, check dependencies
+            if app_dir:
+                if check_app_dependencies(app_dir, required_deps):
+                    features.append(feature_name)
+                    print(f"Enabling feature '{feature_name}' for {config_name} in {os.path.basename(app_dir)}")
+            else:
+                # If no app_dir provided, enable for all (backward compatibility)
+                features.append(feature_name)
+                print(f"Enabling feature '{feature_name}' for {config_name}")
+    
+    return features
+
+
+
+
+
+class UserAppBuildError(Exception):
+    """User application build error exception"""
+    pass
+
+
+def parse_cargo_toml(cargo_toml_path):
+    """
+    Parse Cargo.toml file to extract library name and library type
+    
+    Args:
+        cargo_toml_path: Path to Cargo.toml file
+        
+    Returns:
+        tuple: (lib_name, is_staticlib)
+    """
+    try:
+        with open(cargo_toml_path, 'r') as f:
+            cargo_data = toml.load(f)
+        
+        package_name = cargo_data.get('package', {}).get('name')
+        if not package_name:
+            raise UserAppBuildError(f"No package name found in {cargo_toml_path}")
+        
+        lib_config = cargo_data.get('lib', {})
+        crate_type = lib_config.get('crate-type', [])
+        is_staticlib = 'staticlib' in crate_type
+        
+        # Use lib name if specified, otherwise use package name
+        lib_name = lib_config.get('name', package_name)
+        
+        return lib_name, is_staticlib
+        
+    except Exception as e:
+        raise UserAppBuildError(f"Failed to parse {cargo_toml_path}: {e}")
+
+
+def discover_user_apps(base_dir):
+    """
+    Discover all user application directories
+    
+    Args:
+        base_dir: Base directory path
+        
+    Returns:
+        list: List of directories containing Cargo.toml
+    """
+    user_apps = []
+    
+    for root, dirs, files in os.walk(base_dir):
+        if 'Cargo.toml' in files:
+            if 'target' in root or 'build' in root:
+                continue
+            user_apps.append(root)
+    
+    return user_apps
+
+
+def build_user_app(app_dir, target, debug, rustflags, build_root, features=None):
+    """
+    Build a single user application
+    
+    Args:
+        app_dir: Application directory
+        target: Rust target architecture
+        debug: Whether this is a debug build
+        rustflags: Rust compilation flags
+        build_root: Build root directory
+        features: List of features to enable
+        
+    Returns:
+        tuple: (success, lib_name, lib_path)
+    """
+    try:
+        cargo_toml_path = os.path.join(app_dir, 'Cargo.toml')
+        lib_name, is_staticlib = parse_cargo_toml(cargo_toml_path)
+        
+        if not is_staticlib:
+            return False, None, None
+        
+        env = os.environ.copy()
+        env['RUSTFLAGS'] = rustflags
+        env['CARGO_TARGET_DIR'] = build_root
+        
+        cmd = ['cargo', 'build', '--target', target]
+        if not debug:
+            cmd.append('--release')
+        
+        # Add features if specified
+        if features:
+            cmd.extend(['--features', ','.join(features)])
+        
+        print(f"Building example user app {lib_name} (cargo)…")
+        result = subprocess.run(cmd, cwd=app_dir, env=env, 
+                              capture_output=True, text=True)
+        
+        if result.returncode != 0:
+            print(f"Failed to build user app in {app_dir}")
+            print(f"Command: {' '.join(cmd)}")
+            print(f"Return code: {result.returncode}")
+            print(f"STDOUT: {result.stdout}")
+            print(f"STDERR: {result.stderr}")
+            return False, None, None
+        
+        lib_file = find_library_file(build_root, target, lib_name, debug)
+        if lib_file:
+            # Return the library name for linking
+            return True, lib_name, lib_file
+        else:
+            print(f"Library file not found for lib {lib_name}")
+            return False, None, None
+            
+    except Exception as e:
+        print(f"Exception occurred while building user app in {app_dir}: {e}")
+        return False, None, None
+
+
+def find_library_file(build_root, target, lib_name, debug):
+    """
+    Find the generated library file
+    
+    Args:
+        build_root: Build root directory
+        target: Rust target architecture
+        lib_name: Library name
+        debug: Whether this is a debug build
+        
+    Returns:
+        str: Library file path, or None if not found
+    """
+    profile = "debug" if debug else "release"
+    
+    possible_names = [
+        f"lib{lib_name}.a",
+        f"lib{lib_name.replace('-', '_')}.a"
+    ]
+    
+    search_paths = [
+        os.path.join(build_root, target, profile),
+        os.path.join(build_root, target, profile, "deps")
+    ]
+    
+    for search_path in search_paths:
+        if not os.path.exists(search_path):
+            continue
+                    
+        for name in possible_names:
+            lib_path = os.path.join(search_path, name)
+            if os.path.exists(lib_path):
+                return lib_path
+    
+    return None
+
+
+def build_all_user_apps(base_dir, target, debug, rustflags, build_root, has_func):
+    """
+    Build all user applications
+    
+    Args:
+        base_dir: User applications base directory
+        target: Rust target architecture
+        debug: Whether this is a debug build
+        rustflags: Rust compilation flags
+        build_root: Build root directory
+        has_func: Function to check if a configuration is enabled
+        
+    Returns:
+        tuple: (LIBS, LIBPATH, success_count, total_count)
+    """
+    LIBS = []
+    LIBPATH = []
+    success_count = 0
+    
+    user_apps = discover_user_apps(base_dir)
+    total_count = len(user_apps)
+    
+    for app_dir in user_apps:
+        # Check if this application should be built based on Kconfig
+        if not should_build_app(app_dir, has_func):
+            app_name = os.path.basename(app_dir)
+            print(f"Skipping {app_name} (disabled in Kconfig)")
+            continue
+            
+        # Collect features for this specific app
+        features = collect_features(has_func, app_dir)
+        success, lib_name, lib_path = build_user_app(app_dir, target, debug, rustflags, build_root, features)
+        
+        if success and lib_path:
+            app_name = os.path.basename(app_dir)
+            print(f"Example user app {app_name} built successfully")
+            LIBS.append(lib_name)
+            lib_dir = os.path.dirname(lib_path)
+            if lib_dir not in LIBPATH:
+                LIBPATH.append(lib_dir)
+            success_count += 1
+    
+    return LIBS, LIBPATH, success_count, total_count
+
+
+def generate_linkflags(LIBS, LIBPATH):
+    """
+    Generate link flags
+    
+    Args:
+        LIBS: List of library names
+        LIBPATH: List of library paths
+        
+    Returns:
+        str: Link flags string
+    """
+    if not LIBS or not LIBPATH:
+        return ""
+    
+    linkflags = f" -L{LIBPATH[0]} -Wl,--whole-archive"
+    for lib in LIBS:
+        linkflags += f" -l{lib}"
+    linkflags += " -Wl,--no-whole-archive -Wl,--allow-multiple-definition"
+    
+    return linkflags
+
+
+def clean_user_apps_build(build_root):
+    """
+    Clean user applications build artifacts
+    
+    Args:
+        build_root: Build root directory
+    """
+    if os.path.exists(build_root):
+        shutil.rmtree(build_root)
+
+
+def build_example_usrapp(cwd, has_func, rtconfig, build_root=None):
+    """
+    Build the example user applications.
+    
+    Args:
+        cwd: Current working directory (usrapp directory)
+        has_func: Function to check if a configuration is enabled
+        rtconfig: RT-Thread configuration module
+        build_root: Optional build root directory
+        
+    Returns:
+        tuple: (LIBS, LIBPATH, LINKFLAGS) for SCons
+    """
+    LIBS = []
+    LIBPATH = []
+    LINKFLAGS = ""
+    
+    try:
+        # Import build support functions
+        import sys
+        sys.path.append(os.path.join(cwd, '../rust/tools'))
+        import build_support as rust_build_support
+        
+        target = rust_build_support.detect_rust_target(has_func, rtconfig)
+        debug = bool(has_func('RUST_DEBUG_BUILD'))
+        rustflags = rust_build_support.make_rustflags(rtconfig, target)
+        LIBS, LIBPATH, success_count, total_count = build_all_user_apps(
+            cwd, target, debug, rustflags, build_root, has_func
+        )
+        
+        if success_count == 0 and total_count > 0:
+            print(f'Warning: Failed to build all {total_count} user applications')
+        elif success_count > 0:
+            LINKFLAGS = generate_linkflags(LIBS, LIBPATH)
+            print(f'Example user apps linked successfully')
+            
+    except UserAppBuildError as e:
+        print(f'Error: {e}')
+    except Exception as e:
+        print(f'Unexpected error during user apps build: {e}')
+    
+    return LIBS, LIBPATH, LINKFLAGS

components/rust/tools/feature_config_component.py

@@ -0,0 +1,30 @@
+import sys
+import os
+from building import *
+cwd = GetCurrentDir()
+sys.path.append(os.path.join(cwd, 'tools'))
+from build_component import CONFIG_COMPONENT_FEATURE_MAP
+
+def setup_all_component_features():
+    """
+    Setup all component feature mappings.
+    This function configures which RT-Thread configurations should enable which component features.
+    """
+    
+    CONFIG_COMPONENT_FEATURE_MAP.update({
+        'RUST_LOG_COMPONENT': {
+            'feature': 'enable-log',
+            'dependencies': ['em_component_log'],
+            'description': 'Enable Rust logging component integration'
+        },
+    })
+    
+    print("All component feature mappings have been configured!")
+
+
+if __name__ == "__main__":
+    setup_all_component_features()
+    print(f"Total component configurations: {len(CONFIG_COMPONENT_FEATURE_MAP)}")
+    print("Available component configurations:")
+    for config, info in CONFIG_COMPONENT_FEATURE_MAP.items():
+        print(f"  {config}: {info['feature']} - {info['description']}")

components/rust/tools/feature_config_examples.py

@@ -0,0 +1,26 @@
+import sys
+import os
+from building import *
+cwd = GetCurrentDir()
+sys.path.append(os.path.join(cwd, 'tools'))
+from build_usrapp import CONFIG_FEATURE_MAP
+
+def setup_all_example_features():
+    
+    CONFIG_FEATURE_MAP.update({
+        'RUST_LOG_COMPONENT': {
+            'feature': 'enable-log',
+            'dependencies': ['em_component_log'],
+            'description': 'Enable Rust logging component integration'
+        },
+    })
+    
+    print("All example feature mappings have been configured!")
+
+
+if __name__ == "__main__":
+    setup_all_example_features()
+    print(f"Total configurations: {len(CONFIG_FEATURE_MAP)}")
+    print("Available configurations:")
+    for config, info in CONFIG_FEATURE_MAP.items():
+        print(f"  {config}: {info['feature']} - {info['description']}")