main page

getting started








RWTH Aachen

Fachgruppe Informatik

MontiArcAutomaton: Modeling Component & Connector Robotics Applications

Jan Oliver Ringert, Bernhard Rumpe, and Andreas Wortmann

New: You can test MontiArcAutomaton with a prepared Eclipse instance.

The MontiArcAutomaton architecture and behavior modeling language and framework [RRW13a, RRW13c] provides an integrated, platform independent structure and behavior modeling language with an extensible code generation framework. MontiArcAutomaton’s central concept is encapsulation and decomposition known from component & connector architecture description languages (ADLs). This concept is extended from the modeling language to the code generation and target runtime framework to bridge the gap of platform specific and independent implementations along well designed interfaces. This facilitates the reuse of robot applications and makes their development more efficient. MontiArcAutomaton enables to use application-specific modeling languages to describe component behavior by means of language embedding. This allows to engineer very specific solutions, wrapped into stable interfaces of the containing ADL, thus enabling reuse with minimial effort. Component & connector language elements are inherited from the ADL MontiArc and the MontiArcAutomaton modeling language is implemented with the domain-specific language workbench MontiCore.

Fig.1: Software architecture of BumperBot robot.

Example: BumperBot

The Bumperbot is a minimal example of a Lego Mindstorms robot with a MontiArcAutomaton controller. The robot moves around by driving straight until it hits obstacles. Then it turns 90 degrees left, drives backwards for a short time, and starts driving straight again. While certainly not being the most sophisticated robot, the system suffices to show some of the benefits of modeling with MontiArtAutomaton. The architecture consists of a composed component BumperBot which contains 5 subcomponents (the timer is omitted). The robot receives data of type distance from the component sensor of type UltraSonic, which, due to the black box nature of components might be composed too. This data is interpreted by the atomic component controller of type BumpControl, which contains an embedded automaton to model component behavior. Atomic components either contain models to describe their behavior or are generated such that they expect a manual implementation. Depending on the distance message received, the automaton of controller switches states from idle to driving, backing up after meeting an obstacle and turning afterwards, before continuing to drive around. Guards of the automaton are modeled in the OCL of UML/P, a variant of UML focused on precise semantics and applicability to generative software engineering. The transitions of the automaton describe which messages to emit during state changes and thus either command the motors or the timer via the outgoing ports of component controller. The timer is used to define the durations for backing up and turning around. The decomposed component BumperBot is furthermore labeled with the stereotype <<deploy>> which configures the code generator to generate a run-time environment.

Other Platforms

MontiArcAutomaton has been evaluated with different platforms, among these were various simulators, Lego Mindstorms robots (with both the leJOS Java Lego Operating System and the NXT stack of the Robot Operating System(ROS)), and Festo Robotino robots (using the ROS robotino stack as well as the SmartSoft middleware). While leJOS and simulators used Java, the software for platforms using ROS were implemented in python.

Lab Courses

We have used MontiArcAutomaton in university lab courses in winter term 2012/13, winter term 2013/14, and summer term 2014. The courses had between 8 and 14 participants, with mostly master level students participating, and were organized following the Scrum software development methodology as closely as possible (e.g., due to different schedules of the participants, daily Schrum meetings were impossible).

Lab Course Winter Term 2012/13

During winter 2012/13 the students implemented a coffee delivery service with a distributed system of three Lego Mindstorms robots and leJOS. The lab was divided into three stages: preparation, robot development, and toolchain improvement. In the course's first stage, the students prepared several presentations on MDE, MontiCore, MontiArcAutomaton, Maven, ...
During the course's second stage, the students developed a distributed coffee service consisting of three robots. Therefore, we provided user stories to the students, which were elicited, refined, and discussed in the team's weekly Scrum meetings. The resulting robot control software was modeled using the structure and behavior modeling language MontiArcAutomaton. Architecture and behavior models are described in the overall system architecture description of the three robots and their communication. The video below shows the coffee service in action:

Afterwards, we conducted a survery on the students' experiences with MontiArcAutomaton and modeling robotics controllers in general. Based on this questionnaire, they improved the MontiArcAutomaton toolchain in the third stage of the course. Therefore, they developed a deployment language supporting the development of distributed architectures and improved the textual MontiArcAutomaton editor mentioned below. Some results are published in [RRW13b].

Lab Course Winter Term 2013/14

In the model driven robotics lab course of winter term 2013/14, the participating students developed a logistics application with Festo Robotino robots using the ROS robotino stack. The following video shows their final presentation, in which an order to fetch a lemonade is issued and the robot interacts via kinect with the users to handle loading/unloading and delivery.

Lab Course Summer Term 2014

During model-driven robotics development course of summer 2014, a group of 14 master level students from different computer science majors have implemented a logistics application with Festo Robotino robots using the SmartSoft middleware. Below you can see a video of their final presentation in which a robot is instructed to fetch items from a certain room. The robot drives to the room issued to, communicates the desired item via an on-board tablet to a person, waits until the person has confirmed that the robot is loaded and returns to the user who instructed the robot.

MontiArcAutomaton Publications and Supporting Materials

Further Applications

Toast Service

To demonstrate the ease of language integration and generator composition with MontiArcAutomaton, we have developed a modeling language for robot arms with 3 degrees of freedom to assist operating a toaster. Models of this language are embedded into atomic MontiArcAutomaton components and consists of programs defining the motion of the arm in terms of defined locations and gripper commands. With these it is possible to model to place bread in a toaster, operate the toaster, and deliver the toast to a nearby plate. Explicitly modeling this behavior enables to reuse in different architectures and with different arms easily. The following figure shows the architecture of the toast service system:

Fig.2: Architecture of the toast service robot.

Similar to the bumper robot example above, a controller component receives input data from the sensors and interprets it. The automaton describing the controller's behavior translates input messages into commands for the component 'ToasterController', which is responsible for starting and stoping the actual toaster, and the component 'ArmController', which controls the arm to pick up and deliver toast. The behavior of component 'ArmController' is modeled by set of robot arm programs.

The following video shows the system in action:


The SLAMbot is a Lego Mindstorms NXT robot which uses three ultrasound sensors to simultaneously localize and map an unknown environment as good as the Lego hardware allows. Architecture and behavior of the robot were developed with our toolchair for presentation at the students day of SE2013.

Fig.3: Architecture of the SLAMbot robot.

The architecture of the SLAMbot connects three ultrasound sensors to a central controller which is modeled as an automaton. The results are send to a DifferentialPilot component, allows to control a vehicle with two wheels.

Fig.4(a): Architecture of the SLAMbot Fig.4(b): Behavior of the SLAMbot

Figure 5 shows the software architecture and the controlling automaton. The robot collects data from three ultra sonic sensors and passes the resulting messages to the controller which computes the behavior with the automaton. Resulting messages are passed to a DifferentialPilot component which controls the motors of the robot.

Development Toolchain

MontiArcAutomaton Editor

We also developed a graphical editor for MontiArcAutomaton models which allows parallel textual and graphical modeling of robot controllers. This editor comes as an Eclipse plugin and was build using the both the Eclipse Modeling Framework and the Graphical Editing Framework. Besides textual and graphical presentation, the editor provides various means to ease modeling with MontiArcAutomaton, for example views about the embedding component and debugging of automata using traces recorded at runtime. The editor comes with a generators for Java and Python and is easily extensible with other generators. The following video shows the editor in action: