rt_thread 的定时器管理源码分析

该休眠就休 眠，且时间 可控制。
sleep(1000);
} return 0; }
LED流水灯 – 第二盏灯

如何点亮第二盏灯？ Linux的做法，再编写一个应用程序：

int main(int argc, char** argv) { while (1) { led(2, 1); sleep(500); led(2, 0); sleep(500); } return 0; }
RT-Thread丰富的外围组件： 图形用户界面
16

为人机交互提供图形化的用户界面：
支持GBK中文显示； 丰富的绘图例程、丰富的基础控件：


多线程多窗口用户界面； 支持主题风格的图形用户界面； 典型资源占用：20k RAM。

label, button, checkbox, radiobox, textbox, slider progress bar, scroll bar, window, list box/view等

RT-Thread实时核心：内存管理
9

内存管理模块：
带线程挂起功能的静态内存池： 每个内存块大小固定； 申请、释放内存块行为实时而高效。 当内存池为空时，线程可选择是否休眠，当有内存块可 用时，自动唤醒等待线程。


多线程环境安全的动态堆内存管理。
基本系统亦可脱离内存分配器而独立运行。
第二个LED点灯程 序可以不用关心第 一个程序的执行情 况。
LED流水灯 – 运行于RT-Thread基础上

点亮第一盏灯
#include <rtthread.h> #include <Arduino.h>

rtthread里面的堆设置原理-概述说明以及解释1.引言1.1 概述在嵌入式实时操作系统中，堆是一个重要的概念，也是实现动态内存分配的重要手段。

在rtthread中，堆的设置尤为重要，它不仅影响系统的内存管理效率，还直接影响到系统的稳定性和可维护性。

因此，深入理解rtthread中堆设置的原理是非常必要的。

本文将围绕rtthread中堆的概念、作用、设置方法以及原理展开讨论，希望读者能够通过本文全面了解rtthread中堆设置的重要性，并为今后在实际应用中做好相关设置提供指导。

1.2文章结构文章结构部分的内容如下："1.2 文章结构:本文将分为三个主要部分，分别是引言、正文和结论。

在引言部分，将介绍本文的概述、文章结构以及撰写的目的。

在正文部分，将详细介绍rtthread中堆的概念及作用，堆的设置方法，以及堆设置的原理。

在结论部分，将总结rtthread中堆设置的重要性，展望堆设置的未来发展，并进行结语。

通过这样的结构，读者可以全面了解rtthread中堆设置的相关内容，从而更好地理解其原理和作用。

"1.3 目的在本文中，我们的主要目的是探讨rtthread中堆设置的原理。

通过深入研究rtthread中堆设置的工作原理，可以帮助开发人员更深入地了解如何优化堆的使用，提升系统的性能和稳定性。

同时，通过对堆设置原理的解析，也可以帮助开发人员更好地理解rtthread的内部机制，为日后的开发和调试工作提供更加清晰的指导和帮助。

通过本文的学习，读者能够更好地掌握rtthread操作系统的核心概念和原理，从而更加熟练地应用这些知识进行系统开发和优化工作。

2.正文2.1 rtthread中堆的概念及作用在rtthread中，堆是用来存放动态分配内存的区域。

堆是由系统在程序运行时动态管理的，程序员可以根据需要在堆中动态分配内存空间，而不需要在编写程序时提前确定内存分配的大小。

堆的作用主要体现在以下几个方面：1. 动态内存分配：堆为程序提供了一种灵活的内存分配方式，可以根据实际情况动态给变量分配内存，避免了静态内存分配时出现内存浪费或内存不足的情况。

从0到1教你写RT-Thread之线程的定义《《《《《正文》》》》》《前言》本章是我们真正从从 0 到 1 写RT-Thread的第一章，属于基础中的基础，必须要学会创建线程，并重点掌握线程是如何切换的。

因为线程的切换是由汇编代码来完成的，所以代码看起来比较难懂，但是我会尽力把代码讲得透彻。

如果本章内容学不会，后面的内容根本无从下手。

在这章中，我们会创建两个线程，并让这两个线程不断地切换，线程的主体都是让一个变量按照一定的频率翻转，通过KEIL的软件仿真功能，在逻辑分析仪中观察变量的波形变化，最终的波形图具体见图 6-1。

其实，图 6-1 的波形图的效果，并不是真正的多线程系统中线程切换的效果图，这个效果其实可以完全由裸机代码来实现，具体见代码清单 6-1。

