RT-Thread Smart 致力于物联网和边缘计算领域的开源。

目前对 嵌入式操作系统 有巨大的需求，你建立的操作系统最好是开源的。RT-Thread 项目的研发团队花了两年时间，研发出了该项目的最新成果：RT-Thread Smart。这是一款微内核的操作系统，主要针对中高端的处理器，如具有内存管理单元（MMU）的 RISC-V 或 Arm Cortex-A，为嵌入式领域的所有行业提供了一个具有竞争力的、基于 POSIX 的软件平台。

谁需要 RT-Thread Smart?

RT-Thread Smart 是一款专业的、高性能的微内核操作系统，用于实时应用。它为所有市场的嵌入式设备提供了开源基础，如安全（IP 摄像头）、工业控制、车载设备、消费电子及其他嵌入式科技应用，可谓一切场景。它的意义在于：不像传统的物联网操作系统，一个微内核的操作系统可以填补传统实时操作系统 RTOS 和相对大型的操作系统如 Linux 之间的空白，实现实时性能、成本、安全、启动速度等等各方面之间的最佳平衡。

RT-Thread Smart 的架构

RT-Thread Smart 通过 MMU 和系统调用将系统分割为内核模式和用户模式，并为每种模式区分了地址空间（一个 32 位系统可以提供 4G 地址空间）。

（RT-Thread, CC BY-SA 4.0）

RT-Thread Smart 内核包括平台的基础功能，并支持定制化。RT-Thread Smart 的用户应用环境使用 musl libc 来提供 POSIX 接口调用和 C 语言的运行时支持。它也继承了原始的 RT-Thread 生态系统，使用 SCons 或者其他编译工具如 Autotools、Makefile、CMake 等等来支持开发，以及 RT-Thread 开箱即用的在线软件包（撰写本文时超过 342 个）。你甚至可以将 Linux 应用程序（如 wget/cURL、BusyBox、OpenSSL 和 Simple DirectMedia Layer）移植到你的平台。

压缩的 RT-Thread Smart 内核仅 217 KB，搭配一个 127 KB 的根文件系统。大约 2 MB的存储占用。包括了对文件系统、网络协议栈、多媒体的完整支持。RT-Thread 只需要 3 到 5 秒完成启动，而在不运行其他功能组件时，RT-Thread Smart 需要的启动及准备时间不到 500ms。

通过其集成的 Persimmon 用户界面（UI）组件，RT-Thread Smart 从上电到运行 UI 需要大约 1 秒。换句话说，这是一个非常轻巧快速的系统。当然，“实时”不是指启动，而是指系统随着时间推进而表现出的一致性。对于 RT-Thread ，实时性能需要优先考虑，中断时延小于 1μs，满足大部分实时性要求严格的场景需求。

RT-Thread Smart 和 RT-Thread

你可能想知道 RT-Thread Smart 和 RT-Thread 之间的不同。简单来说， RT-Thread Smart 是一个基于 RT-Thread RTOS 的操作系统，但它整合了用户态的处理过程。RT-Smart 的内核部分本质上是 RT-Thread RTOS，它在虚拟地址上运行，增加了进程管理，使用进程间通信机制（IPC）、虚拟内存/地址空间管理、ELF 加载器等等，以上特性全部在 RT-Thread RTOS 内实现，当这些组件被禁用时，RT-Smart 会回归 RT-Thread RTOS。

以下是对比：

RT-Thread RTOS 非常紧凑，它的所有应用和子系统都编译到镜像中，多线程应用运行并分享相同的地址空间。

RT-Thread Smart 是独立的。系统和应用是分别编译和运行的。应用拥有完整且互相隔离的地址空间。它也继承了 RT-Thread 优秀的实时性，同时也具有 POSIX 环境的特性。

类似地，它们都与 RT-Thread API 兼容。RT-Thread RTOS 的应用可以被平滑移植到 RT-Thread Smart。

嵌入式开源

RT-Thread Smart 是一个开源项目，项目地址：GitHub。你可以下载代码和文档，尝试一下，并提交评论和反馈，将该项目传播给更多开源倡导者。嵌入式系统属于它们的用户，有太多的嵌入式开发人员没有找到太多可用的嵌入式系统。

