Free rt software for linux

RT is one free real-time operating system with one hardware depending part very little this can make possible the porting for other microprocessor.
The RT project Is one real-time operating system for the ARM 7 architecture. The main source can be used in any ARM 7 compatible microprocessor and the device driver can are tested using the Keil MCB2140 with the Philips LPC2148.
Main features:
- Hard real-time multi threading
- Support for semaphore and mutual exclusion
- User definable priorities from 001 to 254
- Fast memory allocation
- Free compiler.
- Asynchronous serial driver for 16550 Uart.
- Serial driver for the 8051 architecture
- Serial console.
- Sample application.
- And more ....
Current porting:
- ARM7 with GNUARM and Philips LPC2148 micro controller tested with the Keil MCB2140 evaluation board.
- 8051 using SDCC compiler tested with the J51 emulator.
Installation:
Extract the package in one new directory. Set the path for the compiler desired and the variable RT to the root of the package. Es. if the package is extracted in ~/rt-0.0 set RT=~~/rt-0.0
Directory structure relative to the root of the package.
docs - Documentation directory
efsl-x.x.x - Embedded file system library
examples - Examples source directory
obj - Precompiled example
rt - RTOS main directory
script - SCript used for linking target
sdcc - SDCC utility
makefile.inc - Include makefile from all program.
makefile.efsl - Makefile for embedded file system library
makefile.rt - Makefile for RTOS library
readme.txt - This file.

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.
Enhancements:
- More porting was done to Samsung S3C44b0 CPU, AMTEL AT91SAM7S64, Nintendo DS, and Intel i386.

RoboTournament project is a RoboRally-inspired game with Death Match, Rally, and Capture The Flag matches.
RoboTournament is a RoboRally inspired game where players program their robots to vanquish their opponents.
RoboTournament features multiple game types (Death Match, Rally, and Capture The Flag), TCP/IP multiplayer support, six weapons including the BFG, a map editor, a wide variety of board elements, integrated chat, and computer-controlled robots for Rally and Death Match games.
Main features:
- Multiple Game Types: Death Match, Rally, and Capture The Flag
- Multi-Player through TCP/IP
- Six weapons including the BFG
- Map Editor
- Wide variety of board elements
- Integrated chat
- Computer controlled robots for Rally and Death Match games
Enhancements:
- This release changes the deployment, but adds no functionality.
- The server and client are now distributed as individual, platform specific executables.

Module::Starter::XSimple is a Perl module to create XS modules with Module::Starter.

Replacement class for Module::Starter::Simple.

Can be used in two ways:

Using the commandline

Pass as an override class to the module-starter script:

module-starter --module=[modulename]
--class=Module::Starter::XSimple

Using a config file

Create a .module-starter/config file with at least the following:

author: your name
email: your_address@example.com
builder: Module::Build
plugins: Module::Starter::XSimple

At present, M::S::XSimple only supports Module::Build, because the XS and associated files locations are different between Module::Build and ExtUtils::ModuleMaker.

All methods are replacements or additions to the methods provided by Module::Starter::Simple.

Build_PL_guts

Creates the custom Build.PL file for the generated module.

create_modules

Creates the .PM, .XS, and typemap files for each requested module. Calls the following three subs:

module_guts

Generates the .PM file from skeleton code.

xsmodule_guts

Generates the .XS file from skeleton code.

typemap_guts

Generates the typemap file from skeleton code.

module_path_create

Replacement sub for M::S::Simple routine; permits the caller to set the file extension when creating non .PM files.

rtname

Generate the special e-mail address to use when reporting bugs via rt.cpan.org.

t_guts

Add additional test files.