在多线程系统中，两个线程不断切换的效果图应该像图 6-2 所示那样，即两个变量的波形是完全一样的，就好像CPU在同时干两件事一样，这才是多线程的意义。

虽然两者的波形图一样，但是，代码的实现方式是完全不一样的，由原来的顺序执行变成了线程的主动切换，这是根本区别。

这章只是开始，我们先掌握好线程是如何切换，在后面章节中，我们会陆续的完善功能代码，加入系统调度，实现真正的多线程。

千里之行，始于本章节，不要急。

《什么是线程》在裸机系统中，系统的主体就是 main 函数里面顺序执行的无限循环，这个无限循环里面 CPU 按照顺序完成各种事情。

在多线程系统中，我们根据功能的不同，把整个系统分割成一个个独立的且无法返回的函数，这个函数我们称为线程。

线程的大概形式具体见代码清单 6-2。

《创建线程》1、定义线程栈我们先回想下，在一个裸机系统中，如果有全局变量，有子函数调用，有中断发生。

那么系统在运行的时候，全局变量放在哪里，子函数调用时，局部变量放在哪里，中断发生时，函数返回地址发哪里。

如果只是单纯的裸机编程，它们放哪里我们不用管，但是如果要写一个RTOS，这些种种环境参数，我们必须弄清楚他们是如何存储的。

rtthread 项目例程RT-Thread 是一个开源的物联网操作系统，以其高效、灵活和可靠的特性，被广泛应用于各种嵌入式设备和物联网应用中。

本文将以一个实际的 RT-Thread 项目例程为例，来展示其功能和应用场景。

这个项目例程是一个智能家居控制系统，它可以实现远程控制家庭中的各种设备，例如灯光、温度、门窗等。

用户可以通过手机或者电脑上的应用程序来实时监控和控制家中的各种设备。

我们需要在RT-Thread 上创建一个通信模块，该模块可以与手机或电脑上的应用程序进行通信。

通过这个模块，用户可以与智能家居系统进行交互，发送指令和接收信息。

这个通信模块需要支持多种通信协议，例如 Wi-Fi、蓝牙或者 Zigbee。

这样，用户可以根据自己的需求选择合适的通信方式。

接下来，我们需要连接各种设备到智能家居系统上。

例如，我们可以通过GPIO 接口将灯光、温度传感器、门窗传感器等设备连接到RT-Thread 上。

这样，智能家居系统就可以获取到这些设备的状态信息，并根据用户的指令进行相应的控制。

例如，当用户发送开灯指令时，智能家居系统会通过 GPIO 接口控制灯光的开关。

除了基本的设备控制功能，智能家居系统还可以实现一些高级功能，例如定时控制、情景模式等。

用户可以通过应用程序设置定时任务，例如在某个时间点打开灯光，或者在某个温度阈值达到时发送警报。

情景模式可以让用户一键切换不同的家居状态，例如回家模式、离家模式等。

智能家居系统还可以集成语音控制功能。

用户可以通过语音指令来控制家中的各种设备，例如“打开客厅的灯光”或者“调高温度”。

为了实现语音控制功能，我们可以使用一个语音识别模块，并将其连接到RT-Thread 上。

这样，用户就可以通过语音与智能家居系统进行交互。

RT-Thread 项目例程中的智能家居控制系统具有多种功能和应用场景。

它可以实现远程控制、定时控制、情景模式和语音控制等功能，为用户带来便利和舒适的生活体验。

MDK工程
5
11.5 本章小结
0 1
12.1 FinSH介 绍
0 2
12.2 FinSH内 置命令
0 4
12.4 FinSH功 能配置
0 6
12.6 本章 小结
0 3
12.3 自定 义FinSH 命令
0 5
12.5 FinSH应 用示例
13.1 I/O设备介绍
13.2 创建和注册I/O 设备
13.3 访问I/O设备 13.4 本章小结
第二篇 组件篇
0 1
第11章 Env辅助开 发环境
0 2
第12章 FinSH控 制台
0 3
第13章 I/O设备管 理
0 4
第14章 通 用外设接口
0 6
第16章 网 络框架
0 5
第15章 虚 拟文件系统
1
11.1 Env简介
11.2 Env的功 2
能特点
3 11.3 Env工程
构建示例
4 11.4 构建更多
最新版读书笔记，下载可以直接修改
《嵌入式实时操作系统 RT Thread设计与实现》
PPT书籍导读
读书笔记模板
最
新
版
本
本书关键字分析思维导图
ቤተ መጻሕፍቲ ባይዱ
功能
环境
示例
线程
内存
系统
实时操作系统
第章
管理
内核 应用
工作
小结
网络
组件
设备
接口
机制
架构
目录
01 第一篇 内核篇
附录A
03 menuconfig配置选 项
02 第二篇 组件篇
15.7 本章小结

