The ThingML approach is composed of i) a modeling language, ii) a set of tools and iii) a methodology. The modeling language combines well-proven software modeling constructs for the design and implementation of distributed reactive systems:
- statecharts and components (aligned with the UML) communicating through asynchronous message passing
- an imperative platform-independent action language
- specific constructs targeted at IoT applications.
The ThingML language is supported by a set of tools, which include editors, transformations (e.g. export to UML) and an advanced multi-platform code generation framework, which support multiple target programming languages (C, Java, Javascript). The methodology documents the development processes and tools used by both the IoT service developers and the platform experts.
ThingML is distributed under the Apache 2.0 licence, and has been developed by @ffleurey and @brice-morin of the Networked Systems and Services department of SINTEF in Oslo, Norway, together with a vibrant open-source community. ThingML is now owned by Tellu, but remains open-source.
Issues, bug reports and feature requests should be submitted to the issue tracker on GitHub
ThingML can compile code for various platforms and languages. Please make sure you follow the required steps
If you are going to compile Java code from ThingML, please:
If you are going to compile Javascript code from ThingML, for:
- NodeJS: Install Node.JS
- Browser: Make sure you have a decent web browser (Chrome or Firefox should work fine, and probably some others)
If you are going to compile UML Diagrams from ThingML, please:
- Install Graphviz
If you are going to compile Arduino code from ThingML, please:
- Install Arduino IDE
If you are going to compile Teensy code from ThingML, please:
- Install Teensyduino IDE
or
- Install cross compiled arm toochain
- Install teensy command line loader
If you are going to compile C code from ThingML, please:
- Use a C-friendly OS (such as Linux) with a decent build toolchain (
make
,gcc
), potentially in a Virtual Box
The easiest way to get started with ThingML is to use the ThingML plugins in the Eclipse IDE.
If you have docker, you can use the build container with Eclipse and ThingML at the thingmleditor repository or the thingmleditor docker hub
Else
- Download Eclipse for Java Developers
- Install and Launch Eclipse
- Install XText plugins:
Help -> Install New Software... -> Add...
and chooseXText
as a name andXtext - http://download.eclipse.org/modeling/tmf/xtext/updates/composite/releases/
as location, and thenOK
. SelectXText
and continue with the install procedure β³ - Install the ThingML plugins: Same procedure. Use
ThingML - http://thingml.org/dist/update2/
update site, and select ThingML β³
You are now ready to use ThingML. β
Once you have created (or imported) ThingML files in your workspace, simply right click on a ThingML file in order to compile it. A HEADS / ThingML
should be present in the menu and you can then select which compiler to use: Java, JavaScript, C, etc.
The ThingML file you want to compile should contain a
configuration
The generated code will be located in a
thingml-gen
folder in your current project
β Configure Eclipse so that it uses the JDK: Window -> Preferences -> Java -> Installed JREs
(make sure it points to a JDK)
- Right click on
pom.xml
(inthingml-gen/java/your-configuration
) Run as -> Maven build...
- In
Goals
type:clean install exec:java
If Maven claims it cannot find a
pom.xml
file, change the base directory in theRun as -> Maven build...
window using theWorkspace...
button, so that it points tothingml-gen/java/your-configuration
.
Nothing special. Open the generated index.html
file in your System Browser (ideally Chrome or Firefox)
Do not use the default web browser embedded into Eclipse!
β In Eclipse, from this update site: Node.JS - http://www.nodeclipse.org/updates/enide-2015/
, install Features included in Enide Studio .Features Set
and Nodeclipse Node.js .Features Set 1.0.2.201509250223
- Right click on
package.json
(inthingml-gen/nodejs/your-configuration
) Run as -> npm install
- Right click on
main.js
Run as -> Node Application
β Install PlantUML plugins in Eclipse using this update site: http://files.idi.ntnu.no/publish/plantuml/repository/
(See below for how to install plugins in Eclipse)
Window -> Show View -> Other... -> PlantUML
Make sure you have Graphviz installed (see Prerequisites)
- Open a terminal at
...thingml-gen/posix/your-configuration
make
./your-configuration
- Open the generated file in the Arduino IDE
- Compile
- Upload to your board
For more information about how to use the Arduino IDE and Arduino boards, have a look at the Arduino documentation.
You need Git, Maven, and a proper JDK8+
git clone https://github.com/TelluIoT/ThingML.git
cd ThingML
mvn clean install
cd language
mvn clean install
The command-line interface JAR (containing all you need to compile ThingML files) can be found here:
cd compilers/registry/target
java -jar compilers.registry-2.0.0-SNAPSHOT-jar-with-dependencies.jar
--- ThingML help ---
Typical usages:
java -jar your-jar.jar -t <tool> -s <source> [-o <output-dir>] [--options <option>][-d]
Usage: <main class> [options]
Options:
--compiler, -c
Compiler ID (Mandatory unless --tool (-t) is used)
--create-dir, -d
Create a new directory named after the configuration for the output
Default: false
--help, -h
Display this message.
Default: false
--list-plugins
Display the list of available plugins
Default: false
--options
additional options for ThingML tools.
--output, -o
Optional output directory - by default current directory is used
--source, -s
A thingml file to compile (should include at least one configuration)
--tool, -t
Tool ID (Mandatory unless --compiler (-c) is used)
Compiler Id must belong to the following list:
?? sintefboard - Generates C++ based in code for Arduino.
?? posixmt - Generates C code for Linux or other Posix runtime environments (GCC compiler).
?? java - Generates plain Java code.
?? arduino - Generates C/C++ code for Arduino or other AVR microcontrollers (AVR-GCC compiler).
?? UML - Generates UML diagrams in PlantUML
?? browser - Generates Javascript code that can run in common Web Browsers.
?? nodejsMT - Generates Multi-Process Javascript code (one nodejs process per instance) for the NodeJS platform.
?? nodejs - Generates Javascript code for the NodeJS platform.
?? posix - Generates C/C++ code for Linux or other Posix runtime environments (GCC compiler).
?? debugGUI - Generates html/js mock-up for other a ThingML external connector
Tool Id must belong to the following list:
?? testconfigurationgen - Generates test configuration for things annnotated with @test "input # output".
Nowhere! Or almost everywhere, from microcontrollers to the cloud!
A ThingML file per se is a design-time specification of the structure (components) and behavior (state machines) of a reactive system. It cannot be directly executed.
A ThingML file can however be compiled (or transformed) to Java/JavaScript/C/Arduino source code, which can in turn be compiled and executed on a platform. Code generated from ThingML has been successfully executed on a large number of platforms: PC Windows/Linux, Raspberry Pi 1, 2 and 3, Intel Edison, Arduino Uno/Mega/Yun/Mini, ESP8266/ESP32, Trinket, Teensy, and probably others.
A set of tutorials is available here. The tutorials describe the most common features of ThingML. In addition, an extensive set of tests describes pretty much all the concepts available. Have a look there is you wonder how to express something. Should this information be insufficient, have a look below.
The ThingML language is formalized into an EMF-based metamodel. The textual syntax is formalized as an XText grammar.
ThingML is backed by a set of scientific publications (PDFs can easily be found on e.g. Google Scholar):
- Model-Based Software Engineering to Tame the IoT Jungle
Brice Morin, Nicolas Harrand and Franck Fleurey
In IEEE Software, Special Issue on Internet of Things, 2017. - ThingML, A Language and Code Generation Framework for Heterogeneous Targets
N. Harrand, F. Fleurey, B. Morin and K.E. Husa
In MODELSβ16: ACM/IEEE 19th International Conference on Model Driven Engineering Languages and Systems. Practice and Innovation track. St Malo, France, October 2-7, 2016 - MDE to Manage Communications with and between Resource-Constrained Systems
F. Fleurey, B. Morin, A. Solberg and O. Barais.
In MODELSβ11: ACM/IEEE 14th International Conference on Model Driven Engineering Languages and Systems. Wellington, New Zealand, October 2011.
ThingML has also been used together with other approaches:
- Agile Development of Home Automation System with ThingML
A. Vasilevskiy, B. Morin, Γ. Haugen and P. Evensen.
In INDINβ16: 14th IEEE International Conference on Industrial Informatics. Poitiers, France, July 18-21, 2016 - A Generative Middleware for Heterogeneous and Distributed Services
B. Morin, F. Fleurey, K.E. Husa, and O. Barais.
In CBSEβ16: 19th International ACM Sigsoft Symposium on Component-Based Software Engineering. Venice, Italy, April 5-8, 2016
Embed the command-line inteface JAR described previously in this readme in your classpath.
You can also include ThingML as a Maven dependency in your project:
<dependency>
<groupId>org.thingml</groupId>
<artifactId>compilers.registry</artifactId>
<version>1.0.0-SNAPSHOT</version>
</dependency>
...
<repository>
<id>thingml-snapshot</id>
<name>thingml-snapshot</name>
<url>http://maven.thingml.org/thingml-snapshot/</url>
</repository>
<repository>
<id>thingml-release</id>
<name>thingml-release</name>
<url>http://maven.thingml.org/thingml-release/</url>
</repository>
Rather than being monolithic blobs, compilers are implemented in a modular way around a set of extension points defined in the ThingML Code Generation Framework.
Well, it is up to you to implement a compiler for whatever language that is not supported by default. What are you waiting for?
File myFile = new File("source.thingml");
ThingMLModel myModel = ThingMLCompiler.loadModel(myFile);
//Do something
ThingMLCompiler.saveAsThingML(myModel, "target.thingml");
//or
ThingMLCompiler.saveAsXMI(myModel, "target.xmi");
Protip1: Make sure you have a good understanding of the ThingML metamodel
Protip2: Have a look at the helper functions which simplify some typical treatments
Models saved this way will contain all the imports that the original file refered to in one big file
This feature might currently be broken as we migrated to XText.
Visit thingml.org to find out more about ThingML !