The [http://www.adapteva.com/parallella/ Adapteva Parallella] is a heterogeneous MPSoC with 18 cores. We want to execute real-time applications using e.g. FreeRTOS on this board and compare the results with APP4MC. Your task is to create such an application.

+

We want to execute real-time applications using e.g. FreeRTOS on typical heterogeneous embedded systems and compare the results with APP4MC. Your task is to create such an application using e.g. the [http://www.adapteva.com/parallella/ Adapteva Parallella], which is an heterogeneous MPSoC with 18 cores.

−

('''Skills required:''' C/C++, FreeRTOS)

+

('''Skills required:''' C/C++, FreeRTOS (optional))

Specific work that this could involve includes:

Specific work that this could involve includes:

−

* Get an understanding on how FreeRTOS works

+

* Get an understanding on how the (preferably RT-) OS works

−

* Create a simple application based on FreeRTOS on the Adapteva that utilizes all 16 Epiphany cores

+

* Create a simple application based on the (RT)OS on the heterogeneous embedded system that utilizes all processors

Modern automotive software tends to run on more centralized high performance machines that typically consist of several heterogeneous CPUs but also accelerators and GPUs.

+

With this (Topic 5) project, typical response time analysis for fixed priority mixed preemptive scheduling must be advanced to consider weighted round robin (WRR) scheduling for the GPU(s), task chain latencies should be calculated, and an appropriate mapping approach should be found (such as constraint programming, an evolutionary algorithm, ILP, ACO, ...) to optimize the task to processing unit mapping and minimize response times.

+

Therefore, tasks can comprise different ''tick'' amounts for either the CPUs and the GPUs that must be considered.

+

Additionally, copy operation latencies must be considered for tasks that are executed on the GPU.

+

This topic is closely, but not completely, related to the industrial [https://www.ecrts.org/forum/viewtopic.php?f=43&t=124&sid=9eb46a4f9a4417124aa63af90b7ce95f WATERS challenge] of the ECRTS community, which provides the AMALTHEA model that needs to be addressed with the java implementation within the APP4MC project.

Currently, the endpoints are synchronous: one POST a file to be signed, the server sign the file and return the result in the response body. This is a naive implementation and should be augmented with an asynchronous variant: one POST a file to be signed and get a token from the server. The server signs the file in the background. User can then poll the server with the token to query whether the file is ready or not. Instead of polling, the initial POST could also open a WebSocket waiting to be notified by the server when the file is ready. The endpoint main client (maven plugins: ) will need to be updated to benefit from the new asynchronous endpoints.

+

Currently, the endpoints are synchronous: one POSTs a file to be signed, the server signs the file and returns the result in the response body. This is a naive implementation and should be augmented with an asynchronous variant: one POSTs a file to be signed and gets a token from the server. The server signs the file in the background. User can then poll the server with the token to query whether the file is ready or not. Instead of polling, the initial POST could also open a WebSocket waiting to be notified by the server when the file is ready. The endpoint main client (maven plugins: https://git.eclipse.org/c/cbi/org.eclipse.cbi.git/tree/maven-plugins) will need to be updated to benefit from the new asynchronous endpoints.

Eclipse Vert.x is a polyglot reactive runtime that fully supports [https://www.typescriptlang.org/ TypeScript] in the form of [https://reactiverse.io.ex4x ES4X]. Support is currently provider in the form of:

+

Eclipse Vert.x is a polyglot reactive runtime that fully supports [https://www.typescriptlang.org/ TypeScript] in the form of [https://reactiverse.io/es4x ES4X]. Support is currently provider in the form of:

* proper type hinting

* proper type hinting

Line 374:

Line 386:

−

Please do not hesitate to ask questions to: sw360-dev@eclipse.org

+

'''Please do not hesitate to ask questions to: sw360-dev@eclipse.org'''

Help platform committers to re-create their IDE setup on latest nightly build in few clicks.

+

+

Links:

+

+

https://bugs.eclipse.org/bugs/show_bug.cgi?id=545164

+

+

Possible mentors: [mailto:loskutov@gmx.de Andrey Loskutov]

+

+

= Eclipse LSP4E - support for more LSP operations =

+

+

The Eclipse LSP4E project is adopted by multiple Eclipse IDE plugins as a basis to build edition support for any language, relying on the simple and powerful (enough) cross-IDE/cross-language Language Server Protocol (LSP). While the project is already mature in term of functionality and process, it's still missing support for some recent operations added to the Language Server Protocol.<br/>

The main responsibility of the student will be to identify which operations of the LSP are missing in LSP4E, and to implement as much of them as possible, sorting out the value and difficulty of each feature to prioritize their work. This will involve comparing with Visual Studio Code (as it is the reference implementation of the LSP) and trying multiple languages to see the effect of proposed changes.<br/>

+

Communication and project development happens using professional OSS state-of-art practices: open by default, usage of public channels, Git, code review (with Gerrit), code quality...<br/>

+

From LSP4E and in the context of GSoC, the student may interact with other related projects and communities: Eclipse projects (upstream dependencies and downstream adopters), but also Language Server Protocol specification or existing language servers... This topic is a good entry point for students interested in the IDE/editors/languages domain as a whole since the LSP is related to many languages and many editors/IDEs. Since LSP is a hot topic of the domain, this experience and the interaction with various communities and organizations can be very profitable to bootstrap a career.<br/>

* LSP4E open bugs and feature requests (bugs about "add support for ..." are typically the scope of the proposal): https://bugs.eclipse.org/bugs/buglist.cgi?classification=Technology&list_id=18380808&product=lsp4e&query_format=advanced&resolution=---

+

+

+

Possible mentors: [mailto:mistria@redhat.com mistria@redhat.com]

+

+

= [https://www.eclipse.org/kura/ Eclipse Kura] =

+

+

Eclipse Kura™ is an extensible open source IoT Edge Framework based on Java/OSGi. Kura offers API access to the hardware interfaces of IoT Gateways (serial ports, GPS, watchdog, GPIOs, I2C, etc.). It features ready-to-use field protocols (including Modbus, OPC-UA, S7), an application container, and a web-based visual data flow programming to acquire data from the field, process it at the edge, and publish it to leading IoT Cloud Platforms through MQTT connectivity.

+

+

== Topic 1: TensorFlow for Java in Kura ==

+

TensorFlow™ is an open source software library for high-performance numerical computation.

+

This proposal requires you to acquire a basic knowledge of TensorFlow for Java and Eclipse Kura, in order to be able to wrap TensorFlow as a Kura bundle, exposing APIs that can be leveraged by other user applications.

+

The resulting bundle should:

+

* enable the user to train the neural network

+

* Provide APIs that can be used by other applications to feed with new data the TensorFlow processing.

+

The integration should be completed by the creation of a specific Kura Wire component that has input ports for receiving messages from other Wire components, feeding the TensorFlow neural network. The Wire component is expected to have output ports for providing messages for downstream components in the graph that, for example, can publish messages to a remote cloud platform.

+

The student should design and set up a real world use case example (i.e. predictive maintenance on vibration monitoring anomaly detection) where, using a Wire Graph, the data retrieved from the field, using industrial protocols, is processed by TensorFlow and produces an alert message when an unexpected behaviour is found. This alert message can then be published to a cloud platform.

+

+

Possible mentors: [mailto:matteo.maiero@eurotech.com Matteo Maiero]

+

+

== Topic 2: Kura Driver for Bosch XDK110 ==

+

The XDK110 device is an all-in-one sensor kit designed for rapid prototyping. It features up to 8 sensors, all housed in a small form factor, and can be connected via USB, Bluetooth or WLAN.

+

The task requires the applicant to:

+

* create a Kura Driver for the Bosch XDK110, supporting at least Bluetooth connectivity, and enabling the read of XDK sensors from an Asset in Kura Wires;

+

* Design a Wire Graph that leverages the new Driver to match data, perform edge processing and publishing of results to a cloud platform

+

* Amend the documentation to describe the new Driver

+

* Update the Kura’s documentation examples section with the new use case based on the interaction between the framework itself and the Bosch XDK110.

+

+

+

Possible mentors: [mailto:matteo.maiero@eurotech.com Matteo Maiero]

+

+

== Topic 3: Eclipse Kura on GraalVM ==

+

Experiment the possibility to run Eclipse Kura or part of it onto a GraalVM, leveraging the optimization features supported by this alternative VM. The student should work to enable the OSGi stack of Kura to run on GraalVM, providing a complete analysis in terms of features leveraged and eventual improvements achieved.

+

+

Possible mentors: [mailto:matteo.maiero@eurotech.com Matteo Maiero]

+

+

= Eclipse Vorto =

+

+

The Eclipse Vorto project is part of the IoT Working Group projects and targets IoT Device manufacturers and Solution Developers integrating IoT devices with various platforms.

+

+

== Topic 1: Eclipse Vorto LSP Server for Vorto IoT Language ==

+

+

Vorto provides a DSL to describe IoT devices and their capabilitities. The language is implemented with Eclipse XText. In order to support a wider range of 3rd party tools for Vorto language, e.g. Visual Studio .NET (Monaco), the idea here is to provide a LSP server for Vorto providing auto-completing, syntax highlighting, validation etc.

The Eclipse Ditto project provides a connectivity API that allows developers to define payload transformation logic, in order to integrate IoT devices that send arbitrary payload via Eclipse Hono protocol adapters. Now the idea is to provide a Code Generator plugin that consumes Vorto Models for IoT devices and generate javascript transformation code that a developer can deploy "as-is" in the Eclipse Ditto service. This would allow a fast and easy integration of any device sending arbitrary telemetry data to the Eclipse Ditto service.

Other ideas

Project team member and potential mentors, add your content here. The format suggested below is just an idea. Play with the layout, but please don't mess with content provided by other projects. Please be sure to follow branding guidelines (e.g. "Eclipse Dash", not "Dash"). Putting things in alphabetical order seems like a fair thing to do. Links to content hosted elsewhere are fine, but bear in mind that this page will likely be the main point of contact for people who are not already inside your community.

Example Project idea

Description of the Example Project idea with links to more information, bugs, and other useful content.

Eclipse 4diac is an environment for programming distributed industrial process measurement and control systems according to the IEC 61499 standard.

Topic 1: Investigate how Eclipse 4diac can migrate to GEF 5

The modeling language defined in IEC 61499 is highly graphical language.
Currently we are using GEF legacy for implementing our graphical editors.
As GEF legacy is not maintained any more, we need a migration path to the new GEF 5.
As part of this topic a first editor could be implemented.
A good candidate could be the system configuration editor.
Based on the results of this experiment we can better estimate and plan for a full migration to GEF5.

Topic 2: Improve Dynamic Code Loading

Eclipse 4diac allows to program a wide variety of devices (e.g., PLCs from different vendors, RaspberryPI, BeagleBone Black, Lego Mindstorms).
In order to address this we have a feature that deploys user programs utilizing the Lua programming language and the Lua virtual machine.
However this is feature is highly experimental.
It would require further testing, stabilization and some features are missing.
A starting point can be these open bugs:

Topic 3: Add OCL for Detecting Model Inconsistencies in 4diac Models

Eclipse provides a OCL (Object Constraint Language) infrastructure.
This allows to specify generic constraints a model has to fulfill.
This can be utilized in Eclipse 4diac to add checks for issues and inconsistencies in the models developed in 4diac.

Eclipse APP4MC is a platform for engineering embedded multi- and many-core software systems. The platform enables the creation and management of complex tool chains including simulation and validation. As an open platform, proven in the automotive sector by Bosch and their partners, it supports interoperability and extensibility and unifies data exchange in cross-organizational projects. APP4MC is one of the results of the ITEA3 Amalthea and Amalthea4Public research projects.

What is APP4MC?

Click here to get a quick overview of how APP4MC and Capra can help you manage timing, scheduling and traceability in a multi-core environment.

Topic 1: Code-Generator for Raspberry Pi

Eclipse APP4MC integrates the Amalthea System Model that allows, among others, to describe the structure of software. In order to verify the timing behavior of software, your task is to generate code out of models that is compileable and executable on e.g. a Raspberry Pi.

(Skills required: Java, C/C++ beneficial)

Specific work that this could involve includes:

create a C or C++ file based on the content of an AMALTHEA model

generate C-functions out of tasks and runnables

annotate these with waiting methods that delay execution according to their execution time

implement inter-task communication

In case you have no access to a Raspberry Pi, we can provide you with SSH-Access to one located in our facilities.

Example:

Let us assume we have a model with one Task t1 and two Runnables r1 and r2. If Runnables r1 and r2 are executed as part of task t1, the generated C-Code could look similar to the following listing:

Topic 2: APP4MC capable Real-Time applications on embedded Systems

We want to execute real-time applications using e.g. FreeRTOS on typical heterogeneous embedded systems and compare the results with APP4MC. Your task is to create such an application using e.g. the Adapteva Parallella, which is an heterogeneous MPSoC with 18 cores.

(Skills required: C/C++, FreeRTOS (optional))

Specific work that this could involve includes:

Get an understanding on how the (preferably RT-) OS works

Create a simple application based on the (RT)OS on the heterogeneous embedded system that utilizes all processors

Topic 3: Progress visualization

The Amalthea platform tools in Eclipse APP4MC allow users to distribute data and tasks to the target hardware platforms, with the focus on optimization of timing and scheduling. Your task is to extend these tools with an visualization of the progress along with (preliminary) results.

(Skills required: Java)

Specific work that this could involve includes:

Extract metrics from APP4MC, e.g. the number of tasks, runnables, min/avg/max communications per task/label/runnable, the best quality of the partitioning/mapping tool, ...

Select a library that is suitable for visualizing these metrics e.g. Eclipse SWTChart

Create an own extension for the APP4MC tools that implements the visualization of the current progress resp. the quality metrics.

Topic 5: CPU-GPU Response Time and Mapping Analysis

Modern automotive software tends to run on more centralized high performance machines that typically consist of several heterogeneous CPUs but also accelerators and GPUs.
With this (Topic 5) project, typical response time analysis for fixed priority mixed preemptive scheduling must be advanced to consider weighted round robin (WRR) scheduling for the GPU(s), task chain latencies should be calculated, and an appropriate mapping approach should be found (such as constraint programming, an evolutionary algorithm, ILP, ACO, ...) to optimize the task to processing unit mapping and minimize response times.
Therefore, tasks can comprise different tick amounts for either the CPUs and the GPUs that must be considered.
Additionally, copy operation latencies must be considered for tasks that are executed on the GPU.
This topic is closely, but not completely, related to the industrial WATERS challenge of the ECRTS community, which provides the AMALTHEA model that needs to be addressed with the java implementation within the APP4MC project.

Topic 1.1 Add authentication

The web services are currently not authenticated, they rely on the network topology to implement access restriction. The goal is to add authentication to those webservices. An OAuth2 service will be used to provide the authentication service.

Topic 1.2: Add asynchronous endpoints

Currently, the endpoints are synchronous: one POSTs a file to be signed, the server signs the file and returns the result in the response body. This is a naive implementation and should be augmented with an asynchronous variant: one POSTs a file to be signed and gets a token from the server. The server signs the file in the background. User can then poll the server with the token to query whether the file is ready or not. Instead of polling, the initial POST could also open a WebSocket waiting to be notified by the server when the file is ready. The endpoint main client (maven plugins: https://git.eclipse.org/c/cbi/org.eclipse.cbi.git/tree/maven-plugins) will need to be updated to benefit from the new asynchronous endpoints.

Topic 2: Implement a Dashboard about apps running in a Kubernetes cluster

CBI is currently in the process of migrating all the Jenkins instances it manages (https://ci.eclipse.org) to a Kubernetes (OpenShift) cluster. The goal of this topic is to implement a dashboard listing all Jenkins instances running in the Kubernetes cluster (similar to https://ci.eclipse.org) but with live data from the cluster (pod status, resource usage, Jenkins queue size etc...). The dashboard will run itself in the cluster. Server side implementation will preferably be in Java, Rust or Go while the dashboard client will preferably be implemented as a set of reusable React JS components.

Eclipse SUMO: Simulation of Urban Mobility

SUMO is a free and open traffic simulation suite. SUMO allows modelling of intermodal traffic systems including road vehicles, public transport and pedestrians. Included with SUMO is a wealth of supporting tools which handle tasks such as route finding, visualization, network import and emission calculation. SUMO can be enhanced with custom models and provides various APIs to remotely control the simulation.

The goal of our GSoC project is to make SUMO more accessible for users of graphical user interfaces and facilitate alternative ways of setting up and interacting with the simulation.
Specific work that this could involve includes:

Topic 1: Create a new protocol adapter

Eclipse Hono is all about abstracting protocols for IoT. We already have MQTT, plain HTTP, Coap, and last year's GSoC brought us AMQP 1.0. So it only makes sense to pick another protocol this year and do an implementation for Eclipse Hono.

This topic requires you to:

Pick a protocol you want to add (as part of your proposal)

Define mappings between the Hono telemetry, event, and command & control API and the chosen protocol

The task here is not to write a new protocol implementation, but rather to use an existing protocol implementation and create a mapping to the Hono system (aka protocol adapter). For example, in last year's GSoC the task was to implement an AMQP protocol adapter, by re-using the existing Proton AMQP library.

SWTChart is a powerful library to create charts and display data using SWT. So, it can be easily used in Java desktop applications. Only a few lines of code are necessary to create interactive and feature rich charts:

If you are interested in one of the topics you have to apply on the mailing list.

Topic 1: Extending the export options

Many export options are contained already, e.g. to export to bitmaps as well as to scripts. The R script option is really helpful, especially when preparing scientific charts for publication. As the data is stored in a generic way, many different export options can be implemented. The task of topic 1 would be to add/extend the options: *.svg, *.eps, *.pdf and to put a pre-configured LaTeX table into the clipboard.

Topic 2: Handling of large data sets

SWTChart already contains a function to compress the data and reduce the time to plot series. This is important especially when handling > 100,000 data points. Compressing large data sets could be improved, e.g. to lazily load just the data that is needed, depending on the resolution of the screen. Even when handling large data sets, details should be displayed when zooming in.

Topic 3: Create default charts

Topic 1: Reactive relational database client

Eclipse Vert.x currently supports relational database using JDBC and a PostgreSQL Client. The PostgreSQL client can be extended to supports other relational databases, reusing the current client API and internal architecture.

A student willing to work on this project should have some basic knowledge in relational databases and be capable of reading and understanding database access protocols which are publicly available such as the PostgreSQL, MySQL or SQLServer protocols.

The student should also be able to use networking tools such as Wireshark or TCP dump which can be useful for developing such protocols in a client.

Finally the student must also have a good pro-efficiency with the Java language, event driven architectures and Java concurrency in general.

The goal is to implement the Service Provider Interface of a non-blocking database client for the MSSQL database which are openly and clearly documented:

develop the set of command to authenticate and close a connection to an SQL Server database

develop query execution (also known as simple queries) and retrieve results from the database

Topic 2: Full polyglot support of TypeScript (outside vert.x APIs)

Eclipse Vert.x is a polyglot reactive runtime that fully supports TypeScript in the form of ES4X. Support is currently provider in the form of:

proper type hinting

compile time validation

generated type definitions

However if libraries are used that were not specifically written for use with vert.x no help is available. This project would be to enhance/extend the current tooling to extract basic class metadata to generate a bare type definition file(s) for non vert.x API jars.

A student willing to work on this project should have some basic knowledge in TypeScript and be capable of using tools available with any JDK such as:

jar

javap

The goal is to implement a tool, that given a random jar file, will generate a set of TypeScript definition files for each public class/interface. The format is already well defined in the vert.x project, which makes the task of the student a bit simpler:

1. identify a way to read a random jar
2. list all public APIs in the given jar
3. map the public APIs to a JavaScript import file
4. map the generated import file to a TypeScript .d.ts file
5. package the generated code into a npm package
6. automate all the steps into a simple CLI tool

Eclipse SW360 supports software development by managing a component inventory for products and projects. The component inventory will be fed by build tool chains using a REST API and the inventory can help for a number of tasks: license compliance, vulnerability management, export control for "interesting" technologies, statistics about component usage, and so forth. Imagine a person in an organisation asking "I would like to know which products have commons-collections-3.2.1.jar?" (referring to the vulnerability that was reported once in 2017) - using SW360 as central component inventory can answer this question.

We from the Eclipse SW360 team would like to offer GOSC topics, if you are interested in the topic or technology. The SW360 technology stack is:

Topic 1: Make Eclipse SW360 Fit for OSS Foundations

SW360 can be used for organizations in general: However, currently, the main input for use cases was coming from commercial organizations, companies. However, since SW360 is entirely open source software, how would use looks like for OSS foundations? Main use cases of foundations are about license compliance as well - for example ensuring license compatibility of involved OSS in the software project hosted by a foundation. The GSOC project proposes to implement an integration of Eclipse SW360 into the operations of the Eclipse Foundation. As such, as for the preparations, the relevant use cases and interaction with existing build hardware needs to be determined. Then, the project shall focus on three main use cases:

Topic 2: Create a cool statistics dashboard

Currently, there is some overview as of tables, and users can export spreadsheets for drawing pie charts, but the latter requires export. SW360 users would greatly take advantage from charting that allows to select from predefined values:

Time frame (1 day, 1 week, 1 month, 1 year, 10 years) where time frame could present the interval by using the step below (one day shows data at the interval of hours, one week shows the interval of days)

That is for the basics, another area of charting is interesting for license compliance metrics, where the charting mode can vary (not necessarily using bar charts, but pie charts):

which licenses do appear

what is their distribution

list components by license

This part could be displayed as separate portlet.

For users, a statistics dashboard allows for displaying charts based on selectable metrics. The metrics could be predefined queries in terms of metric and time frame and interval.

Topic 1: Eclipse Dart Support

Topic 2: Usability improvements for the Eclipse IDE

Help improving the usability of the Eclipse IDE. This can for example include contributing and testing the platform notification API, simplifying Git operations, moving blocking dialogs to non-blocking, migrating code minings from Github implemtations to standard.

Topic 3: Easy Eclipse setup for platform development

Eclipse LSP4E - support for more LSP operations

The Eclipse LSP4E project is adopted by multiple Eclipse IDE plugins as a basis to build edition support for any language, relying on the simple and powerful (enough) cross-IDE/cross-language Language Server Protocol (LSP). While the project is already mature in term of functionality and process, it's still missing support for some recent operations added to the Language Server Protocol.
Improving LSP4E will automatically and immediately improve the quality of multiple editors (HTML, CSS, JavaScript, Typescript, JSon, Yaml, Rust, C#, Bash...), by adding them extra features or enhanced usability.

The main responsibility of the student will be to identify which operations of the LSP are missing in LSP4E, and to implement as much of them as possible, sorting out the value and difficulty of each feature to prioritize their work. This will involve comparing with Visual Studio Code (as it is the reference implementation of the LSP) and trying multiple languages to see the effect of proposed changes.
Communication and project development happens using professional OSS state-of-art practices: open by default, usage of public channels, Git, code review (with Gerrit), code quality...
From LSP4E and in the context of GSoC, the student may interact with other related projects and communities: Eclipse projects (upstream dependencies and downstream adopters), but also Language Server Protocol specification or existing language servers... This topic is a good entry point for students interested in the IDE/editors/languages domain as a whole since the LSP is related to many languages and many editors/IDEs. Since LSP is a hot topic of the domain, this experience and the interaction with various communities and organizations can be very profitable to bootstrap a career.

Eclipse Kura™ is an extensible open source IoT Edge Framework based on Java/OSGi. Kura offers API access to the hardware interfaces of IoT Gateways (serial ports, GPS, watchdog, GPIOs, I2C, etc.). It features ready-to-use field protocols (including Modbus, OPC-UA, S7), an application container, and a web-based visual data flow programming to acquire data from the field, process it at the edge, and publish it to leading IoT Cloud Platforms through MQTT connectivity.

Topic 1: TensorFlow for Java in Kura

TensorFlow™ is an open source software library for high-performance numerical computation.
This proposal requires you to acquire a basic knowledge of TensorFlow for Java and Eclipse Kura, in order to be able to wrap TensorFlow as a Kura bundle, exposing APIs that can be leveraged by other user applications.
The resulting bundle should:

enable the user to train the neural network

Provide APIs that can be used by other applications to feed with new data the TensorFlow processing.

The integration should be completed by the creation of a specific Kura Wire component that has input ports for receiving messages from other Wire components, feeding the TensorFlow neural network. The Wire component is expected to have output ports for providing messages for downstream components in the graph that, for example, can publish messages to a remote cloud platform.
The student should design and set up a real world use case example (i.e. predictive maintenance on vibration monitoring anomaly detection) where, using a Wire Graph, the data retrieved from the field, using industrial protocols, is processed by TensorFlow and produces an alert message when an unexpected behaviour is found. This alert message can then be published to a cloud platform.

Topic 2: Kura Driver for Bosch XDK110

The XDK110 device is an all-in-one sensor kit designed for rapid prototyping. It features up to 8 sensors, all housed in a small form factor, and can be connected via USB, Bluetooth or WLAN.
The task requires the applicant to:

create a Kura Driver for the Bosch XDK110, supporting at least Bluetooth connectivity, and enabling the read of XDK sensors from an Asset in Kura Wires;

Design a Wire Graph that leverages the new Driver to match data, perform edge processing and publishing of results to a cloud platform

Amend the documentation to describe the new Driver

Update the Kura’s documentation examples section with the new use case based on the interaction between the framework itself and the Bosch XDK110.

Topic 3: Eclipse Kura on GraalVM

Experiment the possibility to run Eclipse Kura or part of it onto a GraalVM, leveraging the optimization features supported by this alternative VM. The student should work to enable the OSGi stack of Kura to run on GraalVM, providing a complete analysis in terms of features leveraged and eventual improvements achieved.

Eclipse Vorto

The Eclipse Vorto project is part of the IoT Working Group projects and targets IoT Device manufacturers and Solution Developers integrating IoT devices with various platforms.

Topic 1: Eclipse Vorto LSP Server for Vorto IoT Language

Vorto provides a DSL to describe IoT devices and their capabilitities. The language is implemented with Eclipse XText. In order to support a wider range of 3rd party tools for Vorto language, e.g. Visual Studio .NET (Monaco), the idea here is to provide a LSP server for Vorto providing auto-completing, syntax highlighting, validation etc.

Topic 2: Vorto Code Generator for Eclipse Hono/Ditto Payload Mappings

The Eclipse Ditto project provides a connectivity API that allows developers to define payload transformation logic, in order to integrate IoT devices that send arbitrary payload via Eclipse Hono protocol adapters. Now the idea is to provide a Code Generator plugin that consumes Vorto Models for IoT devices and generate javascript transformation code that a developer can deploy "as-is" in the Eclipse Ditto service. This would allow a fast and easy integration of any device sending arbitrary telemetry data to the Eclipse Ditto service.