---
title: "Linux嵌入式实时操作系统开发与设计（七）"
author: "mmdev"
date: "2004-08-18T16:53:00Z"
tags: []
slug: "linux"
draft: false
lastmod: "2004-08-18T16:53:00Z"
id: 1009476
url: "https://mmdev.iteye.com/blog/1009476"
---

[]()[]()[]()[]()[]()[]()[第四章]() RTLinux应用程序设计&lt;?xml:namespace prefix = o ns = "urn:schemas-microsoft-com:office:office" /&gt;

4.1 程序结构

每个实时应用程序可以分为两部分：实时部分和非实时部分\[2]。非实时部分在用户空间执行，称为用户部分。实时部分要尽可能简单，只包含直接与时间相关的代码；由于硬件对时间的约束，低级的与硬件通信的代码一般也包含在实时部分。用户部分的代码主要实现为数据的处理，包括数据的发布、保存和用户界面。两部分之间的通信采用数据缓冲区。

图4.1所示的数据流程图是依照这个程序模型的典型实时应用程序。

&lt;?xml:namespace prefix = v ns = "urn:schemas-microsoft-com:vml" /&gt;&lt;shapetype id="\_x0000\_t75" stroked="f" filled="f" path="m@4@5l@4@11@9@11@9@5xe" o:preferrelative="t" o:spt="75" coordsize="21600,21600"&gt;&lt;stroke joinstyle="miter"&gt;&lt;/stroke&gt;&lt;formulas&gt;&lt;f eqn="if lineDrawn pixelLineWidth 0"&gt;&lt;/f&gt;&lt;f eqn="sum @0 1 0"&gt;&lt;/f&gt;&lt;f eqn="sum 0 0 @1"&gt;&lt;/f&gt;&lt;f eqn="prod @2 1 2"&gt;&lt;/f&gt;&lt;f eqn="prod @3 21600 pixelWidth"&gt;&lt;/f&gt;&lt;f eqn="prod @3 21600 pixelHeight"&gt;&lt;/f&gt;&lt;f eqn="sum @0 0 1"&gt;&lt;/f&gt;&lt;f eqn="prod @6 1 2"&gt;&lt;/f&gt;&lt;f eqn="prod @7 21600 pixelWidth"&gt;&lt;/f&gt;&lt;f eqn="sum @8 21600 0"&gt;&lt;/f&gt;&lt;f eqn="prod @7 21600 pixelHeight"&gt;&lt;/f&gt;&lt;f eqn="sum @10 21600 0"&gt;&lt;/f&gt;&lt;/formulas&gt;&lt;path o:connecttype="rect" gradientshapeok="t" o:extrusionok="f"&gt;&lt;/path&gt;&lt;lock aspectratio="t" v:ext="edit"&gt;&lt;/lock&gt;&lt;/shapetype&gt;

