|
|
|
MontiArcAutomaton: Modeling Component & Connector Robotics ApplicationsJan Oliver Ringert, Bernhard Rumpe, and Andreas WortmannNew: 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
Other PlatformsMontiArcAutomaton 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 CoursesWe 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
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/14In 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 2014During 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 ApplicationsToast ServiceTo 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: SLAMbotThe 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.
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 ToolchainMontiArcAutomaton Editor
|
|||||
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
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, ...
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