rtthread任务调度原理rt-thread是一个开源的实时操作系统，广泛应用于嵌入式系统中。

它具有高效的任务调度机制，能够有效地管理和调度系统中的各个任务。

本文将从任务调度的原理和实现方式两个方面介绍rt-thread任务调度的工作原理。

一、任务调度的原理rt-thread采用的是抢占式的优先级调度算法。

此算法通过为每个任务分配优先级，并根据优先级来决定任务的执行顺序。

具体来说，rt-thread将任务划分为两种类型：线程和实时线程。

线程是最基本的任务单元，通过线程来实现系统中不同功能的并发执行。

每个线程都有自己的优先级，优先级高的线程在系统空闲时会被优先执行。

线程的调度是通过rt-thread内核中的调度器来完成的。

实时线程是一种特殊的线程，它具有固定的周期和执行时间要求。

为了满足实时线程的要求，rt-thread引入了时钟滴答机制，以固定的时间间隔来调度实时线程的执行。

时钟滴答机制是rt-thread 的核心功能之一，它通过硬件定时器来实现，确保实时线程能够按时执行。

任务调度的过程是在时钟滴答中完成的。

每当时钟滴答到来时，调度器会根据当前任务的状态和优先级来选择下一个要执行的任务，并进行上下文切换。

上下文切换是指将当前任务的上下文保存起来，并恢复下一个任务的上下文，使其能够继续执行。

二、任务调度的实现方式rt-thread任务调度的实现方式主要包括任务控制块、就绪队列和调度器三个部分。

任务控制块（TCB）是rt-thread中用于管理任务的数据结构，它包含了任务的状态、优先级、堆栈等信息。

每个任务都有一个对应的任务控制块，通过任务控制块可以对任务进行管理和调度。

就绪队列是用来保存所有处于就绪状态的任务的数据结构，它按照任务的优先级进行排序。

当任务进入就绪状态时，会被插入到就绪队列中的适当位置。

调度器会从就绪队列中选择优先级最高的任务进行执行。

调度器是rt-thread中的核心组件，它负责任务的调度和上下文切换。

RTThread学习笔记——对线程的个⼈了解线程？它是啥？ 在我们刚开始进⼊嵌⼊式软件的编程领域时，每次都会接触到⼀个函数——main函数，在裸机的编程中，程序的执⾏流程就是在main 函数中进⾏的，main函数也可以理解为⼀个线程，它也有它的栈空间来存储变量。

但是，如果有许多线程呢，怎样来区分它们？⼜怎样来分配存储空间？ 对于这个问题，RTThread有它的解决办法。

⾸先是线程栈 栈，是⼀种经典的储存结构，RTThread为每个线程都分配了栈空间，来看看它是怎样定义的。

ALIGN(RT_ALIGN_SIZE) //线程栈对齐static rt_uint8_t rt_led1_thread_stack[1024]; //定义线程栈 这是⼀个rt_uint8_t（RTThread中的宏定义，⽆符号8位）类型的全局数组，第⼀句话是为了栈空间对齐，使得CPU对数据的访问更加⾼效，第⼆句就是线程的具体定义了，这⾥定义1024的长度。

然后是线程的ID卡——线程控制块 在操作系统中，常常有许多的线程在运⾏，⾯对着这么多的的线程，⾃然需要⼀个⾝份块来标识每个线程，使得系统便于管理。

⽽这个⾝份，就是线程控制块。

