GitHub

Eclipse AAS Web Client is a viewer and client for interaction with Asset Administration Shell information models. The data corresponding to the Asset Administration Shell models are exchanged via a REST Interface with Asset Administration Shell servers e.g., Eclipse AASX Server & Eclipse BaSyx. Building upon the REST Interface, Eclipse AAS Web Client is able to show content of the AASs and AAS repositories. As Eclipse AAS Web Client is written completely in JavaScript, HTML5 and CSS which is executed on the client (web browser), no server infrastructure for hosting the Eclipse AAS Web Client is necessary. 

DevOps is the industry response to the challenge of application availability. It helps businesses respond rapidly to market changes, accelerating the delivery of high-quality software updates to users. It relies on continuous integration, test and delivery to reduce risk and obtain regular and rapid feedback. But in practice, IT teams face considerable barriers to the “continuous” model and many struggle to deliver against objectives and deploy DevOps principles across the enterprise at scale.  Designed to meet the needs of a modern hybrid, enterprise environment, the Eclipse DROPS CE project delivers an open platform for managing, designing, executing and monitoring secured deployment processes and pipelines. The goal of this project is to support a wide range of application release deployment activities on multiple target services regardless of their underlying technology.

Eclipse Novamoon offers a full stack low code platform providing all services to build business applications :

• Low Code back end flows
• Low code Data access layers to SQL
• Low Code REST API Connectors (Including Swagger Definition imports)
• REST API Generator for back end flows (Including the Swagger Definition portal)
• Low Code Font End Responsive UI Builder
• Low Code Font End Action Flows
• Angular Code Generators
• Android / Apple APK/ IPA package generators
• PWA Generators
• Eclipse IDE Plugin to Author Low Code projects

Novamoon Architecture

The platform can hold many projects, isolated by the URL with common requesters, but they can do internal calls to each other.

Custom REST APIs can also be declared to map HTTP calls to any project API. A project uses a YAML based description that configures all technical objects used by the back-end core and the front-end generator. This YAML based description allows usage of source control like GIT.

The back-end YAML descriptor configures properties of Java objects that run on a performance optimized JVM (now Java 17). Java is a robust and optimized stack for years.

The front-end YAML descriptor configures properties of Java or JSON objects that generate all the complex client side (HTML / Typescript / NPM package) without writing a line of code.

A CI module (ready to use with Gradle and CI platforms) allows users to generate and to perform production builds of their front-end applications, then deploy the whole project (front+back) to the integration or production back-end server.

Novamoon Eclipse IDE

• The IDE is based on an Eclipse Plugin providing all the views and editors to author LowCode projects :
• Project View listing all projects and Low Code Objects
• Property view to edit any object property
• Console views to display logs and other useful information
• Palette Views to allow user to Drag & Drop object in the project view or directly on the App Canvas
• Source picker views to allow user to bind data from back low code steps on to another or to bind data from back flows to frontend UI objects
• Connector Editors to Display Connector data

Novamoon Frontend Low Code

NovaMoon IDE allows you to create a live angular based application on your side browser. Every change is generated, built and loaded in seconds and lives like the production application.

Code Generated on the front end is Standard Angular 13.XX + Type Script Code including all the necessary frameworks.

With low-code objects from the Palette, users can invoke back-end service and bind  each parameter without coding. The call is performed using an integrated SDK and returned values can in turn be binded to any Ul objects or chained to other actions.

The IDE does live builds for development but can also perform production builds and deploy them to a back-end server with a simple 2 clicks process.

Production builds and deployment can also be performed after a GIT push and a CI/CD configured to run the ready-to-use Gradle tasks for build and deploy.

Users have the capacity to customize any part of the code by adding CustomAction (TypeScript code)  and by implementing some custom handlers directly in the application classes. NovaMoon also brings a unique Component architecture that enables some Low Code components to be reused in the same projects or within cross referenced projects.

All iOS / Android builds are automatically handled by the Gradle build tasks or directly by the IDE.

IoT devices only need to pass the mathematical expression and the input values for evaluation to Diafanis. If the mathematical expression doesn't change, the IoT device only needs to give the new input values as required. Diafanis allows IoT devices to scale the number of inputs of their sensing capabilities by moving the computing power required for mathematical calculations to a central platform.

