© https://github.com/MontiCore/monticore; Contact: Christian Kirchhof

The MontiThings Core repository contains everything related to the common basis of the MontiThings architecture description, a MontiArc-based architecture description language for rapid prototyping of Internet of Things applications.

In MontiArc, architectures are described as component and connector systems in which autonomously acting components perform computations. Communication between components is regulated by connectors between the components’ interfaces, which are stable and build up by typed, directed ports. Components are either atomic or composed of connected subcomponents. Atomic components yield behavior descriptions in the form of embedded time-synchronous port automata, or via integration of handcrafted code. For composed components the behavior emerges from the behavior of their subcomponents.

While MontiArc generates code for simulations, MontiThings generates code to be executed on real devices.

MontiThings takes models and handwritten code from its users together with a control script. MontiThings uses these elements to generate a C++ project including various scripts, e.g., for building the project, or packaging it in Docker images.

This section describes some of the many possible ways to use MontiThings. For the purpose of this tutorial, you can choose between the following options:

1. a native installation on your machine (install instructions)

2. an installation in a virtual machine of the Microsoft Azure Cloud (install instructions)

3. using MontiThings' Docker containers to avoid an installation (install instructions)

4. using one of our supported online IDEs (you will need to sign in with your GitHub account):

This sections guides you through building and executing your first application. We will use the example under applications/basic-input-output. It consists of only three components, with the main purpose of showcasing the MontiThings build process. The Example component contains two subcomponents. The Source component produces values, the Sink component consumes these values and displays them on the terminal.

We support four ways of building an application:

1. Using the command line (instructions)
2. Using the CLion IDE (instructions)
3. Using Docker (instructions)
4. Using MontiThings' command line tool (instructions)

Here you can find answers to the most frequently asked questions building and using MontiThings.

Please cite MontiThings using its publication in the Journal of Systems and Software (Free Preprint Link).

Jörg Christian Kirchhof, Bernhard Rumpe, David Schmalzing, Andreas Wortmann, MontiThings: Model-Driven Development and Deployment of Reliable IoT Applications, In: W.K. Chan, editor, Journal of Systems and Software (JSS), Volume 183, January 2022, 111087, Elsevier, https://doi.org/10.1016/j.jss.2021.111087.

@article{KRS+22,
  key       = {KRS+22},
  title     = {{MontiThings: Model-driven Development and Deployment of Reliable IoT Applications}},
  author    = {Kirchhof, J\"{o}rg Christian and Rumpe, Bernhard and Schmalzing, David and Wortmann, Andreas},
  editor    = {Chan, Wing-Kwong},
  year      = 2022,
  month     = {January},
  journal   = {{Journal of Systems and Software}},
  publisher = {Elsevier},
  volume    = 183,
  pages     = 111087,
  doi       = {https://doi.org/10.1016/j.jss.2021.111087},
  issn      = {0164-1212},
  url       = {http://www.se-rwth.de/publications/MontiThings-Model-driven-Development-and-Deployment-of-Reliable-IoT-Applications.pdf},
  keywords  = {Internet of Things, Model-driven engineering, Architecture modeling, Code generation, Deployment}
}

© https://github.com/MontiCore/monticore

For details on the MontiCore 3-Level License model, visit https://github.com/MontiCore/monticore/blob/dev/00.org/Licenses/LICENSE-MONTICORE-3-LEVEL.md

• Project root: MontiCore @github
• MontiCore documentation
• List of languages
• MontiCore Core Grammar Library
• CD4Analysis Project
• Best Practices
• Publications about MBSE and MontiCore
• Licence definition