RTX51原理注釋：由于英文原文會比較好，所以我沒有翻譯過來（不過也寫了部分的翻譯），直接提取出來一些英文，總結在一起。

1. 進程管理（ Task Management ）

1） 進程類型（ Classes of Tasks ）

RTX-51 recognizes two classes of tasks：

1. Fast tasks

n Contain especially short responses and interrupt disable times.

n Contain a separate register bank and a separate stack area （register banks 1， 2 and 3）。（Figure 1）

n Contain the highest task priority （priority 3） and can therefore interrupt standard tasks.

n All contain the same priority and can therefore not be mutually interrupted.

n Can be interrupted by c51 interrupt functions.

n A maximum of three fast tasks can be active in the system.

2. Standard tasks

n Require somewhat more time for the task switching compared to fast tasks.

n Share a common register bank and a common stack area （register bank 0）。

n The current contents of registers and stack are stored in the external （XDATA） memory during a task change.

n Can be interrupted by fast tasks.

n Can interrupt themselves mutually.

n Can be interrupt by c51 interrupt functions.

n A maximum 16 standard tasks can be active in the system.

每一個標準進程都包含一個設備上下文在擴展內存（XDATA）中。在標準進程執行進程切換的時候，會把它自己的Register和Stack存儲到對應的設備上下文中（在擴展內存中的一個區域）。之后，Register和Statck又從設備上下文中重新載入，繼續執行。（交換技術）

相比而言，快速進程則不用這么麻煩，因為它們有各自獨立的Register和Stack，所以只要激活對應的Register（修改PSW）和指向Stack的指針（Mov SP，＃XX）即可。

2） 進程狀態（Task states）

RTX-51 recognizes four task states：

1. READY All tasks which can run are READY. One of these tasks is the RUNNING （ACTIVE）task.

2. RUNNING （ACTIVE） Task which is currently being executed bythe processor. Only one task （maximum） can be in this state at a time.

3. BLOCKED （WAITING） Task waits for an event.

4. SLEEPING All tasks which were not started or which have terminated themselves are in this state.

3） 進程調度（Task switch）

The RTX-51 system section which the processors assigns to the individual tasks is referred to as the scheduler （also dispatcher）。

The RTX_51 scheduler works according to the following rules：

1. The task with the highest priority of all tasks in the READY state is executed.

2. If several tasks of the same priority are in the READY state，the task that has been ready the longest will be the next to execute.

3. Task switchings are only executed if the first rule would have been otherwise violated （exception： round-robin scheduling）。

Time-slice task change （round-robin scheduling） are executed if the following conditions are satisfied：

1. Round-robin scheduling must be enabled （see configuration）。

2. The RUNNING task has the priority of 0 and is currently not executing a floating-point operation （see section “Floating-Point Operations”， page 28）。

3. At least one task with the priority zero must be in the READY state.

4. The last task change must have occurred after the selected system time interval （see system function “os_set_slice”）。 The system time interval can be changed dynamically during program execution.

4） 進程通信和同步（Task Communication and Synchronisation）

There three two mechanisms：

1. Signal

Signals represent the simplest and fastest form of task communication. These can always be used when a pure task synchronisation is required without data exchange.

Each active task contains its own signal flag with which the following operations can be executed：

l Wait for a signal

l Send signal

l Clear signal

The task number （see section section “Task Declaration”） of the receiver task is used for identifying the signals for the individual operations.

2. Message（via MailBoxes（FIFO））

n By means of the mailbox concept， messages can be exchanged free of conflicts between the individual tasks.

n RTX-51 provides a fixed number of eight mailboxes. Messages can be exchanged in words （2 bytes） via these mailboxes. In this case， a message can represent the actual data to be transferred or the identification of a data buffer（defined by the user）。 In comparison to the signals， mailboxes are not assigned a fixed task， but can be freely used by all tasks and interrupt functions. These are identified with a mailbox number.

Mailboxes allow the following operations：

l Send a message

l Read a message

Each mailbox is internally consists of three wait lists.（Figure 2）

Figure 2

1. Message list

List of the messages written in the mailbox. These comprise a maximum of eight messages.

2. Write wait list

Wait list for tasks which want to write a message in the message list of the mailbox （maximum 16 tasks）。

3. Read wait list

Wait list for tasks which want to read a message from the message list of the mailbox （maximum 16 tasks）。