The Eclipse Diafanis web service listens on port 8080 by default. The port can be freely configured. Calculations are then created via HTTPS request.

Example - To create a calculation the IoT device simply calls the following URL:

http://localhost:8080/?call=Diafanis&functionString=-sin(x*cos(x))^(1/y)&numberOfVariables=2&variables=x;y&values=0.5;2&interval=yes

This creates a calculation object for the function "-sin (x * cos (x)) ^ (1 / y)" and immediately performs the calculation with the "2" variables "x; y" for the values "0.5; 2". Variables and values are always separated by a ";". With "interval=yes" it is indicated that in addition to the computer-precise calculation, the upper and lower interval of the calculation is also given. The exact value of the calculation is then in this interval.

In addition, with the calculation you receive a reference to the generated calculation object for the function. From now on you can simply use this reference to get calculations for further values. References are valid for 1 hour, which is extended to 1 hour from the time of access each time a reference is accessed. If only the reference to a calculation object is used, the sometimes very long function does not have to be passed every time. That saves time and computing power.

For example, if you have received a reference "handle_Computation: 2370169936048", simply call up the following URL for a further calculation with the values 0.2 and 2 for x and y:

http://localhost:8080/?call=Diafanis&handle_Computation=2370169936048&values=0.2;2

This allows you to perform complex calculations of any length on the server.

Eclipse ExpressLy implements Jakarta Expression Language, a technology that helps software developers embed dynamically evaluated expressions in things like XML attributes, directly as template text in documents, in annotation attributes and generally as strings in Java code.

After cooperating on a few Jakarta EE specifications (and looking into their implementations as well), I have realized there are certain problems solved over and over again. This leads to duplicity of APIs and to inconsistencies (where the same problem is solved differently by each specification). I think this should be remedied, and a common specification should be created to address these common problems.

Whenever you ask a question "there is this nice API in CDI that would be very useful for my standalone specification, how do I re-use it", you may have discovered a component that would fit the Jakarta Commons project. 

Eclipse Trace Compass Cloud

Eclipse Trace Compass Cloud provides tools and components that facilitate the adoption of cloud-based trace analysis and visualization use cases.

The scope of the project includes the following:

• Trace Server Protocol (TSP) specification

• A client-side library implementation of the TSP in Typescript 

• A client-side library implementation of the TSP in Python

• Generic client front-end implementation in Typescript

• Graphical libraries for specialized visualizations (e.g. Gantt-chart type view)

• VsCode extension

Even if the Trace Server Protocol can be used for other types of visualization use cases, for example for showing profiling data or memory usage, this is not in scope initially.

The primary purpose of this project is to provide a framework for visualizing traces on a distributed platform. A limitation of monolithic implementations like Trace Compass in its current form is that the front end and the back end need to be on the same machine, as well as the trace. This makes scalability limited to a single node. Another limitation is that Trace Compass’s front-end is coupled to SWT. This works well, in many cases, but when it comes to drawing complex images, it is still using the CPU for rendering assistance. A GPU accelerated solution such as something using WebGL technologies is desirable to maintain graphical scalability on modern 4k++ displays.

This can be used as a way to effectively perform deep dives in larger traces, both in duration and breadth while leveraging modern and common UI widgets. The front end shall be hosted in the project, as well as the protocol but the back-end shall remain in the Eclipse Trace Compass project.

The main functionalities of the viewer are configuration, showing trees, continuous data (plots) and discrete data (graphs). The viewers are to be navigable and time synced allowing nanosecond resolution queries.

This shall be used in a Visual Studio Code extension that will be a front end to Eclipse Trace Compass. The protocol defined shall be openly available too, so others may add custom back ends and front ends, much like the Language Server Protocol (LSP) and Debug adapter protocol (DAP), the Trace Server Protocol (TSP) aims to have reporting primitives sent over a network to other clients. 

The goal of the trace server protocol is identical to that of the LSP and DAP. It would allow many back ends and many front ends to connect together seamlessly. It is key in remaining vendor neutral and truly open that it be hosted in a foundation such as eclipse.

Simpler example implementations shall also be made available in the server, such as a python command line viewer that could be used for CI/CD troubleshooting.