WebRun provides a simple Java application distribution tool.
WebRun is a single Java class file that implements a remote class loader and application launcher that can be used to distribute Java applications to clients.
This drastically reduces the need to continually update each client as only this class file plus the Java environment is needed on the client.
WebRun load JAR and CLASS files from URLs plus it supports basic authentication with HTTP URLs.
A simple Java Application Starter that can load jars and class files from URLs, including password protected URLs. WebRun offers the benefits of Java without the overhead or bugs of web browsers.
The front end is run as the main Java class using any Java 1.1 or later runtime environment (RT, JRE, or JDK). It may be compiled as part of a package or outside of packages. It does not depend on its package name in any way other than it is the location where we place our Java tools.
The code was specifically written in such a way as to only require a single class file (in addition to Java) to be on the users system. Thus some of the strange constructs to do the AWT windows for the password entry and for the status display.
Enhancements:
- Very minor changes and some source code cleanups.

Shaaft is an OpenGL 3D falling block game similar to Blockout. It currently runs on Linux and Windows.

There is still a lot missing. No menu system, forgets highscore, some of the sound effects need work (Clearing a single plane sounds like a f*rt. Try clearing >1 plane, though...), etc. That said, I find it is very playable. Enjoy!

You control the rotation via q,a,w,s,e,d. Space will drop the block.

RRDBrowse is a poller daemon, templater and webinterface for RRDTool. It has a threaded daemon which periodically runs from cron. It works with small .nfo files which hold router information and optionally connection details, colors, min max, bandwidth settings, etc, etc. RRDBrowse uses a small caching mechanism to store interface names. Its like MRTG in actual state.
Main features:
- 100% Perl
- Extremely Simple Configuration.
- Flexible & Extendible using Simple and Small Perl modules.
- Caching of ifIndex tables and other slow data. Retrieve once, Process Multiple times.
- Its Fast, thanks to RRDTool! Large organizations can handle thousands updated items each run.
Enhancements:
- Added RT statistics module
- Added oidderive module from Ingimar Robertsson
- Added w2kcpu and w2kmem modules from Okumura Yoshifumi
- Cleanups in utilities and cgi
- Added option to specify your own stylesheet
- Added Limit option in ciscocpu
- Improved debugging facilities
- Added Linux Disk I/O Statistics
- Added Linux Open Files and Open Sockets stats

