The Koneki project is a proposed open source incubator project under
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 Eclipse
[Wikipedia] : Machine-to-Machine (M2M) refers to technologies that
allow both wireless and wired systems to communicate with other devices
of the same ability.
When first faced with the assignment of setting up a remote
management and supervision system for devices scattered over a large
geographical area, a developer faces miscellaneous and usually tricky
- Embedded application development complexity
- Because it is very close to the underlying hardware, embedded
development can turn out to be a complex task, especially considering
the fact that people developing M2M solutions are domain experts
(healthcare, smart grid, …), not necessarily software
- Variety of M2M embedded modules - There are
many M2M-capable devices available on the market, and they all come
with different operating systems (although Linux seems to become the
norm), different APIs to communicate with a distant server (over
HTTP, TCP, or whatever) or with a "local" asset (serial protocol,
Modbus, ZigBee®, …). This fragmentation makes it very difficult
to come up with reusable, portable, software.
The main goal of the proposed project is to provide
Machine-to-Machine solutions developers with tools easing the
development, simulation, testing/debugging and deployment of such
More specifically, Koneki aims at:
- Enabling M2M development
- support for languages and runtimes used to develop M2M
applications, with a specific focus on Lua (ligthweight language,
very well-suited for M2M applications)
- support for communication protocols used in M2M
- smooth integration of M2M servers
- Establishing an M2M application model
- Providing tooling built on top of this application model to
improve M2M development experience.
As detailed in the Background paragraph, there are many
flavors of M2M modules, vendor SDKs, communication protocols, etc. ;
the proposed project will therefore define and expose the APIs needed
to support M2M development in the large.
The Koneki project goal will be to deliver a first-class
development environment for M2M solutions developers.
Here are the key features that the Koneki project aims at
- M2M Embedded
- Language tools — Koneki will rely
on existing language development tools (CDT, JDT, DLTK-based
editors, …) to give the M2M developer access to usual editing
features (syntax highlighting, content assist, outlines, …).
- M2M embedded runtimes — Koneki will
ease the use of M2M embedded runtimes: remote configuration, remote
application deployment/debugging, shell access, …
- M2M application generation — Koneki
will provide an extensible generation infrastructure built on top
of the M2M application model.
- Application examples —
Machine-to-Machine solution developers are not necessarily skilled
embedded developers (e.g. a solution to remotely control an
industrial equipment will likely be developed by a control
engineer), the Koneki project will therefore focus on providing the
developer with embedded application templates and examples.
- Koneki project will provide the user with utilities to
manipulate M2M & industrial protocols: encode/decode binary
frames, perform bandwidth usage simulation according to different
communication scenarios, etc.
- Simulation — Koneki will provide
extension points enabling the creation of a consistent UI on top of
existing protocol simulators/emulators.
- M2M Server
- Koneki will define an abstraction (a la WST Server Adapter)
of what an M2M server is. It will allow M2M services providers to
implement their own connector, and developers to easily configure
the server-side model of their application, discover the Web
Services exposed by the server, etc.
- Simulation — Koneki will provide a
generic simulation infrastructure to allow developer to test
different communication policies (and their consequences on
bandwidth consumption), monitor data transfers, simulate
communication failures, etc.
- Application examples — Koneki may
package exemplary end-user applications to illustrate the use of
M2M server APIs.
- M2M Model
- Application model — Koneki will
implement an M2M application model allowing an M2M solution
developer to create an abstract definition of the capabilities of
an M2M application (communication capabilities, exposed variables,
communication policy, supported remote commands, …).
- Application editors — Koneki will
provide high-level editors (forms, diagrams, DSL-based editors) of
M2M application models, assisting the developer with the design of
his/her embedded application.
The Koneki project has relationships with many Eclipse projects
and the Koneki team will closely collaborate with these projects
- Lua tooling relies on DLTK 2,
- “EMF Forms” (PDE Incubator) is used for easing
the development of form-based editors,
- Tools TM (Terminal and RSE components) is used to communicate
with embedded devices,
- Modeling projects (EMF, EMF Transaction, GMF) support the
M2M application model,
Koneki will work even more closely with eTrice (MDT project) and
Yakindu (EclipseLabs project at the moment) teams to establish an M2M
In addition, an Eclipse M2M Industry Working Group will likely
be created to help industrial partners and tool vendors to come up
with a reference environment to develop M2M solutions. Having Koneki
at eclipse.org is the best way to ensure a good collaboration between
the Koneki team and the members of the Working Group in charge of
identifying M2M tooling requirements.
The Koneki project will be seeded with an initial contribution
from Sierra Wireless in the form of the following tools:
- A set of plug-ins to suppport the Lua language: editor,
content-assist, packaging, …
- A set of plug-ins to ease Linux target communication: remote
project copy, remote application launch, debugging …
- A packaging mechanism of M2M applications examples,
- A prototype of a component model for M2M applications, based
on a dataflow paradigm,
- A graphical editor on top of this component model to give the
developer the ability to visualize and modify its application
structure, and perform type and consistency checks.
No legal issues are anticipated although all 3rd party bundles
used in the initial contribution, and that are not already made
available via the Orbit project, will need to go through the standard
Eclipse IP process.
The following individuals are proposed as initial committers to
Benjamin Cabé, Sierra Wireless (project co-lead)
- Benjamin is a long-time contributor on many Eclipse projects
(Eclipse, PDE, EMF, ECF, …) and committer on e4 and PDE
(inactive though). He loves spreading the good word about Eclipse
awesomeness at various conferences and writing blogs and articles.
Gaétan Morice, Sierra Wireless (project co-lead)
- Gaétan leads the Embedded Tooling Development team at
Sierra Wireless. The tools his team is developing will be built on
top of Koneki components. On a side note, he is passionated by modern
programming languages, and especially Clojure.
Simon Bernard, Sierra Wireless
- Simon is the lead developer of Sierra Wireless Tools for
Embedded Development. He has 5+ years of experience with Eclipse
development (RCP, EMF, GMF, CDT, …).
Kévin Kin-Foo, Sierra Wireless
- Kévin is the developer behind LuaEclipse 2, which he
has developed during an internship at Sierra Wireless, and improved
on his spare time. He has been hired by Sierra recently and will be
the lead developer for the Lua Development Environment.
We welcome additional committers and contributions.
The following Architecture Council members will mentor this
- Bernd Kolb, SAP AG
- Martin Oberhuber, Wind River
The following individuals, organisations, companies and projects
have expressed interest in this project:
- Kai Kreuzer, openHAB project lead
- Kévin Kin-Foo, LuaEclipse 2 project
- itemis AG (Yakindu project)
- Protos Software GMBh (eTrice project)
- Joe Biron, Axeda
- May 2011 – Sierra Wireless initial contribution
- Lua tooling
- Modeling environment prototype
- June 2011
- Convert Koneki's build to Tycho
- Make Lua Tooling available at Eclipse Marketplace
- Q3 2011
- Call for community participation to define an M2M
- Improve Lua Tooling: LuaRocks support
- Q4 2011
- Communicate at EclipseCon Europe
- Setup M2M server simulation infrastructure
- Lua Tooling component to be moved to its own Technology
- Q2 2012 – First release of an “end-to-end”
Changes to this Document
||Added Kai Kreuzer from openHAB to the Interested Parties
||Added Kévin Kin-Foo from LuaEclipse 2 to Interested Parties
||Added new Interested Parties and Mentors
||Detailed the functional architecture.
project plan and relationships with other Eclipse projects.
Added Kévin Kin-Foo to initial committers list.