1. RT-Thread NANO 简介与移植背景
RT-Thread NANO 是一个极简版的硬实时内核,采用 C 语言开发,面向对象的设计思维让代码风格非常优雅。它是一款高度可裁剪的抢占式实时多任务操作系统,内存占用极小,但功能却相当完整——包括多任务处理、软件定时器、信号量、邮箱和实时调度等核心特性。特别适合那些资源受限的 32 位 ARM 入门级 MCU,在家电、消费电子、医疗设备、工控等领域有广泛应用。
我最早接触 RT-Thread NANO 是在一个智能家居项目上,当时需要在一个 Cortex-M3 芯片上跑多个任务,而资源只有 32KB Flash 和 4KB RAM。试过几个 RTOS,最终发现 NANO 是最佳选择,毕竟它的内核最小可以裁剪到 ROM 2.5KB、RAM 1KB,实测下来非常稳。
最新版本 V4.1.1 在官网和 GitHub 都能下载到,不过这个版本在动态内存分配上有个坑——官网提供的 SDK 中,堆栈内存管理算法有点问题,可能是代码调整时忘了同步更新内存管理部分。这会导致堆栈内存没有正确初始化,相关的 API 也无法正常使用。不过别担心,后面我会详细讲怎么解决这个问题。
2. 工程准备与源码移植
2.1 获取源码与工程搭建
首先从 GitHub 下载 RT-Thread NANO V4.1.1 的源码(地址:https://github.com/RT-Thread/rtthread-nano)。下载完后解压,你会看到这样的目录结构:
rtthread-nano/
├── src
├── libcpu
├── include
└── bsp
接下来创建一个新的工程目录,把解压后的文件全部放进去。我习惯这样组织:
- 将
src文件夹下的所有.c文件添加到工程的源码组 - 把
libcpu/arm/cortex-m0(根据你的芯片选择 M0/M3/M4)下的文件添加到 CPU 支持组 - 将
bsp下的board.c和rtconfig.h复制到工程目录的User文件夹
在 IDE 中添加文件时,要注意分组清晰。比如在 Keil 中,我会创建这样的分组:
- RT-Thread/Kernel:放
src下的核心文件 - RT-Thread/CPU:放 CPU 架构相关文件
- RT-Thread/User:放
board.c和rtconfig.h
2.2 头文件路径与基础配置
添加完文件后,记得设置头文件包含路径。通常需要包含这几个路径:
- 工程根目录下的
include文件夹 libcpu/arm/cortex-mx(根据你的芯片选择)src目录- 你自己存放
rtconfig.h的路径
在 rtconfig.h 中,有一些基础配置需要根据你的芯片调整:
#define RT_THREAD_PRIORITY_MAX 32 // 最大线程优先级
#define RT_TICK_PER_SECOND 1000 // 系统时钟频率,通常是 1ms 一个 tick
#define RT_ALIGN_SIZE 4 // 对齐字节数
#define RT_NAME_MAX 8 // 对象名称最大长度
#define RT_MAIN_THREAD_STACK_SIZE 512 // 主线程栈大小
这些值需要根据你的芯片资源来调整。比如 RAM 很小的芯片,可以把栈大小设小一点;而资源丰富的芯片可以适当增大。
3. 内存管理调优实战
3.1 内存分配算法问题定位
移植完成后,编译一般不会报错,但运行时可能会发现线程创建失败。我在第一次移植 V4.1.1 时就遇到了这个问题——系统启动了,但 main 线程就是无法创建。
通过添加调试信息,发现 rt_application_init() 中创建线程时返回了 0,表示创建失败。进一步跟踪,发现是在 rt_thread_create() 中申请内存时失败了。
问题根源在于内存分配算法。NANO 系统默认使用小内存管理算法(RT_USING_SMALL_MEM),但这个版本中,这个算法与 NANO 系统的内存申请方式不太适配,导致堆栈没有正确初始化。
3.2 解决方案与参数调优
解决方法是把 RT_USING_SMALL_MEM 替换为 RT_USING_SMALL_MEM_AS_HEAP。在工程中全局搜索 RT_USING_SMALL_MEM,全部替换掉。然后重新编译,问题就应该解决了。
不过这只是开始,真正要优化内存管理,还需要根据具体芯片调整堆大小。在 board.c 中,可以看到堆的配置:
#define RT_HEAP_SIZE 1024 // 默认堆大小,单位字节
static uint32_t rt_heap[RT_HEAP_SIZE]; // 堆数组
RT_WEAK void *rt_heap_begin_get(void) {
return rt_heap;
}
RT_WEAK void *rt_heap_end_get(void) {
return rt_heap + RT_HEAP_SIZE;
}
对于资源紧张的芯片,你需要精确计算每个线程的栈需求和总内存需求,然后设置合适的堆大小。我的经验是:总堆大小 = 所有线程栈大小之和 + 动态内存需求 + 安全余量(约 20%)。
3.3 高级内存配置技巧
对于更高级的应用,可以使用链接脚本中 ZI 段末尾之后的内存作为堆空间,这样能最大化利用内存:
extern int Image$$RW_IRAM1$$ZI$$Limit; // ZI 段结束地址
#define HEAP_BEGIN ((void *)&Image$$RW_IRAM1$$ZI$$Limit)
#define HEAP_END (0x20000000 + 20 * 1024) // RAM 结束地址
void rt_hw_board_init(void) {
// ... 其他初始化代码
#if defined(RT_USING_USER_MAIN) && defined(RT_USING_HEAP)
rt_system_heap_init((void *)HEAP_BEGIN, (void *)HEAP_END);
#endif
}
这种方式需要你对链接脚本有一定了解,但能更充分地利用芯片的 RAM 资源。
4. 多线程应用创建与验证
4.1 基础多线程创建
内存问题解决后,就可以愉快地创建多线程了。下面是一个典型的多线程示例:
#include <rtthread.h>
#include "main.h"
// 定义线程句柄
rt_thread_t task1_handle = RT_NULL;
rt_thread_t task2_handle = RT_NULL;
rt_thread_t task3_handle = RT_NULL;
// 线程1入口函数
void task1_entry(void *parameter) {
while (1) {
rt_kprintf("Task 1 is running\r\n");
rt_thread_mdelay(1000); // 延时1秒
}
}
// 线程2入口函数
void task2_entry(void *parameter) {
while (1) {
rt_kprintf("Task 2 is running\r\n");
rt_thread_mdelay(1500); // 延时1.5秒
}
}
// 线程3入口函数
void task3_entry(void *parameter) {
while (1) {
rt_kprintf("Task 3 is running\r\n");
rt_thread_mdelay(2000); // 延时2秒
}
}
int main(void) {
// 创建线程1
task1_handle = rt_thread_create("task1", task1_entry, RT_NULL, 256, 3, 20);
if (task1_handle != RT_NULL) {
rt_thread_startup(task1_handle);
} else {
rt_kprintf("Failed to create task1\r\n");
}
// 创建线程2
task2_handle = rt_thread_create("task2", task2_entry, RT_NULL, 256, 2, 20);
if (task2_handle != RT_NULL) {
rt_thread_startup(task2_handle);
} else {
rt_kprintf("Failed to create task2\r\n");
}
// 创建线程3
task3_handle = rt_thread_create("task3", task3_entry, RT_NULL, 256, 1, 20);
if (task3_handle != RT_NULL) {
rt_thread_startup(task3_handle);
} else {
rt_kprintf("Failed to create task3\r\n");
}
// 主线程循环
while (1) {
rt_kprintf("Main thread is running\r\n");
rt_thread_mdelay(3000);
}
}
这段代码创建了三个线程,每个线程有不同的优先级和运行周期。通过 rt_kprintf 输出,我们可以在串口助手中看到各线程的调度情况。
4.2 线程同步与通信实战
在实际项目中,线程之间往往需要同步和通信。NANO 提供了信号量、邮箱等机制:
// 定义信号量和邮箱
static rt_sem_t test_sem = RT_NULL;
static rt_mailbox_t test_mb = RT_NULL;
// 生产者线程
void producer_entry(void *parameter) {
rt_uint32_t count = 0;
while (1) {
rt_sem_take(test_sem, RT_WAITING_FOREVER); // 等待信号量
rt_mb_send(test_mb, (rt_uint32_t)count); // 发送消息
count++;
rt_thread_mdelay(500);
}
}
// 消费者线程
void consumer_entry(void *parameter) {
rt_uint32_t recv_value;
while (1) {
if (rt_mb_recv(test_mb, (rt_ubase_t *)&recv_value, RT_WAITING_FOREVER) == RT_EOK) {
rt_kprintf("Received: %d\r\n", recv_value);
}
}
}
int main(void) {
// 创建信号量
test_sem = rt_sem_create("test_sem", 1, RT_IPC_FLAG_FIFO);
// 创建邮箱
test_mb = rt_mb_create("test_mb", 32, RT_IPC_FLAG_FIFO);
// 创建生产者和消费者线程
rt_thread_t producer_thread = rt_thread_create("producer", producer_entry, RT_NULL, 256, 10, 20);
rt_thread_t consumer_thread = rt_thread_create("consumer", consumer_entry, RT_NULL, 256, 11, 20);
// 启动线程
if (producer_thread != RT_NULL) rt_thread_startup(producer_thread);
if (consumer_thread != RT_NULL) rt_thread_startup(consumer_thread);
// 主线程循环
while (1) {
rt_sem_release(test_sem); // 释放信号量
rt_thread_mdelay(1000);
}
}
这个例子展示了如何使用信号量和邮箱实现线程间的同步与通信。生产者线程等待信号量,然后向邮箱发送数据;消费者线程从邮箱接收数据并打印;主线程定期释放信号量触发生产过程。
5. 系统调试与性能验证
5.1 系统状态监控
调试多线程应用时,了解系统状态很重要。NANO 虽然没有完整的 FinSH 组件,但我们仍然可以通过一些简单方法监控系统状态:
// 系统状态监控线程
void monitor_entry(void *parameter) {
rt_uint32_t total_memory, used_memory, free_memory;
while (1) {
// 获取内存使用情况
rt_memory_info(&total_memory, &used_memory, &free_memory);
rt_kprintf("Memory: Total=%d, Used=%d, Free=%d\r\n", total_memory, used_memory, free_memory);
// 获取线程信息
rt_thread_t thread = rt_thread_self();
rt_kprintf("Current thread: %s, Priority: %d\r\n", thread->name, thread->current_priority);
rt_thread_mdelay(2000);
}
}
这段代码可以显示内存使用情况和当前运行线程的信息,对于调试很有帮助。
5.2 性能测试与优化
在实际项目中,我们还需要验证系统的实时性能。下面是一个简单的性能测试例子:
static rt_tick_t start_time, end_time;
static rt_uint32_t loop_count = 1000;
// 上下文切换性能测试
void context_switch_test(void) {
rt_kprintf("Starting context switch performance test...\r\n");
start_time = rt_tick_get();
for (rt_uint32_t i = 0; i < loop_count; i++) {
rt_thread_yield(); // 主动让出 CPU
}
end_time = rt_tick_get();
rt_tick_t total_ticks = end_time - start_time;
rt_kprintf("Total ticks for %d context switches: %d\r\n", loop_count, total_ticks);
rt_kprintf("Average context switch time: %.3f ms\r\n",
(float)total_ticks * 1000 / RT_TICK_PER_SECOND / loop_count);
}
// 中断响应性能测试
volatile static rt_base_t interrupt_latency;
void IRQ_Handler(void) {
interrupt_latency = rt_tick_get() - start_time;
// 清除中断标志等操作
}
void interrupt_test(void) {
rt_kprintf("Starting interrupt latency test...\r\n");
// 设置中断并触发
start_time = rt_tick_get();
// 这里需要根据具体芯片触发一个中断
rt_thread_mdelay(10); // 等待中断处理
rt_kprintf("Interrupt latency: %d ticks\r\n", interrupt_latency);
}
这些测试可以帮助我们了解系统的实时性能,发现潜在的问题。
6. 常见问题与解决经验
在移植和调试 RT-Thread NANO 过程中,我踩过不少坑,这里分享几个常见问题的解决方法:
问题一:线程创建失败
除了前面提到的内存管理算法问题,线程创建失败还可能是因为堆空间不足。解决方法是通过 rt_memory_info() 函数检查内存使用情况,适当增加堆大小。
问题二:系统运行不稳定
有时系统运行一段时间后会崩溃,可能是栈溢出导致的。可以通过在 rtconfig.h 中开启 RT_USING_OVERFLOW_CHECK 来检测栈溢出。
问题三:优先级反转 在高优先级任务等待低优先级任务释放资源时,可能会发生优先级反转。解决方法
923



被折叠的 条评论
为什么被折叠?



