Semantic aware real-time shceduling

Semantic aware real-time shceduling

SeART or Semantic aware real-time shceduling is an open-source project which has been thought for complex and real-time intelligent robotic applications. SeART addresses the problem of selecting, depending on the current context, a subset of tasks to be scheduled by the operating system in order to achieve the user’s objective, by meeting real-time and additional constraints. Towards this end, it can be easily interfaced with existing middleware for robotics to provide them with extended functionalities. SeART has been designed and implemented in software as a three layered architecture. Through the SeART Abstraction Layer and thanks to its small code footprint, it can be easily extended to work with virtually any possible real-time operating system. Currently, SeART supports following operating systems and frameworks:
- Standard POSIX
- XENOMAI (which also supports RTAI)
- TRAMPOLINE (OSEK/VDX)
- ETHNOS (POSIX support)


port plugin system (port monitoring, port arbitrating)

Port plugin system

In short, it is an extended functionality of a port implemented as a new carrier which allows to dynamically load at run–time script (or dynamically linked libraries such as .so/.dll) and plug it into the port of an existing module without changing the code or recompiling it. Using run-time scripts (currently written in Lua) or DLLs we can access and modify the data traveling through the port using a simple API. In this way extra functionalities of a component can be added during application development time and without the need to modify and rebuild the component itself. port monitor plugin system can be used for
- Data Guarding and Filtering
- Data Transformation
- Logging and Performance Monitoring
- Monitoring communication for QOS
- etc.

Yet Another Robot Platform (YARP)

Yet Another Robot Platform

YARP stands for Yet Another Robot Platform. What is it? If data is the bloodstream of your robot, then YARP is the circulatory system. More specifically, YARP supports building a robot control system as a collection of programs communicating in a peer-to-peer way, with an extensible family of connection types (tcp, udp, multicast, local, MPI, mjpg-over-http, XML/RPC, tcpros, ...) that can be swapped in and out to match your needs. We also support similarly flexible interfacing with hardware devices. Our strategic goal is to increase the longevity of robot software projects. YARP is written in C++. The ACE library is used for Windows builds, and to support extra protocols. On Linux and Mac OSX, ACE can optionally be omitted, giving a very light footprint.


rFSMTools

rFSM Tools

FSMTools is a set of C++ library (librFSM) to load and execute rFSM LUA-based state machines and a graphical modelling tools (rfsmGui) to create, debug and execute the state machine. It allows to build and debug your state machine in few clicks with minimal coding. Simply drags and drops states and transitions directly from the gui, and generates code for your state machine. rFSMTools have been developed with minimum dependencies. The librFSM exploits Lua 5.x and rFSM (embeddable) lua package. The Gui simply relies on Qt 5.x and graphviz library for automatic layouting.


ADA for Stellaris launchpad (ARM Cortex M4)

ADA for Stellaris launchpad

Porting ADA and ravenscare multitasking profiler for Stellaris Launchpad LM4f and TM4C boards. The porting allows for programming Stellaris boards (ARM Cortex M4) using ADA and benefits from its powerfull multi-tasking functionalities. Interrupts handling is fully supported and the required libraries are developed in ADA to access the boards' peripherals such as GPIO, Timers, Uart, I2C and etc.

Robot Testing Framework, RTF

Robot Testing Framework (RTF)

RTF is a generic and multi-platform testing framework for the test driven development (TDD) which is initially designed for the robotic systems. However, it can be used for any TDD system. The framework provides functionalities for developing and running unit tests in a language and middleware independent manner. The test cases are developed as independent plug-ins (i.e., using scripting languages or built as dynamically loadable libraries) to be loaded and executed by an automated test runner. Moreover, a fixture manager prepares the setup (e.g., running robot interfaces, simulator) and actively monitors that all the requirements for running the tests are satisfied during the execution of the tests. These functionalities along with other facilities such as the test result collector, result formatter and remote interface allow for rapid development of test units to cover different levels of system testing.


yarpmanager, gyarpmanager, yarpmanager-console, yarpmanager-gtk

(g)yarpmanager

The command-line utility "yarpmanager-console" and its graphical companions "gyarpmanager" are tools for running and managing multiple programs on a set of machines. The implementation partially uses YARP framework and fully supports Windows, Linux and Mac Os. Some of the features are:
- Running, stopping, and monitoring multiple programs on localhost or remote machines.
- Running programs concerning their dependencies.
- Recovering programs from failure.
- Automatically assigning programs to machines using load balancing and smart resource discovery mechanism for improving performance.
- Discovering information and status of machines in cluster of computers (e.g. Hardware, platform, CPU load).
- Generate application dependency graph