Proposals

The Eclipse SysON project provides an open-source web-based tooling to edit SysML v2 models. It includes a set of editors (graphical, textual, form-based, etc.) enabling users to build the various parts of system models. Capitalizing on the capabilities of the Sirius Web platform, SysON offers a user-friendly interface, facilitating seamless model creation, modification, and visualization.

Furthermore, Eclipse SysON is the core of the SysMLv2 model editing feature of Papyrus and seamlessly enables co-design of SysMLv2 models alongside Eclipse Capella.

Additionally, Eclipse SysON embraces the standard API for interconnection, enhancing the interoperability of these vital modeling resources and will support the SysML v2 textual specifications as an exchange format, to ensure seamless transitions. 

Through this initiative, we seek to foster growth within the MBSE community by providing a robust and accessible tool that harmonizes seamlessly with modern modeling landscapes.

 

The Eclipse Simultaneous Release process works as follows:

• The simrel.aggr model specifies precisely what is to be aggregated.
• The simrel.build change-requests jobs validate each pull request to the simrel.aggr model before the change is committed to the main branch.
• The simrel.build main job promotes each succesfull aggregation build of the current simrel.aggr model on the main branch to the appropriate current subdirectory of staging to produce the SimRel p2 Staging Repository.
• The Eclipse Packaging Product's CI jobs produce an EPP p2 Repository and corresponding EPP Products using the SimRel p2 Repository as input.
• Various Releng jobs periodically promote staging repositories to more permanent locations.

The Eclipse OS-Gov project provides guidelines and best practices for the governance and management of open source projects. Developed by recognised open source experts, it covers a wide range of topics, from tooling to communication and security. It only provides recommendations, as projects should adapt their practices to their own context.

We intend to develop these recommendations in a collaborative manner with the community, and publish various outputs (PDF, epub, HTML) freely available to everybody.

Eclipse openDuT automates the testing and validation process for automotive software and applications. This includes offering a framework for the testing and validation process but also includes process descriptions of the intended use.

It focuses on reliable, repeatable, and observable automated test and validation executions. The main building blocks are:

• Model or description language of test cases that can be kept private or can be part of the open-source context, for example to offer a common implementation of a required topic for legal assessments.
• Test Execution Engine as OSS reference implementation and open APIs to plug-In private engines for private Test Cases.
• Test Management and Execution as component taking care about the needed capabilities to execute test cases and collect the results and insights.
• Management Service to orchestrate, observe and establish communication between distributed Hardware ECUs and Emulated ECUs. Distribution means that the (virtual) devices can be in different networks and even separated by proxies and the internet.
• Hardware Abstraction, Automotive Applications and Communication for uniform interaction with an abstract driver for different automotive networks e.g., CAN.

Main Use Cases are:

• (Fully automated) grey-box tests for single ECUs or clusters of ECUs
• Execution of tests over distributed test benches
• Realization of functional and explorative tests
• Coverage of Complete Security attack scenarios
• Easy interfacing and usability of the framework (Compatibility with external protocols, modularization, …)
• Observation of the test setup to verify if the test has been effective.
• Cloud/on-premises/hybrid deployments
• Adaption and full functional integration of 3rd party components (OSS, proprietary/ private source)

Qrisp is a high-level programming language for working with quantum computers. Qrisp is designed to enable programmers to write complex quantum algorithms with the ease of a modern day programming language, while still compiling down to the circuit level. By automating much of the low-level coding duties, such as gate-by-gate assembly or qubit management, we aim to open this field of research to a broad audience of developers. Qrisp was originally developed at Fraunhofer FOKUS funded by the German ministry for economic affairs and climate action.

The state of the art in programming a quantum computer pretty much resembles programming in assembler – even worse, while assembler provides at least some basic commands more abstract than the actual hardware gates, in quantum computing using gates and qubits only, is the standard. Frameworks like Qiskit or Cirq allow the user to create sub-circuits which can be reused in larger, more complex circuits. However, the handling of the circuits is still rather cumbersome.

Qrisp aims to tackle this challenge by trying to hide the qubit and gate structure of the underlying circuits as much as possible. This is achieved by conceptually replacing gates and qubits by functions and variables. This permits the creation of much more complex circuits than would ever be possible with handling gates and qubits directly. Of course, moving to variables and functions does not end programming with gates and qubits. The elementary quantum functions still need their implementation - under the hood - compiled using gates and qubits. This is why Qrisp comes with its own circuit creation module, which has most of the relevant features known from the established circuit creation frameworks.

Variables and functions not only simplify the management of highly complex circuits – due to the structure of an actual programming language many circuits can be created in a highly modular manner. This improves the possibility to easily maintain or upgrade certain parts of the code.

Apart from allowing highly complex circuit creation, Qrisp can also serve a pedagogical aspect, opening up this realm to non-physicists. This is because in Qrisp many quantum functions and control structures are already pre-programmed and therefore do not require the understanding of complex linear algebra that is needed when comprehending gate sequences.

Eclipse Epicyro implements Jakarta Authentication, a technology that defines a low-level SPI for authentication mechanisms, which are controllers that interact with a caller and a container’s environment to obtain the caller’s credentials, validate these, and pass an authenticated identity (such as name and groups) to the container.