如果你是开发人员，请帮助改进 RT-Thread Smart。随着 RT-Thread 项目的不断推进，我们希望创建物联网和边缘计算的令人激动的开源世界。

via: https://opensource.com/article/21/7/rt-thread-smart

作者：Zhu Tianlong 选题：lujun9972 译者：tendertime 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

由于物联网（IoT）的兴起，对硬件进行编程变得越来越普遍。RT-Thread 可以让你可以用 FinSH 从 Linux 命令行与设备进行沟通、

RT-Thread 是一个开源的实时操作系统，用于对物联网（IoT）设备进行编程。FinSH 是 RT-Thread 的命令行组件，它提供了一套操作界面，使用户可以从命令行与设备进行沟通。它主要用于调试或查看系统信息。

通常情况下，开发调试使用硬件调试器和 printf 日志来显示。但在某些情况下，这两种方法并不是很有用，因为它是从运行的内容中抽象出来的，而且它们可能很难解析。不过 RT-Thread 是一个多线程系统，当你想知道一个正在运行的线程的状态，或者手动控制系统的当前状态时，这很有帮助。因为它是多线程的，所以你能够拥有一个交互式的 shell，你可以直接在设备上输入命令、调用函数来获取你需要的信息，或者控制程序的行为。如果你只习惯于 Linux 或 BSD 等现代操作系统，这在你看来可能很普通，但对于硬件黑客来说，这是极其奢侈的，远超将串行电缆直接连线到电路板上以获取一丝错误的做法。

FinSH 有两种模式。

• C 语言解释器模式，称为 c-style。
• 传统的命令行模式，称为 msh（模块 shell）。

在 C 语言解释器模式下，FinSH 可以解析执行大部分 C 语言的表达式，并使用函数调用访问系统上的函数和全局变量。它还可以从命令行创建变量。

在 msh 模式下，FinSH 的操作与 Bash 等传统 shell 类似。

GNU 命令标准

当我们在开发 FinSH 时，我们了解到，在编写命令行应用程序之前，你需要熟悉 GNU 命令行标准。这个标准实践的框架有助于给界面带入熟悉感，这有助于开发人员在使用时感到舒适和高效。

一个完整的 GNU 命令主要由四个部分组成。

1. 命令名（可执行文件）：命令行程序的名称；
2. 子命令：命令程序的子函数名称。
3. 选项：子命令函数的配置选项。
4. 参数：子命令函数配置选项的相应参数。

你可以在任何命令中看到这一点。以 Git 为例：

git reset --hard HEAD~1

这一点可以分解为：

可执行的命令是 git，子命令是 reset，使用的选项是 --head，参数是 HEAD~1。

再举个例子：

systemctl enable --now firewalld

可执行的命令是 systemctl，子命令是 enable，选项是 --now，参数是 firewalld。

想象一下，你想用 RT-Thread 编写一个符合 GNU 标准的命令行程序。FinSH 拥有你所需要的一切，并且会按照预期运行你的代码。更棒的是，你可以依靠这种合规性，让你可以自信地移植你最喜欢的 Linux 程序。

编写一个优雅的命令行程序

下面是一个 RT-Thread 运行命令的例子，RT-Thread 开发人员每天都在使用这个命令：

usage: env.py package [-h] [--force-update] [--update] [--list] [--wizard]
                      [--upgrade] [--printenv]

optional arguments:
  -h, --help      show this help message and exit
  --force-update  force update and clean packages, install or remove the
                  packages by your settings in menuconfig
  --update        update packages, install or remove the packages by your
                  settings in menuconfig
  --list          list target packages
  --wizard        create a new package with wizard
  --upgrade       upgrade local packages list and ENV scripts from git repo
  --printenv      print environmental variables to check

正如你所看到的那样，它看起来很熟悉，行为就像你可能已经在 Linux 或 BSD 上运行的大多数 POSIX 应用程序一样。当使用不正确或不充分的语法时，它会提供帮助，它支持长选项和短选项。这种通用的用户界面对于任何使用过 Unix 终端的人来说都是熟悉的。

选项种类