3. Semaphore

n By means of the semaphore concept， resources can be shared free of conflicts between the individual tasks.

n A semaphore contains a token that your code acquires to continue execution. If the resource is already in use， the requesting task is blocked until the token is returned to the semaphore by its current owner.

n There are two types of semaphores： binary semaphores and counting semaphores. As its name implies， a binary semaphore can only take two values： zero or one （token is in or out）。 A counting semaphore， however， allows values between zero and 65535.

RTX-51 provides a fixed number of eight semaphores of the binary type.

Semaphores allow the following operations：

l Wait for token

l Return （send） token

2. 中斷管理

RTX-51 performs task synchronisation for external events by means of the interrupt system.

Two types of interrupt processing are basically supported in this case：

1. 單片機c語言 Interrupt Functions （Interrupt are processed by c51 interrupt funcions）

l Very sudden， periodically occurring interrupts without large coupling with the rest of the system （only infrequent communication with RTX-51 tasks， etc.）。

l Very important interrupts which must be served immediately independent of the current system state.

2. Task Interrupts（Interrupt are processed by fast or standard tasks of RTX-51

l Fast Task Interrupts

Important or periodic interrupts which must heavily communicate with the rest of the system when they occur.

l Standard Task Interrupts

Only seldom occurring interrupts which must not be served immediately.

RTX-51 shows considerable different response times for fast and standard tasks.

u The INTERRUPT ENABLE registers of the 8051 are managed by RTX-51 and must not be directly manipulated by the user！

u The Interrupt Priority registers of the 8051 （not to be confused with the softwaretask priorities） are not influenced by RTX-51.

3. 動態內存管理

RTX-51 uses a simple and effective algorithm， which functions with memory blocks of a fixed size. All memory blocks of the same size are managed in a socalled memory pool. A maximum of 16 memory pools each a different block size can be defined. A maximum of 255 memory blocks can be managed in each pool.

n Generate Memory Pool

The application can generate a maximum of 16 memory pools with various block sizes. The application must provide an XDATA area for this purpose. The pool is stored and managed by RTX-51 in this area （see system function “os_create_pool”）。

n Request Memory Block from Pool

As soon as a pool has been generated， the application can request memory

blocks. The individual pools are identified by their block size in this case.

If an additional block is still free in the pool， RTX-51 supplies the start address

of this block to the application. If no block is free， a null pointer is returned （see

system function “os_get_block”）。

n Return Memory Block to Pool

If the application no longer needs a requested memory block， it can be returned

to the pool for additional use （see system function “os_free_block”）。

4. 時間管理

RTX-51 maintains an internal time counter， which measures the relative time passed since system start. The physical source of this time base is a hardware timer that generates an interrupt periodically. The time passed between these interrupts is called a system time slice or a system tick.

This time base is used to support time dependent services， such as pause or timeout on a task wait.

Three time-related functions are supported：

n Set system time slice

The period between the interrupts of the system timer sets the “granularity” of the time base. The length of this period， also called a time slice， can be set by the application in a wide range （see system function “os_set_slice”）。

n Delay a task

A task may be delayed for a selectable number of time slices. Upon calling this system function the task will be blocked （sleep） until the specified number of system ticks has passed （see system function “os_wait”）。

n Cyclic task activation

For many real-time applications it is a requirement to do something on a regular basis. A periodic task activation can be achieved by the RTX interval wait function （see system function “os_wait”）。 The amount of time spent between two execution periods of the same task is controlled， using os_wait， and is measured in number of system ticks and may be set by the application.

5. RTX（FULL）函數縱覽（Functions Overview）

Initialize and Start the System：

os_start_system （task_number）

Task Management：

os_create_task （task_number）

os_delete_task （task_number）

os_ running_task_id （）

Interrupt Management：

os_attach_interrupt （interrupt）

os_detach_interrupt （interrupt）

os_enable_isr （interrupt）

os_disable_isr （interrupt）

os_wait （event_selector， timeout， 0）

oi_set_int_masks （ien0， ien1， ien2）

oi_reset_int_masks （ien0， ien1， ien2）

Signal Functions：

os_send_signal （task_number）

os_wait （event_selector， timeout， 0）

os_clear_signal （task_number）

isr_send_signal （task_number）

Message Functions：

os_send_message （mailbox， message， timeout）

os_wait （event_selector， timeout， *message）