BRL-CAD project is a powerful Constructive Solid Geometry (CSG) solid modeling system. BRL-CAD includes an interactive geometry editor, ray tracing support for rendering and geometric analysis, network distributed framebuffer support, image-processing and signal-processing tools. The entire package is distributed in source code form.
Since the late 1950s, computers have been used to assist with the design and study of combat vehicle systems. The result has been a reduction in the amount of time and money required to take a system from the drawing board to full-scale production as well as increased efficiency in testing and evaluation.
In 1979, the U.S. Army Ballistic Research Laboratory (BRL) (now the U.S. Army Research Laboratory [ARL]) expressed a need for tools that could assist with the computer simulation and engineering analysis of combat vehicle systems and environments. When no existing computer-aided design (CAD) package was found to be adequate for this purpose, BRL software developers began assembling a suite of utilities capable of interactively displaying, editing, and interrogating geometric models. This suite became known as BRL-CAD.
Now comprising over one-half million lines of C code, BRL-CAD has become a powerful constructive solid geometry (CSG) modeling package that has been licensed at over 2,000 sites throughout the world. It contains a large collection of tools, utilities, and libraries including an interactive geometry editor, raytracing and generic framebuffer libraries, a network-distributed image-processing and signal-processing capability, and a customizable embedded scripting language. In addition, BRL-CAD simultaneously supports dual interaction methods, one using a command line and one using a graphical user interface (GUI).
A particular strength of the package lies in its ability to build and analyze realistic models of complex objects using a relatively small set of "primitive shapes." To do this, the shapes are manipulated by employing the basic Boolean operations of union, subtraction, and intersection. Another strength of the package is the speed of its raytracer, which is one of the fastest in existence. Finally, BRL-CAD users can accurately model objects on scales ranging from the subatomic through the galactic and get "all the details, all the time."
The application side of BRL-CAD also offers a number of tools and utilities. They primarily concern (1) geometric conversion, (2) geometric interrogation, (3) image format conversion, and (4) command-line-oriented image manipulation. The following is a list of the major BRL-CAD tools and utilities.
- MGED (Multiple-Device Geometry Editor) ? BRL-CADs graphics editor. (For detailed guidance on the use of MGED as well as a list of all the MGED commands currently available, see Butler et al. [2001].)
- Tools for raytracing and interrogating raytraced geometric objects.
- rt ? the main raytracer for rendering images in BRL-CAD.
- nirt ? a package for firing rays interactively and getting information about what the rays run into.
- remrt ? a network-distributed raytracing package.
- An assortment of geometric converters to convert to and/or from other geometry formats, including Euclid, ACAD, AutoCAD DXF, TANKILL, Wavefront OBJ, Pro/ENGINEER, JACK (the human factors model for doing workload/usability studies), Viewpoint Data Lab, NASTRAN, Digital Equipments Object File Format (OFF), Virtual Reality Mark-up Language (VRML), Stereo Lithography (STL), Cyberware Digitizer data, and FASTGEN4.
- bwish ? a Tcl/Tk interpreter in a windowing shell with enhancements compiled into it for accessing BRL-CAD libraries. It also includes various other extensions to the Tcl language.
- irprep ? produces input to the PRISM (Physically Realistic Infrared Simulation Model) code.
- JOVE (Jonathans Own Version of Emacs) ? a fast, light implementation of Emacs.
- Applications for displaying images of various types on the framebuffer application and retrieving data from that framebuffer into images of various types.
- Tools for generating geometry for common objects such as fences, walls, and geometric mathematical oddities (e.g., the sphereflake shown in Figure 2 in Section 4).
- Data manipulation programs to (1) convert integers to floats, floats to doubles, etc. (e.g., cv); (2) perform mathematical operations on file elements (e.g., imod, umod, and dmod); (3) compute statistics of file elements (e.g., istat, ustat, and dstat); etc.
- Utilities for building animation scripts ? keeping track of columnar data and interpolating it to allow one to produce input to the rt program to render multiple items for animation.
- Utah Raster Tool Kit ? image manipulation of all RLE-based images.
- Programs for manipulating images and converting between different image file types. The two primary BRL-CAD types are pix (24-bit red, green, and blue [RGB] color images) and bw (8-bit greyscale images). Converters exist for various image formats including alias, png, ppm, etc.
- Programs for filtering images, doing histograms on the image data, and extracting rectangles from the images.
- Tools for combining two images and blending them together. (These tools were created before good image editing tools for video production were available; today users would typically load the images directly into a video editing package.)
Enhancements:
- fixed -i argument bug in g-acad, g-dxf, g-nff, g-obj - Shawn Baker
- framebuffer toggle added to raytrace panel in mged - Sean Morrison
- fixed rtedge multithreaded output render bug - Erik Greenwald
- fixed jove/termcap issues on Mac OS X - Sean Morrison
- updated bundled libtermcap to NetBSD version 0.6 - Sean Morrison
- increased output precision on mged analyze command - Sean Morrison
- prevent mged shutdown on DSP objects with no data - Sean Morrison
- integration into the Arch Linux packaging system - Loui Chang
- upgrade of bundled tcl/tk from 8.4.6 to 8.5a5 - Sean Morrison
- improved EOL processing in 70+ tools - Sean Morrison, John Anderson
- rewrote pixcmp providing improved I/O format options - Sean Morrison
- added new manual page for pixcmp utility - Sean Morrison
- updated bundled zlib to version 1.2.3 - Sean Morrison
- updated bundled libpng to version 1.2.16 - Sean Morrison
- fixed Windows line-ending bug in dxf-g - John Anderson
- g_qa manual page documents the -t tolerance option - Lee Butler
- updated bundled blt to blt2.4z-patch-2 - Sean Morrison
- dxf-g turns 2D entities into sketches instead of nmg - John Anderson
- removed advertising clause from BSD code - Sean Morrison
- fix index bug, allow material ID of zero in rtweight - Karel Kulhavy
- fixed multiple frame render bug in raytracers - Karel Kulhavy
- mged help command now shows help for all args listed - Sean Morrison