选项的种类很多，按长短可分为两大类。

1. 短选项：由一个连字符加一个字母组成，如 pkgs -h 中的 -h 选项。
2. 长选项：由两个连字符加上单词或字母组成，例如，scons- --target-mdk5 中的 --target 选项。

你可以把这些选项分为三类，由它们是否有参数来决定。

1. 没有参数：该选项后面不能有参数。
2. 参数必选：选项后面必须有参数。
3. 参数可选：选项后可以有参数，但不是必需的。

正如你对大多数 Linux 命令的期望，FinSH 的选项解析非常灵活。它可以根据空格或等号作为定界符来区分一个选项和一个参数，或者仅仅通过提取选项本身并假设后面的内容是参数（换句话说，完全没有定界符）。

• wavplay -v 50
• wavplay -v50
• wavplay --vol=50

使用 optparse

如果你曾经写过命令行程序，你可能会知道，一般来说，你所选择的语言有一个叫做 optparse 的库或模块。它是提供给程序员的，所以作为命令的一部分输入的选项（比如 -v 或 --verbose）可以与命令的其他部分进行解析。这可以帮助你的代码从一个子命令或参数中获取一个选项。

当为 FinSH 编写一个命令时，optparse 包希望使用这种格式：

MSH_CMD_EXPORT_ALIAS(pkgs, pkgs, this is test cmd.);

你可以使用长形式或短形式，或者同时使用两种形式来实现选项。例如：

static struct optparse_long long_opts[] =
{
    {"help"        , 'h', OPTPARSE_NONE}, // Long command: help, corresponding to short command h, without arguments.
    {"force-update",  0 , OPTPARSE_NONE}, // Long comman: force-update, without arguments
    {"update"      ,  0 , OPTPARSE_NONE},
    {"list"        ,  0 , OPTPARSE_NONE},
    {"wizard"      ,  0 , OPTPARSE_NONE},
    {"upgrade"     ,  0 , OPTPARSE_NONE},
    {"printenv"    ,  0 , OPTPARSE_NONE},
    { NULL         ,  0 , OPTPARSE_NONE}
};

创建完选项后，写出每个选项及其参数的命令和说明：

static void usage(void)
{
    rt_kprintf("usage: env.py package [-h] [--force-update] [--update] [--list] [--wizard]\n");
    rt_kprintf("                      [--upgrade] [--printenv]\n\n");
    rt_kprintf("optional arguments:\n");
    rt_kprintf("  -h, --help      show this help message and exit\n");
    rt_kprintf("  --force-update  force update and clean packages, install or remove the\n");
    rt_kprintf("                  packages by your settings in menuconfig\n");
    rt_kprintf("  --update        update packages, install or remove the packages by your\n");
    rt_kprintf("                  settings in menuconfig\n");
    rt_kprintf("  --list          list target packages\n");
    rt_kprintf("  --wizard        create a new package with wizard\n");
    rt_kprintf("  --upgrade       upgrade local packages list and ENV scripts from git repo\n");
    rt_kprintf("  --printenv      print environmental variables to check\n");
}

下一步是解析。虽然你还没有实现它的功能，但解析后的代码框架是一样的：

int pkgs(int argc, char **argv)
{
    int ch;
    int option_index;
    struct optparse options;

    if(argc == 1)
    {
        usage();
        return RT_EOK;
    }

    optparse_init(&options, argv);
    while((ch = optparse_long(&options, long_opts, &option_index)) != -1)
    {
        ch = ch;

        rt_kprintf("\n");
        rt_kprintf("optopt = %c\n", options.optopt);
        rt_kprintf("optarg = %s\n", options.optarg);
        rt_kprintf("optind = %d\n", options.optind);
        rt_kprintf("option_index = %d\n", option_index);
    }
    rt_kprintf("\n");

    return RT_EOK;
}

这里是函数头文件：

#include "optparse.h"
#include "finsh.h"

然后，编译并下载到设备上。

硬件黑客

对硬件进行编程似乎很吓人，但随着物联网的发展，它变得越来越普遍。并不是所有的东西都可以或者应该在树莓派上运行，但在 RT-Thread，FinSH 可以让你保持熟悉的 Linux 感觉。