isr_send_message （mailbox， message）

isr_recv_message （mailbox， *message）

Semaphore Functions：

os_send_token （semaphore）

os_wait （event_selector， timeout， 0）

Dynamic Memory Management：

os_create_pool （block_size， *memory， mem_size）

os_get_block （block_size）

os_free_block （block_size， *block）

Functions with the System Clock：

os_set_slice （timeslice）

os_wait （event_selector， timeout， 0）

Debug Functions：

os_check_tasks （*table）

os_check_task （task_number， *table）

os_check_mailboxes （*table）

os_check_mailbox （mailbox， *table）

os_check_semaphores （*table）

os_check_semaphore （semaphore， *table）

os_check_pool （block_size， *table）

三．RTX51移植

本試驗是用的RTX的Tiny版本。也就是說沒有優先級之分，沒有郵箱機制，沒有動態內存的管理。移植它很簡單，就是配置一下它帶的配置文件，然后和寫好的程序一起編譯連接，連接的時候加一個rtxtny參數，意思是說當我連接的時候，我把RTXtiny的庫文件連接上，也就等于是程序和操作系統編譯在一起了。該配置文件能在安裝目的rtxtiny2底下找到。文件名稱為Conf_tny.A51，例如，在我的電腦中，路徑為：D：\Keil\單片機c語言\RtxTiny2\SourceCode\ Conf_tny.A51。如下圖所示：

由于試驗箱里面的芯片是AT89C51，所以要配置Conf_tny.A51的RAMTOP EQU 07F，目的是說配置內部RAM為128字節。

四．源程序代碼：

源程序代碼如下，說明請看代碼里面的注釋。

/*

** RTX－51的移植

** 移植到AT89S52

** 此程序是循環花樣顯示LED燈

** 有三個顯示樣式，分別對應下面的三個進程

** 下面的算法中用到了“時間到空間”的轉換，使得算法簡化不少

** 此程序我已在最小系統板上試驗通過。

*/

#include 《reg51.h》

#include 《rtx51tny.h》

const unsigned char table［］={0x01，0x02，0x04，0x08，0x10，0x20，0x40，0x80

，0x40，0x20，0x10，0x08，0x04，0x02，0x01，0xFF，0x00};

/*時間到空間的轉換，如果table是：

const unsigned char table［］={0x01，0x02，0x04，0x08，0x10，0x20，0x40，0x80};

則算法和代碼會多出一倍來。table數組雖然增加了一倍，算法也隨之減少了一半，

好處當然不止在這里體現，下面的進程2也減少了一半*/

//進程0 左-》右-》左

void LED0 （void） _task_ 0

{

int i;

os_create_task（1）;//創建進程1

os_create_task（2）;//創建進程2

while（1）

{

for （i = 0; i 《 15; i++）

{

P1 = table［i］;

os_wait（K_TMO，30，0）;//等待30*10000微妙 = 0.3秒

}

os_send_signal（1）; //發送Signal信號，激活進程1

os_wait（K_SIG，0，0）; //等待信號

}

}

//進程1 全亮-》全滅-》全亮

void LED1 （void） _task_ 1

{

int i;

while（1）

{

os_wait（K_SIG，0，0）;

for （i = 0; i 《 3; i++）

{

P1 = table［15］; //全亮

os_wait（K_TMO，30，0）;

P1 = table［16］; //全滅

os_wait（K_TMO，30，0）;

}

os_send_signal（2）;

}

}

//進程2 兩邊-》中間中間-》兩邊

void LED2 （void） _task_ 2

{

int i;

while（1）

{

os_wait（K_SIG，0，0）;

for （i = 0; i 《 8; i++）

{

P1 = table［i］ | table［i+7］; //由于table長度多一倍，省去了一個循環，而且算法也簡化了。

os_wait（K_TMO，30，0）;

}

os_send_signal（0）;

}

}

五．總結：

本試驗用的RTX 的Tiny 版本。許多比較高級的功能沒有去實現。目的主要是理解RTX的原理，然后移植它到某個單片機上面，編寫個小程序來測試一下。通過閱讀RTX附帶的英文文檔，我對此操作系統有了深刻的認識，感到此操作系統有很多優點，也有很多不足的地方。比如支持的任務較少，不過由于是單片機，“承受”能力也有限，也能理解。總的來說，對于單片機來說是個不錯的操作系統。