具体定义如下：struct rt_thread{/* rt object */char name[RT_NAME_MAX]; /**< the name of thread */rt_uint8_t type; /**< type of object */rt_uint8_t flags; /**< thread's flags */#ifdef RT_USING_MODULEvoid *module_id; /**< id of application module */#endifrt_list_t list; /**< the object list */rt_list_t tlist; /**< the thread list *//* stack point and entry */void *sp; /**< stack point */void *entry; /**< entry */void *parameter; /**< parameter */void *stack_addr; /**< stack address */rt_uint32_t stack_size; /**< stack size *//* error code */rt_err_t error; /**< error code */rt_uint8_t stat; /**< thread status *//* priority */rt_uint8_t current_priority; /**< current priority */rt_uint8_t init_priority; /**< initialized priority */#if RT_THREAD_PRIORITY_MAX > 32rt_uint8_t number;rt_uint8_t high_mask;#endifrt_uint32_t number_mask;#if defined(RT_USING_EVENT)/* thread event */rt_uint32_t event_set;rt_uint8_t event_info;#endif#if defined(RT_USING_SIGNALS)rt_sigset_t sig_pending; /**< the pending signals */rt_sigset_t sig_mask; /**< the mask bits of signal */void *sig_ret; /**< the return stack pointer from signal */rt_sighandler_t *sig_vectors; /**< vectors of signal handler */void *si_list; /**< the signal infor list */#endifrt_ubase_t init_tick; /**< thread's initialized tick */rt_ubase_t remaining_tick; /**< remaining tick */struct rt_timer thread_timer; /**< built-in thread timer */void (*cleanup)(struct rt_thread *tid); /**< cleanup function when thread exit *//* light weight process if present */#ifdef RT_USING_LWPvoid *lwp;#endifrt_uint32_t user_data; /**< private user data beyond this thread */}; 看起来线程控制块的定义⾮常复杂，实际上，线程控制块的主要包含信息有对象成员相关（RTT(hread)通过对象来进⾏管理），线程链表相关（RTT通过线程链表实现调度，也被称为优先级表/就绪链表），线程栈相关和线程本⾝的相关地址。

rtthread 任务调度原理## RT-Thread 任务调度原理RT-Thread是一个实时操作系统（RTOS），其任务调度原理是其核心设计之一。

任务调度是操作系统的关键功能之一，它决定了任务的执行顺序和时间分配。

RT-Thread采用抢占式优先级调度算法，下面将介绍RT-Thread任务调度的原理。

### 任务调度器RT-Thread的任务调度器是操作系统内核中的一个重要组件，主要负责管理和调度任务。

任务调度器根据任务的优先级和状态来决定任务的执行顺序。

### 任务控制块（TCB）每个任务在RT-Thread中都有一个对应的任务控制块（Task Control Block，TCB），TCB是一个数据结构，用于描述和管理任务的各种信息。

TCB中包含了任务的优先级、状态、栈空间等。

### 任务状态RT-Thread中的任务有以下几种状态：1. 就绪态（Ready）：任务已经创建完成，但还未执行。

2. 运行态（Running）：任务正在执行。

3. 阻塞态（Blocked）：任务由于某些原因暂时无法执行，如等待信号量、等待事件等。

4. 挂起态（Suspended）：任务被挂起，不会被调度执行。

### 优先级调度算法RT-Thread采用抢占式优先级调度算法，具体如下：1. 在就绪队列中，任务按照优先级由高到低排序。

当就绪队列中只有一个任务时，该任务被调度执行。

2. 当有新的任务就绪或者当前任务被阻塞等原因无法继续执行时，调度器会选择优先级最高的就绪任务来执行。

3. 当高优先级任务被调度执行后，低优先级任务会被挂起，等待下一次调度执行。

### 任务调度过程下面是RT-Thread任务调度的基本流程：1. 系统启动后，创建和初始化空闲任务。

空闲任务是一个特殊任务，当没有其他任务可以运行时，被调度器执行。

2. 创建其他任务，并设置它们的优先级和初始状态为就绪态。

3. 启动调度器，开始任务调度。

4. 调度器会根据任务的优先级来选择一个就绪任务，将其状态设置为运行态，切换到该任务执行。

RT-Thread 内核实验 1 任务的基本管理
实验目的：
理解 RTOS 中任务管理的基本原理，了解任务的基本状态及其变迁过程； 掌握 RT-Thread 任务管理子系统中的任务创建，启动，延时机制 掌握 RT-Thread 任务管理子系统中静态任务与动态任务创建的区别
实验设计：
为了体现任务的状态切换过程，本实验设计了两个线程，分别是 thread1，thread2，此外，系统 中还有另外一个空闲任务，当没有其他任务运行时，系统自动调度空闲任务并投入运行。
实验流程：
1) 系统进入应用程序入口 2) 初 始 化 静 态 线 程 thread1 ， 线 程 的 入 口 是 thread1_entry, 参 数 是 RT_NULL ， 线 程 栈 是 thread1_stack,优先级是 30，时间片是 10 个 OS Tick 3) 启动线程 thread1 4) 创建动态线程 thread2，线程的入口是 thread2_entry,，参数是 RT_NULL，栈空间是 512，优 先级是 31，时间片是 25 个 OS Tick 5) 启动线程 thread2 6) [1]系统首先调度 thread1 投入运行，打印第 0 次运行的信息，然后通过延时函数将自己挂起 100 个 OS Tick，系统转入调度 thread2 投入运行 7) [2]Thread2 打印第 0 次运行信息，然后通过延时函数将自己挂起 50 个 OS Tick 8) [3]系统中无任务运行，转入调度空闲任务 9) [4]50 个 OS Tick 时间后，Thread2 被唤醒，打印第 1 次运行的信息，继续通过延时函数将自 己挂起 50 个 OS Tick 10) [5]系统中无任务运行，系统转入调度空闲任务，运行 50 个 OS Tick