如果你对在裸机上编码感到好奇，不妨试试 RT-Thread。

via: https://opensource.com/article/20/9/hardware-command-line

作者：Alan Smithee 选题：lujun9972 译者：wxy 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

编程驱动一个微处理器芯片是相当有难度的，但在嵌入式系统开发上，实时操作系统可以为你解决很多此类的困难。

从通用计算的角度，操作系统是提供计算机基本功能的一组软件。操作系统保证了计算机硬件可以探测并响应外围器件（如键盘、屏幕、移动设备、打印机等），并管理内存空间和外部存储空间。

虽然一个 CPU 核心同一时间只能运行单个线程，但现代操作系统可以使多个程序表现的像是在同时运行。每一个任务执行的如此之短，一系列任务切换的如此之快，以至于看起来多个任务像是在并行进行。这一切都是由一个叫做 调度器 的子进程来控制的。

操作系统通常是为计算机准备的，安装在硬盘上，管理计算机所要执行的任务。

为什么实时操作系统对嵌入式系统而言不可或缺

我曾经在 2008 年接触过嵌入式软件，那时候我还是一名学生，正在学习 MCS-51 微处理器编程。因为我的主修专业是计算机科学，我在其它课程中的所有程序都是在 PC 上执行的。为微处理器芯片编程是完全不同的体验。人生中第一次，我看到我的程序在裸板上运行，即使到现在我仍然记得，在我看到自己人生中第一个走马灯程序成功运行时的那种兴奋和激动。

但那种兴奋转瞬即逝。随着为裸板写出越来越多的程序，我遇到了越来越多的问题。这种沮丧并不是我独有的。直接为芯片写程序很困难，这也是 PC 要运行操作系统的很重要的原因。不幸的是，微处理器芯片（或嵌入式系统）通常是没有操作系统的，它们只能采用“硬编码”的方式编程，没有操作系统帮助你管理代码的运行。

在以“硬编码”的方式为处理芯片编写代码的时候，可能会遇到下列问题：

并发

在裸板上是没有管理程序运行的现成守护进程的。嵌入式系统软件中，无可避免的要把所有的逻辑功能放在一个巨大的 while (1) 循环中。每个功能可能包含一个或多个延时函数。CPU 在运行延时函数的时候是顺序执行的，没有任何办法跨越一个不必要的延时。正因如此，运行事务的复位操作只能是等待。最终结果就是很多的 CPU 处理时间浪费在空循环上，这对任务的并发非常不利。

模块化

从软件工程的角度，高內聚低耦合原则在软件开发过程中被不厌其烦的频频强调，但是嵌入式软件的不同模块之间常常是重度耦合的，很多功能都集中在一个巨大的 while (1) 循环中，很难切分为模块。设计低耦合软件在编程上只是繁琐一些，但在嵌入式系统上，要低耦合就难以编写比较大型的软件。

与此同时，如果使用了看门狗定时器，程序员还得在调用延时函数时倍加小心。如果延时时间太长，主程序没有得到及时“喂狗”的时机，那么看门狗将在程序运行过程中被触发。嵌入式系统软件开发过程中，需要考虑的东西太多了，即便是个简单的延时函数，都不能掉以轻心。软件越复杂，就越需要细心。想象一下，试图将这一系列具有精细时间关系的交互功能拆分为模块会怎么样。

软件生态

很多高级的软件组件依赖于其所基于的底层操作系统的实现。举个自身的例子，我曾开发过一个基于 FreeModbus 的开源项目，原计划将它移植到多种平台上，包括裸板。但与适应不同操作系统的便利性相比，有些功能过于复杂，无法在所有裸机板上实现。更糟糕的是，很多硬件平台因为缺乏一致性，只能各自从头做起。

直至现在，我的 Modbus 栈仍然不支持在裸板上运行。

很多像 Realtek、TI 和 MediaTek 的大厂，所提供的 WiFi 软件开发工具只能在操作系统上运行，且他们不公开固件源码，所以在裸板上根本没法使用这些工具。

实时性

