Figure 1.1: A Bird-View of the Urbi Architecture
Urbi SDK is a fully-featured environment to orchestrate complex organizations of components. It is an open source framework for complex systems. It relies on a middleware architecture that coordinates components named UObjects. It also features urbiscript, a scripting language tailored to write orchestration programs.
Urbi makes the orchestration of independent and concurrent components easier. It was first designed for robotics: it provides all the needed features to coordinate the execution of various components (actuators, sensors, software devices that provide features such as text-to-speech, face recognition and so forth). Languages such as C++ are well suited to program the local, low-level, handling of these hardware or software devices; indeed one needs efficiency, small memory footprint, and access to low-level hardware details. Yet, when it comes to component orchestration and coordination, in a word, when it comes to addressing concurrency, it can be tedious to use such languages.
Middleware infrastructures make possible to use remote components as if they were local, to allow concurrent execution, to make synchronous or asynchronous requests and so forth. The UObject C++ architecture provides exactly this: a common API that allows conforming components to be used seamlessly in highly concurrent settings. Components need not be designed with UObjects in mind, rather, UObjects are typically “shells” around “regular” components.
Components with an UObject interface are naturally supported by the urbiscript programming language. This provides a tremendous help: one can interact with these components (making queries, changing them, observing their state, monitoring various kinds of events and so forth), which provides a huge speed-up during development.
Although made with robots in mind, the UObject architecture is well suited to tame any heavily concurrent environment, such as video games or complex systems in general.
The Section 1.1 shows the architecture of Urbi. Let’s browse it bottom up.
At the lowest level, Urbi requires a (possibly very limited) embedded computer. This is the case for most robots today, but on occasion, some device cannot even run reasonably small pieces of code. In that case, Urbi can still be used, but then the robot is actually remote-controlled from a computer running Urbi.
Right on top of the hardware, is running the Operating System. Urbi supports the major OSes; it was also ported on top of real-time OSes such as Xenomai, and on specific OSes such as Aperios, Sony’s proprietary system running its Aibo robotic dog.
The Urbi Runtime, which is the actual core of the system, also known as the engine or the kernel, is interfacing the OS with the rest of the Urbi world, urbiscript and UObjects.
UObjects are used to bind hardware or software components, such as actuators and sensors on the one hand, and voice synthesis or face recognition on the other hand. They can be run locally on the robot, or on a remote, more powerful, computer.
To orchestrate all the components, urbiscript is a programming language of choice (see below).
urbiscript is a programming language primarily designed to handle concurrent programming. It’s a dynamic, prototype-based, object-oriented scripting language. It supports and emphasizes parallel and event-based programming, which are very popular paradigms in robotics, by providing core primitives and language constructs.
Its main features are:
Urbi what first designed and implemented by Jean-Christophe Baillie, together with Matthieu Nottale. Because its users wildly acclaimed it, Jean-Christophe founded Gostai, a France-based Company that develops software for robotics with a strong emphasis on personal robotics. Gostai has been acquired by Aldebaran Robotics in 2012. Urbi is now a community-driven open source project available at https://github.com/jcbaillie/urbi.
Authors Urbi SDK 1 was further developed by Akim Demaille, Guillaume Deslandes, Quentin Hocquet, and Benoît Sigoure.
The Urbi SDK 2 project was started and developed by Akim Demaille, Quentin Hocquet, Matthieu Nottale, and Benoît Sigoure. Samuel Tardieu provided an immense help during the year 2008, in particular for the concurrency and event support.
The maintenance in Gostai was carried out by Akim Demaille, Quentin Hocquet, and Matthieu Nottale. Jean-Christophe Baillie is still deeply involved in the development of urbiscript, he regularly submits ideas, and occasionally even code!
Contributors Many people contributed significantly to Urbi, including Alexandre Morgand, Romain Bezut, Thomas Moulard, Clément Moussu, Nicolas Pierron.
This multi-part document provides a complete guide to Urbi. See Listing 28 for the various notations that are used in the document.
No knowledge of the urbiscript language is needed. As a matter of fact, Urbi can be used as a standalone middleware architecture to orchestrate the execution of existing components.
Yet urbiscript is a feature that “comes for free”: it is easy using it to experiment, prototype, and even program fully-featured applications that orchestrate native components. The interested reader should read either the urbiscript user manual (Listing I), or the reference manual (Section 20).
This part is not an urbiscript tutorial; it is not structured in a progressive manner and is too detailed. Think of it as a dictionary: one does not learn a foreign language by reading a dictionary. For an urbiscript Tutorial, see Listing I.
This part does not aim at giving advanced programming techniques. Its only goal is to define the language and its libraries.
You may want to look at the documentation of the latest version, and visit http://urbiforge.org, the Urbi community web site, and its forum.
This document and others are updated regularly on the Gostai Web site: