RT-Thread 1.0.1 / 1.1.0 Alpha

A real-time operating system
RT-Thread is a real-time operating system. It is designed specifically for small memory footprint platforms. The kernel supports the tranditional RTOS services, such as multiple threads, semaphores, mutexes, event flags, mailboxes, etc.

RT-Thread project also provides a C-expression interpreter shell, from which a programmer can access kernel variables and invoke system functions.

Main features:

  • Kernel Object System:
  • There is a kernel object system, which can access and manage all of the kernel objects. Kernel objects include most of the facilities in the kernel, for example, thread, semaphore etc. Kernel objects can be static objects, whose memory is allocated in compiling. It can be dynamic objects as well, whose memory is allocated from system heaps in runtime. Through the kernel object system, RT-Thread operating system can be independent from the memory management system and greatly enhance the scalability of the system.
  • Multi-Task/Thread Scheduling:
  • RT-Thread operating system supports multi-task systems, which are based on thread scheduling. The scheduling algorithm used in RT-Thread operating system is a full preemptive priority-based scheduling algorithm. It supports 256 priority levels, in which 0 is the highest and 255 the lowest. The 255th priority is used for idle thread. The scheduling algorithm also supports threads running at same priority level. The shared time-slice round-robin scheduling is used for this case. The time of scheduler to determine the next highest ready thread is determinant. The number of threads in the system is unlimited, only related with RAM.
  • Synchronization Mechanisms:
  • RT-Thread operating system supports the traditional semaphore and mutex. Mutex objects use inherited priority to prevent priority reversion. The semaphore release action is safe for interrupt service routine. Moreover, the block queue for thread to obtain semaphore or mutex can be sorted by priority or FIFO.
  • Inter-Thread Communication:
  • RT-Thread operating systems supports event/fast event, mail box and message queue. The event mechanism is used to awake a thead by setting one or more corresponding bit of a binary number when an event ocurs. The fast event supports event thread queue. Once a one bit event occurs, the corresponding blocked thread can be found out timing accurately, then will be waked up. In mailbox, a mail length is fixed to 4 byte, which is more effective than message queue. The send action for communication facilities is also safe for interrupt service routine.
  • Clock and Timer:
  • In default, the system uses clock tick to implement shared time-slice scheduling. The timing sensitivity of thread is implemented by timers. The timer can be set as one-shot or periodic timeout.
  • Memory Management:
  • RT-Thread operating system supports two types memory management: static memory pool management and dynamic memory heap management. The time to allocate a memory block from the memory pool is determinant and when the memory pool is empty, the allocated thread can be blocked (or immediately return, or waiting for sometime to return, which are determined by a timeout parameter). When other thread releases memory blocks to this memory pool, the blocked thread is wake up.

last updated on:
April 18th, 2012, 12:07 GMT
price:
FREE!
developed by:
Midnight Xiong
homepage:
openlab.rt-thread.com
license type:
GPL (GNU General Public License) 
category:
ROOT \ System \ Operating Systems \ Other

FREE!

In a hurry? Add it to your Download Basket!

user rating 18

3.2/5
 

0/5

What's New in version 1.1.0 Alpha
  • This release is a technical preview, indicating the development direction of the RT-Thread, and it’s not suitable for product development yet.
  • The main improvement of this version is the new initialization module for the components, new DeviceDriver framework (SPI, SDIO), newly ported jffs2 and yaffs2 filesystems, and virtualised configuring of rtconfig.h in Eclipse.
read full changelog

Add your review!

SUBMIT