CDT GDB DAP Adapter

The Eclipse CDT GDB Adapter is an implementation of the Debug Adapter Protocol (DAP), allowing the connection of web-based tools to any device supporting GDB. The library can be included into VS Code, Theia or any client that supports DAP. For example, Renesas, ARM and Blackberry/QNX all have VS Code or Theia extensions that can allow the IDE to connect to their respective hardware and ecosystem. Whether your editor is a traditional IDE, or you are using the new generation of editors in the cloud, the adapter is a key piece that allows communication between that editor and GDB.

The Adapter is a library, and therefore enabling technologies, such as extensions, allow the library to be used in those editor/IDEs.This part of the project will therefore include such extensions and integrations as either examples or published products. Therefore, in addition to the third-party adapters that are built on top of CDT GDB Adapter, the adapter is also delivered as an extension for Theia via the Open VSX Registry and is expected to be delivered as an extension for VS Code in the near future.

Eclipse CDT.cloud Blueprint

CDT.cloud Blueprint is a template tool for building custom, web-based C/C++ tools. It is made of existing open source components and provides a typical C/C++ IDE based on the Eclipse Theia platform. This includes C/C++ language features, a language server (clangd), debugging support, memory debugging and a tracing view. It is meant to serve as a starting point for the implementation of domain-specific custom tools. For a simple showcase, CDT.cloud Blueprint can be easily downloaded and installed on all major operating system platforms.

CDT.cloud Blueprint is not a production-ready product. Therefore, it is also not meant to be a replacement for Eclipse CDT or any other IDE (yet).

As part of the CDT.cloud project, the Blueprint will serve as an integration tool that integrates other parts of CDT.cloud together with parts from outside the project. It therefore also ensures compatibility of the involved projects and can serve as a kind of simultaneous release.

Eclipse AAS Model for Java implements the specification of the Asset Administration Shell (AAS) such as metamodels, submodels, serialization and deserialization modules, validators, and transformation libraries based on the AAS specifications. It also contains all classes and properties as defined by the document 'Details of the Asset Administration Shell' published on www.plattform-i40.de. 

The Eclipse AAS Model for Java projects are focusing on the following features / functionalities:

• AAS Java Generator: The Java Generator automatically updates AAS Java Model classes and interfaces upon change in the specification documents.
• AAS Java Model: The AAS Java Model enables users to model and to represent their Digital Twins using AAS metamodels and submodels.
• AAS Java Serializer: The AAS Java Serializer enables users to serialize the AAS model into JSON, RDF, XML, AASX, OPC UA, AutomationML. This feature is necessary to support the import/export of AAS from/to these formats and validate them.
• AAS Transformation Library: The AAS Transformation Library brings the content from existing industry-standards such as OPC UA and AutomationML to the AAS.

Eclipse AASX Package Explorer is a viewer / editor for the Asset Administration Shell.  Eclipse AASX Package Explorer is a tool with graphical user interface meant for experimenting and demonstrating the potential of Asset Administration Shells targeting tech-savvy and less technically-inclined users. The Eclipse AASX Package Explorer also includes an internal REST server and OPC UA server for the loaded .AASX.

Eclipse AASX Package Explorer accelerates the development of digital twin technologies based on standards such as the Asset Administration Shell and drives its adoption in the market. As a result, the Eclipse AASX Package Explorer supports that Digital Twins technology can be easily used and deployed into existing solutions and processes with little IT infrastructure investment.  

Eclipse Velocitas provides an end-to-end, scalable, modular and open source development toolchain for creating containerized and non-containerized in-vehicle applications.

Currently, the automotive industry is facing some revolutionary changes. This includes the clear trend towards electric vehicles as well as the rise of self-driving capabilities. One very important, yet often underestimated trend is the change in value creation from hardware-heavy to software-defined features and business models, towards so called software-defined vehicles.

This project tries to:

• contribute to amplify the trend towards software-defined vehicles by providing a development environment for in-vehicle applications that offers a comfortable, fast and efficient development experience
• pursue this goal in an open ecosystem with open source elements created by manifold players of the automotive industry and beyond in order to shape and boost open de-facto standards
• provide a center of gravity of next generation automotive development environments with a lively community of developers, stakeholders and users