![](http://www.tianhecity.com/jose/7.gif)

**图4.1 程序结构图**

4.2 基本API

4.2.1 POSIX线程创建函数

就像前面介绍的那样，一个实时程序是由几个执行的线程组成的。线程是轻量级进程，它们共享共有的地址空间。在RTLinux中，所有的线程共享Linux内核地址空间。

**int pthread\_create (pthread\_t \*thread, pthread\_attr\_t * attr, void * (* start\_routine)(void \*), void \*arg)**

这是RTLinux的标准POSIX线程创建函数。这个线程运行函数指针start\_routine指向的过程，arg是这个函数的指针的入口参数。线程的属性由attr对象决定，可以为这个属性设置CPU号、堆栈大小等属性。设定若为NULL，将会使用默认属性。返回0表示成功创建线程，线程号放在thread所指向的空间；返回非0表示创建失败。线程的属性决定在特定的CPU上创建线程(pthread\_attr\_setcpu\_np)，是否使用FPU(pthread\_attr\_setfp\_np)。

**int pthread\_attr\_init (pthread\_attr\_t \*attr)**

初始化线程运行的属性。

**int pthread_ attr\_setschedparam (pthread\_attr\_t \*attr, const struct sched\_param \*param)和int pthread_ attr\_setschedparam (const pthread\_attr\_t \*attr, struct sched\_param \*param)**

这两个函数根据程序的需要相应地从attr中设定/取得线程的运行参数。param是为调度的SCHED\_FIFO和SCHED\_RR策略定义的属性。

**int** **pthread\_attr\_setcpu\_np (pthread\_atte\_t \*attr, int cpu)****和**

**int pthread\_attr\_getcpu\_np (pthread\_atte\_t \*attr, int cpu)**

设定/取得线程运行的CPU号。在SMP机器上允许线程在一个特定的CPU上运行。

**int pthread\_cancel (pthread\_t thread)**

取消一个运行的线程。

**int pthread\_delete\_np (pthread\_t thread)**

删除一个线程，并且释放该线程的所有资源。返回0表示成功删除，非0表示删除失败。

**pthrad\_t pthread\_self (void)**

获得当前正在运行的线程号。

**clockid\_t rtl\_getschedclock (void)**

获得当前调度方法的时钟。

**int rtl\_setclockmode (clockid\_t clock, int mode, hrtime\_t mode\_param)**

设置当前的时钟模式，mode=RTL\_CLOCK\_MODE\_ONESHOT时是非周期（一次性）模式mode\_param参数无用；mode=RTL\_CLOCK\_MODE\_PERIODIC时是周期模式，mode\_param参数是周期的长度。（有关时钟模式见3.4节的说明）

**int pthread\_wait\_np (void)**

当前周期的线程运行结束，总是返回0。

4.2.2 时间相关函数

RTLinux提供了一些时钟函数用于计时功能，包括线程调度，获得TSP(timestamps)等。

**下面的是一般的计时函数：**

/* #include &lt;rtl\_time.h&gt;&lt;span style="mso-spacerun: yes"&gt; &lt;/span&gt;\*/&lt;p&gt;&lt;/p&gt;&lt;/rtl\_time.h&gt;

int clock\_gettime(clockid\_t clock\_id, struct timespec \*ts);

hrtime\_t clock\_gethrtime(clockid\_t clock);

struct timespec {

time\_t tv\_sec; /* 秒 \*/

long tv\_nsec; /* 纳秒 \*/

};

clock\_gettime：读取当前的时间，保存到clock\_id所指的对象中。

clock\_gethrtime：读取当前时间，但返回一个64位(hrtime\_t)的纳秒时间值。

一些时间转换的函数，用于把时间格式转换为另外一种格式。

**时间转换函数：**

/* #include &lt;rtl\_time.h&gt;&lt;span style="mso-spacerun: yes"&gt; &lt;/span&gt;\*/&lt;p&gt;&lt;/p&gt;&lt;/rtl\_time.h&gt;

hrtime\_t timespec\_to\_ns(const struct timespec \*ts); /* timespec到纳秒数转换 \*/

struct timespec timespec\_from\_ns(hrtime\_t t); /* 纳秒数到timespec转换 \*/

const struct timespec * hrt2ts(hrtime\_t value); /*

下面是一些支持的时钟类型。

**时钟类型相关的宏：**

l CLOCK\_MONOTONIC: POSIX时钟，以恒定速率运行；不会复位和调整

l CLOCK\_REALTIME: 标准POSIX实时时钟。目前与CLOCK\_MONOTONIC时钟相同

l CLOCK\_RTL\_SCHED: 调度器用来任务调度的时钟

**以下是机器结构相关的时钟：**

l CLOCK\_8254: 在x86单处理器机器上用于调度的时钟

l CLOCK\_APIC: 用在SMP x86机器的时钟

4.2.3 线程调度函数

RTLinux提供一些调度方式，允许线程代码在特定的时刻运行。RTLinux使用单纯优先级驱动的调度器，更搞优先级的线程总是被选择运行。如果两个线程的优先级拥有一样的优先级，选择那一个线程运行是不确定的。RTLinux使用下面的调度API：

**int pthread\_setschedparam (pthread\_t thread, int policy, const struct sched\_param \*param)**

设置一个线程的调度参数，用policy和sched\_param两个参数设置thread的调度参数属性：

policy=SCHED\_RR：使用Round-Robin方法调度

policy=SCHED\_FIFO：使用先进先出的方法调度

返回0表示成功调度，非0表示失败。

**int pthread\_getschedparam (pthread\_t thread, int policy, const struct sched\_param \*param)**

获得一个线程的调度参数。将获得的policy和sched\_param结构放在入口参数所指向的地址里面。

**int pthread\_make\_periodic\_np (pthread\_t thread, hrtime start\_time, hrtime\_t period)**

这个函数标记thread线程为可运行。线程将在start\_time时刻开始运行，运行的时间间隔由period给定。

**int pthread\_wait\_np (void)**

pthread\_wait\_np函数将挂起当前运行发线程直到下一周期。这个线程必须是pthread\_make\_periodic\_np函数标记为可执行。

**int sched\_get\_priority\_max (int policy)和**

**int sched\_get\_priority\_min (int policy)**

确定sched\_priority可能的值。

4.3 编程示例

前面介绍了RTLinux的基本API，在这里以一个实例来说明RTLinux下的编程方法。这是一以测试RTLinux下中断延迟的程序。正如前面所说的，程序分为两部分，实时部分和非实时部分。实时部分通过使用一个模块，在将实时模块插入后，运行实时任务。对于非实时部分，实现对FIFO设备的读取，完成和实时任务的通信。

**![](http://www.tianhecity.com/jose/8.gif)**

**图4.2 实时程序结构图**

4.3.1 实时部分

init\_module完成对实时部分的初始化。cleanup\_module实现关闭实时模块的任务。

/* * RTLinux scheduling accuracy measuring example \*/

#include &lt;rtl.h&gt;&lt;p&gt;&lt;/p&gt;&lt;/rtl.h&gt;

#include &lt;rtl\_fifo.h&gt;&lt;p&gt;&lt;/p&gt;&lt;/rtl\_fifo.h&gt;

#include &lt;time.h&gt;&lt;p&gt;&lt;/p&gt;&lt;/time.h&gt;

#include &lt;rtl\_sched.h&gt;&lt;p&gt;&lt;/p&gt;&lt;/rtl\_sched.h&gt;

#include &lt;rtl\_sync.h&gt;&lt;p&gt;&lt;/p&gt;&lt;/rtl\_sync.h&gt;

#include &lt;pthread.h&gt;&lt;p&gt;&lt;/p&gt;&lt;/pthread.h&gt;

#include &lt;unistd.h&gt;&lt;p&gt;&lt;/p&gt;&lt;/unistd.h&gt;

#include &lt;rtl\_debug.h&gt;&lt;p&gt;&lt;/p&gt;&lt;/rtl\_debug.h&gt;

#include &lt;errno.h&gt;&lt;p&gt;&lt;/p&gt;&lt;/errno.h&gt;

#include "common.h"

int ntests=500;

int period=1000000;

int bperiod=3100000;

int mode=0;

int absolute=0;

int fifo\_size=4000;

int advance=0;

MODULE\_PARM(period,"i");

MODULE\_PARM(bperiod,"i");

MODULE\_PARM(ntests,"i");

MODULE\_PARM(mode,"i");

MODULE\_PARM(absolute,"i");

MODULE\_PARM(advance,"i");

pthread\_t thread;

int fd\_fifo;

void \*thread\_code(void \*param)

{

hrtime\_t expected;

hrtime\_t diff;

hrtime\_t now;

hrtime\_t last\_time = 0;

hrtime\_t min\_diff;

hrtime\_t max\_diff;

struct sample samp;

int i;

int cnt = 0;

int cpu\_id = rtl\_getcpuid();

rtl\_printf ("Measurement task starts on CPU %d\\n", cpu\_id);

if (mode) {

int ret = rtl\_setclockmode (CLOCK\_REALTIME, RTL\_CLOCK\_MODE\_PERIODIC, period);

if (ret != 0) {

conpr("Setting periodic mode failed\\n");

mode = 0;

}

} else {

rtl\_setclockmode (CLOCK\_REALTIME, RTL\_CLOCK\_MODE\_ONESHOT, 0);

}

expected = clock\_gethrtime(CLOCK\_REALTIME) + 2 * (hrtime\_t) period;

fd\_fifo = open("/dev/rtf0", O\_NONBLOCK);

if (fd\_fifo &lt; 0) {

rtl\_printf("/dev/rtf0 open returned %d\\n", fd\_fifo);

return (void \*) -1;

}

if (advance) {

rtl\_stop\_interrupts(); /* Be careful with this! The task won't be preempted by anything else. This is probably only appropriate for small high-priority tasks. \*/

}

/* first cycle \*/

clock\_nanosleep (CLOCK\_REALTIME, TIMER\_ABSTIME, hrt2ts(expected - advance), NULL);

expected += period;

now = clock\_gethrtime(CLOCK\_MONOTONIC);

last\_time = now;

do {

min\_diff = 2000000000;

max\_diff = -2000000000;

for (i = 0; i &lt; ntests; i++) {

++cnt;

clock\_nanosleep (CLOCK\_REALTIME, TIMER\_ABSTIME, hrt2ts(expected - advance), NULL);

now = clock\_gethrtime(CLOCK\_MONOTONIC);

if (absolute && advance && !mode) {

if (now &lt; expected) {

rtl\_delay (expected - now);

}

now = clock\_gethrtime(CLOCK\_MONOTONIC);

}

if (absolute) {

diff = now - expected;

} else {

diff = now - last\_time - period;

if (diff &lt; 0) {

diff = -diff;

}

}

if (diff &lt; min\_diff) {

min\_diff = diff;

}

if (diff &gt; max\_diff) {

max\_diff = diff;

}

expected += period;

last\_time = now;

}

samp.min = min\_diff;

samp.max = max\_diff;

write (fd\_fifo, &samp, sizeof(samp));

} while (1);

return 0;

}

pthread\_t background\_threadid;

void \*background\_thread(void \*param)

{

hrtime\_t next = clock\_gethrtime(CLOCK\_REALTIME);

while (1) {

hrtime\_t t = gethrtime ();

next += bperiod;

/* the measurement task should preempt the following loop \*/

while (gethrtime() &lt; t + bperiod * 2 / 3);

clock\_nanosleep (CLOCK\_REALTIME, TIMER\_ABSTIME, hrt2ts(next), NULL);

}

}

int init\_module(void)

{

pthread\_attr\_t attr;

struct sched\_param sched\_param;

int thread\_status;

int fifo\_status;

rtf\_destroy(0);

fifo\_status = rtf\_create(0, fifo\_size);

if (fifo\_status) {

rtl\_printf("RTLinux measurement test fail. fifo\_status=%d\\n",fifo\_status);

return -1;

}

rtl\_printf("RTLinux measurement module on CPU %d\\n",rtl\_getcpuid());

pthread\_attr\_init (&attr);

if (rtl\_cpu\_exists(1)) {

pthread\_attr\_setcpu\_np(&attr, 1);

}

sched\_param.sched\_priority = 1;

pthread\_attr\_setschedparam (&attr, &sched\_param);

rtl\_printf("About to thread create\\n");

thread\_status = pthread\_create (&thread, &attr, thread\_code, (void \*)1);

if (thread\_status != 0) {

rtl\_printf("failed to create RT-thread: %d\\n", thread\_status);

return -1;

&lt;/