有些应用领域对实时性有要求，比如有些场景中，必须在特定的时间触发特定的软件操作。在工业控制场景，机器实体控制过程中，机械部件必须以确定的时间和确定的顺序执行动作。如果不能保证控制系统的实时性，整个机器可能出现功能异常，甚至危及工人生命。在裸板平台，所有的功能都塞在一个巨大的 while (1) 循环中，实时性无从保证。

重用性

重用性依赖于模块化。没谁愿意翻来覆去做一成不变的事，对程序员而言更是如此。这不单单是浪费时间，更要命的是这使得代码的维护异常复杂。尤其是，因为功能的实现依赖于底层的硬件，使用了不同芯片的不同硬件平台上，同样的功能必须适配不同的硬件平台。这种情况下，重新发明轮子是无法避免的。

实时操作系统的优势

幸运的是，现在有针对各种微处理器芯片的操作系统，它们被称为实时操作系统（RTOS），和大多数操作系统一样，它们拥有调度器，保证代码以可预见的顺序运行。

我是在 2010 年初次在裸板上使用实时操作系统。那时候，STM32 系列微处理器（MCU）开始流行，因为这种微处理器性能强大、功能丰富，很多人在上面跑操作系统。我使用的是 RT-Thread 操作系统，有很多基于它的现成组件可用。它使用的是 Apache 2.0 许可，和其它操作系统相比，我觉得这个很舒心。我已经基于它作为平台从事开发工作 10 年了。

使用实时操作系统为裸板编程，操作系统为我们解决了需要处理的大部分问题。

模块化

在操作系统支持下，整个软件可以分割为多个任务（即线程）。每个线程拥有自己独立的运行空间。线程之间互相独立，这促进了软件的模块化。

并发

如果一个线程有延时函数，它将自动让出 CPU 资源给需要 CPU 的线程，这提高了 CPU 的整体利用率，也提升了系统的并发性能。

实时性

实时操作系统从设计上就具备实时性。每个线程都被指定了特定的优先级，比较重要的线程设置为更高的优先级，不重要的线程优先级也低。正是以这种方式，软件整体的实时性得到了保证。

开发效率

操作系统提供了统一的抽象接口，这使得可重用组件得以不断积累，同时提升了开发效率。

操作系统是软件极客集体智慧的结晶。很多通用的软件功能，如信号量、事件提醒、邮箱、环形缓冲、单向链表、双向链表等，被抽象出来并实现了封装，可随时调用。

Linux、RT-Thread 等操作系统为五花八门的硬件实现了一致的硬件接口，也就是常说的设备驱动框架。正因如此，软件工程师可以专注于软件开发，而不用关心底层的硬件，也不用重复造轮子。

软件生态

RT-Thread 丰富的软件生态为大量的从业者带来了巨大的改变。操作系统带来的模块化和重用性，使得程序员可以基于 RT-Thread 封装出方便嵌入式系统开发使用的可重用组件。这些组件可以在其它项目中重用，也可以分享给其他的嵌入式应用开发者，以最大化软件的价值。

比如，LkdGui 是个开源的单色显示图形库，你可能在工业控制面板上简单而美观的设置界面上见过它。LkdGui 提供了像描点、画线、绘矩形及显示文本、按钮组件、进度条等绘图功能。

使用像 LkdGui 这样兼具扩展性和健壮性的功能库，程序员们可以在同行已有工作成果的基础上充分施展自己的才能。而这一切，没有实时操作系统这样一个统一的基础，是根本不可能的。

试用 RT-Thread

作为开源极客，我已经在 GitHub 上开源了一些嵌入式软件。在发布开源软件之前，我很少对他人谈及自己曾经的项目，因为不同的人在使用各种不同的微处理器芯片和硬件平台，我的代码极可能无法在他人的板子上运行。类似于 RT-Thread 这样的实时操作系统极大的提升了软件的可重用性，所以全世界的不同领域的专家得以就同一个项目展开探讨。这鼓励着越来越多的人分享和交流各自的项目。如果你在做裸板的软件开发，下次可以试试 TR-Thread。

via: https://opensource.com/article/20/6/open-source-rtos

作者：Zhu Tianlong 选题：lujun9972 译者：silentdawn-zz 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出