Eclipse Epicyro provides default implementations of these authentication mechanisms and algorithms, as defined and mandated by the Jakarta Authentication specification.

Eclipse BlueChi is built around three components:

• The hirte service, which is the primary controller that runs on the primary node
• The hirte-agent services, which run on each managed node and are the agents that talk locally to systemd to instruct systemd to act on services
• The hirtectl command line, which is used by administrators to test, debug and manually manage services across nodes

Eclipse BlueChi is meant to be used in conjunction with a state manager (a program or person) that knows the desired state of the systems. This design choice has a few consequences: 

• Eclipse BlueChi does not know the desired final state of the systems; it only knows how to transition between states, such as how to start, stop or restart a service on one or more nodes 
• Eclipse BlueChi monitors and reports changes in the services that are running and alerts the state manager when a service stops or when the connection to a node is lost, but hirte itself does not act on these notifications
• Eclipse BlueChi does not handle the initial setup of the system; the system boots into a desired state and hirte handles the transitions from this state

The state manager program integrates with hirte over D-Bus. The state manager tells hirte to perform actions or to receive the outcome of actions. Eclipse BlueChi monitors services and nodes via D-Bus and reports state changes back to the state manager. Administrators can use the hirtectl interface to avoid interacting directly with hirte via D-Bus.

Eclipse Langium is a toolkit for domain-specific languages (DSLs) that is fully built with TypeScript. It provides a text parser with integrated cross-reference resolution and a language server for smart editor support. You can use Langium to build custom text languages that can be automatically processed. For example, you can execute user-defined behavior with an interpreter, or generate executable code, documentation, or other output formats. Such a custom language can

• empower non-technical persons to provide data, logical constraints, executable behavior, or similar concepts,
• greatly reduce the manual effort to create artifacts such as source code or documentation,
• strengthen the communication between stakeholders with a formal language.

Eclipse Langium aims to enable DSL development in a web-based technology stack. When used in the context of a desktop app (e.g. VS Code, Eclipse IDE, etc.), Langium runs on the Node.js platform. Additionally, it can run in a web browser to add language support to web applications with embedded text editors (e.g. Monaco Editor). The interface between Langium and the text editor is the Language Server Protocol (LSP).

The entry point of a Langium project is the grammar language – similarly to how Eclipse Xtext works. A grammar file describes the concrete syntax by instructing the parser how to read input text, and also the abstract syntax by defining object types and their properties. The resulting abstract syntax tree (AST) is created by the parser that Langium provides based on the grammar declaration. The AST is the basis for all further operations, including cross-reference resolution, validation, code generation and much more.

In addition to editor support through LSP, a Langium-based language implementation can be used as a library to implement automation processes: interpret (execute) language instances, generate different artifacts, transform into specific modeling formats, and so forth – there are vast possibilities that can be explored depending on your project context and the specific problems you would like to address.

Eclipse OpenXilEnv is a lightweight SIL/HIL environment that allows running embedded software functions on a PC without a target platform and compiler.

Eclipse OpenXilEnv will provide a configurable graphical user interface and an API for automation.

Use case scenarios:

• Software in the Loop
• Model in the Loop
• Open Loop
• Hardware in the Loop
• Module tests
• Network tests
• Complete digital twin test
• Manual tests
• Automated tests
• Rapid prototyping
• Offline calibration

Some highlights are:

• Easy integration of the code under test
• Clean separation in own executables (memory protection) Communication over a network layer
• Platform independent (Windows/Linux)
• User interface (Qt) with a lot of display items (text, oscilloscope, tacho, ...),  items for manual intervention (text, slider, knob, ...)  and calibration items for single, curve and map parameters
• Tree view of all static parameter and variables (debug information)
• Can be extensively automated with a remote procedure call interface (Python) or a build-in script interpreter
• GUI less variant exist for automation (Headless Variant)
• Parallel execution (multi core) of test code 
• Support of FMUs with FMI2.0 interface (64 and 32 bit)
• Residual bus simulation of non-existing CAN (FD) bus members
• Recording and replay in stimulation is possible with text or MDF3 files
• Debug information parser (dwarf)
•  A small A2L parser is included for calibration.A XCP over ethernet port to connect a calibration system
•  Parallel execution (multi core) support with barriers for synchronisation.

OpenXilEnv was developed and maintained at ZF for the last 25 years and used in numerous projects.

Eclipse Autowrx is the open source implementation of digital.auto (http://digital.auto), an industry-wide initiative enabling the automotive industry to establish a new, digital-first approach for the creation of next-generation customer experiences and data-driven mobility services. Designed as an open ecosystem with a very use-case-centric approach, digital.auto is bringing together automotive original equipment manufacturers (OEMs), suppliers and partners to drive transformation of the industry. The global initiative builds on two key pillars of automotive technology development: the software-defined vehicle (SDV) and standardized vehicle APIs. Eclipse Autowrx aims to combine existing standards with appropriate methods and best practices to translate technology into business value. Co-initiators include Robert Bosch GmbH as well as software companies Dassault Systèmes and LeanIX. The initiative is hosted by Heilbronn-based Ferdinand-Steinbeis-Institut (FSTI) as a neutral, non-profit facilitator and was launched in November 2022.

The ultimate goal of Eclipse Autowrx is to support digital value creation for OEMs in close alignment with the development of the physical elements of the vehicle.