rtthread设计与实现RT-Thread 是一个开源的实时操作系统（RTOS），它主要适用于嵌入式系统开发。

RT-Thread 具有高度可定制性，并且提供了丰富的中间件组件，例如TCP/IP 网络堆栈、文件系统、GUI 图形界面等。

RT-Thread 的设计和实现主要包括以下几个部分：1、内核：RT-Thread 的内核基于组件化的设计思想，提供了一个可配置的核心框架。

核心组件包括：(1)RT-Thread Scheduler：这是RT-Thread 的核心调度器，负责任务管理和调度。

(2)RT-Thread Timer：定时器管理，用于实现延迟操作和定时任务。

(3)RT-Thread Mailbox：用于实现任务间的通信和同步。

(4)RT-Thread Message Queue：消息队列，用于任务间的数据传输。

(5)RT-Thread Memory Pool：内存池管理，用于动态内存分配和管理。

2、组件：RT-Thread 提供了一系列中间件组件，例如：(1)RT-Thread Networking：TCP/IP 网络协议栈，支持各种网络接口和协议。

(2)RT-Thread File System：支持多种文件系统，例如Fat 文件系统、ext2/3 文件系统等。

(3)RT-Thread GUI：支持多种图形界面，例如Qt、MiniGUI 等。

(4)RT-Thread Device Driver：设备驱动框架，用于支持各种硬件设备的驱动程序开发。

3、工具链：RT-Thread 提供了一套完整的工具链，包括编译器、调试器、烧录器等。

同时，RT-Thread 支持多种编程语言，例如C/C++、Python 等。

4、应用编程接口（API）：RT-Thread 提供了一套简单易用的API，使得开发者可以方便地使用RT-Thread 的各种功能。

例如，通过RT-Thread 的API 可以创建任务、管理任务、管理内存、管理网络连接等。

RT-Thread——线程管理1.线程的概念线程可以理解为⼀个个相互独⽴运⾏的单元任务。

这些任务共同使⽤CPU和内存空间等系统资源，不过，每⼀时刻，只能有⼀个线程在运⾏。

各个线程的运⾏是相互独⽴，不断切换的，所以线程都要有⾃⼰的堆栈，从⽽再次运⾏时能够恢复运⾏环境。

2.线程的调度RT-Thread提供的线程调度器是基于优先级的全抢占式调度，但中断函数和临界段程序是不可抢占的。

系统总共⽀持256个优先级，即0~255，数值越⼩，优先级越⾼，0为最⾼优先级，255是空闲线程的优先级，⽤户⼀般不会使⽤。

当有⽐当前运⾏线程优先级更⾼的线程就绪时，当前线程将⽴刻被换出，⾼优先级线程抢占运⾏。

RT-Thread还⽀持创建相同优先级的线程。

这些线程采⽤时间⽚轮转进⾏调度，但前提是没有更⾼优先级的线程出现。

所有准备好的线程都链接到了优先级队列中，选择优先级⾼的线程就是在优先级数组中寻找最⾼优先级线程对应的⾮空链表。

3.线程的状态操作系统中的线程有的在执⾏，有的被抢占，还有的即将被运⾏，也就是说有多种运⾏状态。

RT-Thread分5种运⾏状态：①初始态：RT_THREAD_INIT，创建线程时设置为初始态；②就绪态：RT_THREAD_READY，线程在就绪列表中，具备执⾏的条件，等待CPU运⾏；③运⾏态：RT_THREAD_RUNNING，线程正在被CPU执⾏；④挂起态：RT_THREAD_SUSPEND，线程正在等待某个信号量、消息队列、、事件或被延时等情况，不在就绪列表；⑤关闭态：RT_THREAD_CLOSE，线程运⾏结束，等待系统回收资源。

