The project has been created. Please visit the project page.
The eTrice project is a proposed open source project under the MDT Project.
This proposal is in the Project Proposal Phase (as defined in the Eclipse Development Process) and is written to declare its intent and scope. We solicit additional participation and input from the Eclipse community. Please send all feedback to the eTrice Forum.
Domain Specific Languages (DSLs), whether they use a textual or graphical notation, are widely recognized as a convenient way to formalize abstractions of a given domain. They allow the engineer working on a problem in this domain to express his solution on exactly the level of abstraction which is best suited for the domain and best adapted to the way he states the problem and thinks about a solution.
For event driven real-time embedded systems engineers traditionally tend to use general purpose (and sometimes low level) programming languages like assembler, C and (usually a restricted subset of) C++. This way they have maximum control over the memory and performance impact of every single detail of their system. But the exponentially growing complexity of current software systems in the domains of telecommunication, automotive and industrial automation calls for advanced engineering methods. The challenge is to master the new complexity of highly distributed, concurrent and large software systems while maintaining quality and reliablity.
In recent years UML has been adopted for modeling in many areas including embedded systems. But while ULM1 lacked concepts for abstraction, e.g. the notion of ports and components, which are agreed to be essential for distributed systems, UML2 suffers from its mere complexity which is owed to its general and domain independent applicability. Additionally there is a gap between the UML model and the semantics of the code produced from it which is not addressed by the standard. State machines and ports leave many degrees of freedom. So vendors of UML2 modeling tools independently filled this gap while narrowing down the abundance of modeling elements by stereotypes.
In the early 1990s a DSL called [ROOM] (Real-Time Object Oriented Modeling) was proposed by Bran Selic et al. This language was designed for the, at this time, most complex real time systems developed for the upcoming mobile telephony. In a way, ROOM can be thought of a specific implementation, including the semantics of the model, of a subset of UML2 for the very specific needs of those kinds of systems - even though ROOM was proposed before the advent of UML. In its relation to UML2 ROOM is in a similar position as EMF compared to MOF where the design was guided by the principles of simplicity and performance. ROOM was tailored to suit the needs of a very special class of problems and uses concepts that address them in a highly formalized way. Maybe it is worth to stress that ROOM is not limited at all to the domain of telecommunication. It is general enough to be applied to any distributed event driven real time system.
The proposed eTrice project aims at an implementation of the ROOM language together with code generators and tooling for model editing. For the embedded target a portable runtime library will be supplied as part of the project which implements a platform abstraction, basic services like messaging, thread and process creation and a layer with the invariant parts of the modeling elements .
The objectives of the eTrice project are to:
The eTrice project will strive to deliver state of the art tooling and target middleware for the model driven development of industry quality event driven real-time software. Emphasis will be laid on the usablity of tooling, produced code and middleware in real industry projects.
The design will be guided by the following principles
The eTrice project will create
The ROOM metamodel will be based on EMF. Since there is no industry standard the project adopts the language as it is described in [ROOM]. The model will be completed by elements to describe deployment and configuration data. Also the model will be refined where appropriate as the project evolves. E.g. a concept of libraries will be introduced.
Model persistence will be in a textual, human readable form at a medium granularity. This provides an easy way for a team to lock some parts and merge others if necessary.
Initial editors will be implemented using Xtext. The concrete syntax will be similar to the one proposed in [ROOM] p. 493ff. Later graphical editors for structure (component hierarchy) and behavior (state machines) will be added using GMF or Graphiti.
Code generators will be based on Xpand and Xtend. Initially code generation in Java and C++ will be supported. Later also an ANSI C version will follow.
The middleware will be supplied for exemplary OS/hardware combinations like Windows/PC and Linux/PC. A middleware will be provided for each supported OS/hardware combination and target language. Emphasis will be laid on easy portability.
The initial committers created between 1998 and 2002 a ROOM tool called Trice, that implements a good part of the ROOM language, including runtime and code generators for C++ and C. The tool is still used for the development of distributed realtime systems mainly in the domains of automation, automotive and telecommunications. Since the tool was developed completely from scratch with Visual C++, it would be very hard to migrate it to Eclipse, XText, EMF, GMF, ... The decision is to redo it completely.
So the contribution from the Trice Project will not be code, but
The current eTrice prototype is a proof of concept that was created to get a better feeling for the way to go with XText Grammar, syntax and semantic models, code generators and runtime.
The prototype that will be contributed contains:
All other contributions will be developed from scratch.
The following individuals are proposed as initial committers to the project:
The following Architecture Council members will mentor this project:
The following individuals, organisations, companies and projects have expressed interest in this project:
The project will start with modeling editors and codegenerators for static structure and statemachines. Other ROOM features will follow step by step.
|July 2010:||Proposal published and announced to Eclipse membership|
|August 2010:||Initial Contribution|
|October 2010:||Prototype of ROOM meta model and XText grammar|
|December 2010:||Prototype of Java runtime and Java code generators, first tutorials|
|March 2011:||Prototype of graphical editors for statemachines and actor structure, model level debugging|
|August 2011:||First industrial project using eTrice|
|Further Steps:||C++ runtime and code generators, further ROOM features, C runtime and code generators|
|29-June-2010||Added mentors and interested parties.|
|29-September-2010||Added more interested parties.|
Back to the top