线程的状态是不断转换的，⽤⼀张图来表⽰线程状态迁移：4.建⽴线程实例下⾯介绍⼀下线程创建的步骤，以下发⽣在main.c源⽂件中。

（1）定义线程控制块和声明线程函数static rt_thread_t example_thread = RT_NULL; //初始化线程控制块static void example_thread_entry(void *parameter); //线程函数声明（2）在main函数中创建线程example_thread = //线程控制块指针rt_thread_create("example"， //线程名字example_thread_entry, //线程⼊⼝函数RT_NULL, //线程⼊⼝函数参数512， //线程栈⼤⼩3， //线程的优先级20); //线程时间⽚（单位tick）// 启动线程，开启调度if(example_thread != RT_NULL)rt_thread_startup(example_thread);elsereturn -1;（3）编写线程函数内容static void example_thread_entry(void *parameter){while(1){ //⽆限循环，该线程不会被系统删除//若⽆这个循环，则线程运⾏完毕后会被系统⾃动删除// ....⽤户⾃定义线程操作}}通过以上三个步骤，就能建⽴可运⾏的线程了。

Rt-thread：任务调度启动顺序：1 rtthread_startup进⾏对象初始化2 rt_application_init进⾏线程对象初始化rt_thread_create创建线程1 调⽤rt_object_allocate(RT_Object_Class_Thread,name);获取线程对象并创建线程(a) rt_object_get_information(type)，根据type获取线程的对象实例。

查找⽅法是遍历rt_object_container并找到type能匹配上的。

Rt-thread中所有的对象都包含在object.c中的静态变量rt_object_container中static struct rt_object_information rt_object_container[RT_Object_Info_Unknown] ={/* initialize object container - thread */{RT_Object_Class_Thread, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Thread), sizeof(struct rt_thread)},#ifdef RT_USING_SEMAPHORE/* initialize object container - semaphore */{RT_Object_Class_Semaphore, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Semaphore), sizeof(struct rt_semaphore)},#endif#ifdef RT_USING_MUTEX/* initialize object container - mutex */{RT_Object_Class_Mutex, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Mutex), sizeof(struct rt_mutex)},#endif#ifdef RT_USING_EVENT/* initialize object container - event */{RT_Object_Class_Event, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Event), sizeof(struct rt_event)},#endif#ifdef RT_USING_MAILBOX/* initialize object container - mailbox */{RT_Object_Class_MailBox, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_MailBox), sizeof(struct rt_mailbox)},#endif#ifdef RT_USING_MESSAGEQUEUE/* initialize object container - message queue */{RT_Object_Class_MessageQueue, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_MessageQueue), sizeof(structrt_messagequeue)},#endif#ifdef RT_USING_MEMHEAP/* initialize object container - memory heap */{RT_Object_Class_MemHeap, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_MemHeap), sizeof(struct rt_memheap)},#endif#ifdef RT_USING_MEMPOOL/* initialize object container - memory pool */{RT_Object_Class_MemPool, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_MemPool), sizeof(struct rt_mempool)},#endif#ifdef RT_USING_DEVICE/* initialize object container - device */{RT_Object_Class_Device, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Device), sizeof(struct rt_device)},#endif/* initialize object container - timer */{RT_Object_Class_Timer, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Timer), sizeof(struct rt_timer)},#ifdef RT_USING_MODULE/* initialize object container - module */{RT_Object_Class_Module, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Module), sizeof(struct rt_dlmodule)},#endif};(b) object = (struct rt_object *)RT_KERNEL_MALLOC(information->object_size); 根据该对象的object_size⼤⼩⽣成线程对象。

/* 初始化线程1 */ /* 线程的入口是thread1_entry，参数是RT_NULL * 线程栈是thread1_stack * 优先级是200，时间片是10个OS Tick */ result = rt_thread_init(&thread1, "thread1", thread1_entry, RT_NULL, &thread1_stack[0], sizeof(thread1_stack), 30, 10); /* 启动线程 */ if (result == RT_EOK) rt_thread_startup(&thread1); /* 创建线程2 */ /* 线程的入口是thread2_entry, 参数是RT_NULL * 栈空间是512，优先级是250，时间片是25个OS Tick */ thread2_ptr = rt_thread_create("thread2", thread2_entry, RT_NULL, 512, 31, 25); /* 启动线程 */ if (thread2_ptr != RT_NULL) rt_thread_startup(thread2_ptr); return 0; }
源程序说明：
/* 线程1的对象和运行时用到的栈 */ static struct rt_thread thread1; ALIGN(4) static rt_uint8_t thread1_stack[512]; /* 线程1入口 */ void thread1_entry(void* parameter) { int i; while (1) { for (i = 0; i < 10; i ++) { rt_kprintf("%d\n", i); /* 延时100个OS Tick */ rt_thread_delay(100); } } } /* 线程2入口 */ void thread2_entry(void* parameter) { int count = 0; while (1) { rt_kprintf("Thread2 count:%d\n", ++count); /* 延时50个OS Tick */ rt_thread_delay(50); } } /* 用户应用程序入口 */ int rt_application_init() { rt_thread_t thread2_ptr; rt_err_t result;

1. FreeRTOS特点：免费嵌入式软件源代码，设计小巧，简单易用，有许多支持架构的免费开发工具，可移植性非常好的源代码结构，主要用C.任务调度：对任务优先级分配没有限制 - 可以为多个实时任务分配相同的优先级，0优先级为最低的优先级。

固定优先级抢占式，调度器保证总是在所有可运行的任务中训责具有最高优先级的任务；被选中的任务具有不止一个任务，调度器会让这些任务轮流运行。

对可创建的实时任务数量没有软件限制。

对于优先级反转，采用优先级继承机制。

支持实时任务和协同程序。

任务运行要在主函数中启动调度器，任务在主函数或其他任务中声明拥有心跳中断钩子函数允许调度器的关闭与开启、中断的开关通讯机制：队列、二进制信号量、计数信号量、递归信号量和互斥体，用于任务之间的通信和同步，或实时任务和中断之间（没有邮箱机制）创新事件组（或事件标志）实施。

具有优先级继承的互斥体。

信号量和队列没有控制块，使用前要在主函数中定义中断服务程序要在主函数中声明，如：声明：_dos_setvect(0x82,vExampleInterruptHandler)而在任务中要用_asm{int 0x82}进入中断。

2.UC/0S特点：μC/OS-II是一种完整的、可移植的、可固化的、可剪裁的占先式实时多任务内核，绝大多数代码用c语言编写，与微处理器密切相关的部分用汇编语言编写，不过开源收费任务调度：对任务优先级分配有限制 - 一个优先级只能有一个任务，通常最低的两个优先级被赋给空闲任务和统计任务，0优先级为最高的优先级。

固定优先级抢占式，调度器保证总是在所有可运行的任务中训责具有最高优先级的任务；不支持时间片轮询机制。

因为优先级不能相同，所以不支持优先级继承机制，UC/0S在互斥信号量中引用了优先级提升的方法。

任务运行不需要在主函数中启动调度器，任务在主函数或其他任务中创建允许调度器的关闭与开启、中断的开关通讯机制：二进制信号量、计数信号量、消息邮箱、消息队列、事件标志组用于任务之间的通信和同步，或实时任务和中断之间3.RT-Thread特点：RT-Thread是一款来自中国的开源嵌入式实时操作系统，除了类似FreeRTOS和UCOS的实时操作系统内核外，也包括一系列应用组件和驱动框架，遵循GPLv2+许可证，实时操作系统内核及所有开源组件可以免费在商业产品中使用，不需要公布应用源码，没有任何潜在商业风险。

rt-thread原理RT-Thread是一个基于实时操作系统（RTOS）的开源项目，它提供了一个可嵌入式的实时操作系统内核，适用于各种微处理器、微控制器和DSP等嵌入式设备。

RT-Thread的设计目标是为嵌入式系统提供高效、稳定和可靠的实时运行环境。

1. RT-Thread内核架构RT-Thread内核采用了多线程模型，支持多任务并发执行。

它的内核架构主要由以下几个组件组成：a. 调度器：RT-Thread内核提供了一个简单的优先级调度器，用于管理多个任务的执行顺序。

调度器基于优先级对任务进行调度，高优先级的任务优先执行。

b. 任务管理：RT-Thread内核提供了任务管理功能，可以创建、删除、挂起和恢复任务。

每个任务都有一个独立的栈空间和优先级，可以通过任务切换实现多任务并发执行。

c. 时钟管理：RT-Thread内核提供了时钟管理功能，可以定时触发任务的执行。

通过时钟管理，可以实现定时任务和延时功能。

d. 中断管理：RT-Thread内核提供了中断管理功能，可以处理外部中断和软件中断。

中断处理函数可以在中断发生时被调用，执行特定的操作。

e. 内存管理：RT-Thread内核提供了内存管理功能，可以动态分配和释放内存。

内存管理模块可以有效地管理系统资源，提高系统的稳定性和可靠性。

f. 设备驱动：RT-Thread内核提供了设备驱动框架，支持各种外设的驱动。

设备驱动模块可以与硬件进行交互，实现设备的读写操作。

2. RT-Thread应用RT-Thread可以用于各种嵌入式系统的开发，包括通信设备、工业控制、医疗设备、智能家居等。

它具有以下几个特点：a. 灵活性：RT-Thread内核具有可配置的特性，可以根据具体需求进行定制。

用户可以选择需要的功能模块，以减小内核的体积和内存占用。

b. 可移植性：RT-Thread内核支持多种处理器架构和编译器，可以在不同的硬件平台上进行移植。

它提供了一套统一的API接口，方便应用程序的移植和开发。

RT-Thread--线程管理线程管理的功能特点RT-Thread系统中线程是调度的最⼩单位；线程分为：系统线程和⽤户线程，系统线程是由 RT-Thread 内核创建的线程，⽤户线程是由应⽤程序创建的线程，这两类线程都会从内核对象容器中分配线程对象，当线程被删除时，也会被从对象容器中删除RT-Thread 的线程调度器是抢占式的，主要的⼯作就是从就绪线程列表中查找最⾼优先级线程，保证最⾼优先级的线程能够被运⾏，最⾼优先级的任务⼀旦就绪，总能得到 CPU 的使⽤权。

当调度器调度线程切换时，先将当前线程上下⽂保存起来，当再切回到这个线程时，线程调度器将该线程的上下⽂信息恢复。

线程的⼯作机制线程控制块线程控制块由结构体 struct rt_thread 表⽰，线程控制块是操作系统⽤于管理线程的⼀个数据结构，它会存放线程的⼀些信息，例如优先级、线程名称、线程状态等，也包含线程与线程之间连接⽤的链表结构，线程等待事件集合等/*** Thread structure*/struct rt_thread{/* rt object */char name[RT_NAME_MAX]; /**< the name of thread */rt_uint8_t type; /**< type of object */rt_uint8_t flags; /**< thread's flags */#ifdef RT_USING_MODULEvoid *module_id; /**< id of application module */#endifrt_list_t list; /**< the object list */rt_list_t tlist; /**< the thread list *//* stack point and entry */void *sp; /**< stack point */void *entry; /**< entry */void *parameter; /**< parameter */void *stack_addr; /**< stack address */rt_uint32_t stack_size; /**< stack size *//* error code */rt_err_t error; /**< error code */rt_uint8_t stat; /**< thread status *//* priority */rt_uint8_t current_priority; /**< current priority */rt_uint8_t init_priority; /**< initialized priority */#if RT_THREAD_PRIORITY_MAX > 32rt_uint8_t number;rt_uint8_t high_mask;#endifrt_uint32_t number_mask;#if defined(RT_USING_EVENT)/* thread event */rt_uint32_t event_set;rt_uint8_t event_info;#endif#if defined(RT_USING_SIGNALS)rt_sigset_t sig_pending; /**< the pending signals */rt_sigset_t sig_mask; /**< the mask bits of signal */void *sig_ret; /**< the return stack pointer from signal */rt_sighandler_t *sig_vectors; /**< vectors of signal handler */void *si_list; /**< the signal infor list */#endifrt_ubase_t init_tick; /**< thread's initialized tick */rt_ubase_t remaining_tick; /**< remaining tick */struct rt_timer thread_timer; /**< built-in thread timer */void (*cleanup)(struct rt_thread *tid); /**< cleanup function when thread exit *//* light weight process if present */#ifdef RT_USING_LWPvoid *lwp;#endifrt_uint32_t user_data; /**< private user data beyond this thread */};typedef struct rt_thread *rt_thread_t;nit_priority 是线程创建时指定的线程优先级，在线程运⾏过程当中是不会被改变的（除⾮⽤户执⾏线程控制函数进⾏⼿动调整线程优先级）；cleanup 会在线程退出时，被空闲线程回调⼀次以执⾏⽤户设置的清理现场等⼯作；user_data 可由⽤户挂接⼀些数据信息到线程控制块中，以提供类似线程私有数据的实现。