Enterprise Architect version 13


English Chinese (Simplified) Czech Dutch French German Italian Korean Polish Portuguese Russian Slovak Spanish Swedish

My Profile

Social Media Channels

facebook google plus twitter youtube linkedin

Peter Lieber

Peter Lieber

I am an extrovert promoter and results-oriented controller and director. It like creating new partnerships and relations. I like people that are talking with me and it is important for me to help and motivate others. I'm very self-motivated and I prefer doing thinks I really like. I need a lot of creative and open space. But I also need people doing the administrative tasks and people realizing the ideas.

My highest motivation is doing creative work with and around Enterprise Architect. (www.sparxsystems.de)

LieberLieber Software: From Data Streams to Models

After completing its first project with a Christian Doppler Laboratory (CDL) at the end of 2016, LieberLieber is now continuing this commitment. Together they seek ways to transform live data streams directly into models within the framework of industry 4.0.

The team of CDL-MINT: Polina Patsuk-Bösch, Serap Kadam, Petr Novak, Manuel Wimmer, Alexandra Mazak, Radek Šindelár (f.l.t.r.)

After gaining valuable experience in the handling of machine languages found in widespread use in industry applications during an initial cooperation, LieberLieber is making new strides with the new "CDL for Model-Integrated Intelligent Production" (CDL-MINT). "In industry 4.0 scenarios, huge amounts of data are constantly being collected and then subsequently evaluated and implemented for the further optimization of production processes. As an industrial partner, LieberLieber has a great deal of experience in dealing with such data streams and so we are now jointly taking the step of generating models from this continuously-occurring data," explains Prof. Manuel Wimmer from the Business Informatics Group at the Institute for Software Engineering and Interactive Systems at TU Wien, who also manages the new CD lab. Peter Lieber, founder and owner of LieberLieber: "In our customer projects, such as at Vattenfall, RWE, Bosch, BMW and VW, we see on a daily basis how projects in software and systems development are becoming increasingly complex and data-intensive. This is also a major challenge for powerful modeling platforms such as Enterprise Architect, which we now want to solve together. Model-based development is therefore increasingly at the center of industry 4.0 solutions since it helps to handle the complexity and manage the flow of data in an ordered fashion."

CDL-MINT was established with the support of the Federal Ministry for Science, Research and Business (BMWFW) as well as the two industrial partners CertiCon and LieberLieber, and opened on May 22nd, 2017.

Data, languages and storage

As in the first CDL project, the handling of special machine languages - this time in connection with the operational data - is an important part of the development work. "Since this project is the first time that a reactive model has been generated from the live data streams, the models must understand the languages in which these data are transmitted. If we can do this, then the deployment possibilities of Sparx Systems Enterprise Architect would expand considerably," Wimmer explains. In this case, the models could be used to monitor the systems, to understand complex system behavior or to validate model assumptions through empirical data.

Industry 4.0 scenarios are based on the comprehensive exchange of information between all suppliers, customers and manufacturers involved in the production process. Model-based system development solves the challenge of the resulting data streams by using a central model memory. However, the relational database used by Sparx Systems Enterprise Architect encounters its limits with increasing amounts of data. "For a while now, we have been dealing with the issue of how to achieve more efficient storage and retrieval of large volumes of model data. In this collaboration we wish to further extend our know-how and also develop other database concepts, such as NoSQL and graphical or card-based databases," says Lieber. The question of optimized loading and buffering mechanisms for very large models is also addressed.

LieberLieber believes that Sparx Systems has made the next step of becoming the scalable modelling plattform through its engagement in Pro Cloud technology and LieberLieber is keen to colloborate with Sparx Systems on this topic.

Advancements built on solid experience

LieberLieber has already gained extensive experience in the industry 4.0 environment through its "Embedded Engineer" tool. The resulting technologies are a great starting point for the desired model-based monitoring and data collection. "The collaboration with CDL-MINT is based on our experience and will test concepts, technologies and platforms in order to enhance our know-how in industry 4.0 projects. We are deliberately pursuing high goals in order to show everyone that model-based software and systems development is an excellent approach for the rapid implementation of industrial 4.0 projects," concludes Lieber.


Peter Lieber at the CDL-MINT opening speech (May 22nd, 2017)



TU Wien press release: https://www.tuwien.ac.at/aktuelles/news_detail/article/124989/

About Christian Doppler Laboratories
Christian Doppler Laboratories carry out high-level application-oriented basic research, and is an environment wherein outstanding scientists cooperate with innovative companies. Its excellence in promoting such cooperation has placed the Christian Doppler Research Association in high international regard as a best-practice example. Christian Doppler laboratories are financed jointly by the public authorities and the participating companies. The most important public funding agency is the Federal Ministry of Science, Research and Business (BMWFW).



About LieberLieber Software

LieberLieber Software  is headquartered in Vienna, Austria, with offices in Germany, Slovakia and the USA. LieberLieber operates within a variety of industries in the field of model-based software engineering, offering specialized products and services to users of Sparx Systems Enterprise Architect and other well-known UML/SysML software modeling tools.

LieberLieber represents a single source of competence for model-based software development and systems engineering, with years of experience in consulting, scope analysis, creation of individualized solutions, tool chain integration, specialized training and high-level support.

LieberLieber is also well-known for its innovation and advances in the software engineering domain. LieberLieber Embedded Engineer for Enterprise Architect combines automated source-code generation with debugging on the model level and is a veritable revolution in software development. LieberLieber LemonTree is a fresh new model diff & merge tool that boosts productivity in the working environments of distributed development teams while supporting adherence to industry and regulatory standards.

LieberLieber cooperates closely with renowned research institutions and universities to research and create model-based software solutions of the future.


Get more information at www.lieberlieber.com


"VBScript and JScript require the Microsoft Process Debug Manager (PDM.dll) to be installed on the local machine; this is available through various Microsoft products including the free 'Microsoft Script Debugger'"

(refer to: http://sparxsystems.com/enterprise_architect_user_guide/13.0/automation/debug_scripts.html)


The issue is: Microsoft Script Debugger as is - is depricated and here is the list (not complete for sure), where PDM is part of:

* Office 2000-2007

* Visual Studio

* Visual Studio Remote Tools (PDM stays installed even after uninstall of the Remote Tools)


Depending on the used operating system of Microsoft you will find Process Debug Manager (PDM.DLL) in the following folders:


Windows Vista, Windows 7, Windows 8, Windows 8.1 (64bit)

C:\Program Files (x86)\Internet Explorer\pdm.dll

Windows Vista, Windows 7, Windows 8, Windows 8.1 (32bit)

C:\Program Files\Internet Explorer\pdm.dll


Windows 10 _before_ v1607

Windows 10 (64bit)


Windows 10 (32bit)



This file (pdm.dll) must be registerd manually using regsvr32.


Windows 10 v1607:

in this version manual installation of pdm.dll is not possible anymore. So you have to install a Microsoft Product that contains PDM.dll.


I recommend using the "Remote Tools for Visual Studio 2015 Update 3"

32bit: https://go.microsoft.com/fwlink/?LinkId=615469&clcid=0x407

64bit: https://go.microsoft.com/fwlink/?LinkId=615470&clcid=0x407


After installation you can uninstall them - because PDM.DLL resists and can be used by Enterprise Architect.



SparxSystems CE: Award for Smart Grid Technology

Salzburg University of Applied Sciences recently received a Best Paper Award for its SGAM Toolbox for model-based engineering and evaluation of “smart grid” architectures. The Toolbox is an innovative extension developed for Enterprise Architect, the popular modeling platform produced by Sparx Systems.

Vienna, Oct. 11, 2016 - An essential part of the coming energy revolution is the realization of an intelligent power network, the so-called “Smart Grid”. Back in 2014 the Salzburg University of Applied Sciences introduced its SGAM Toolbox, an add-in for Sparx Systems Enterprise Architect that enables model-based development and evaluation of Smart Grid architectures. June of this year saw the presentation of the now further-developed Toolbox at the 11th International IEEE Conference “System of Systems Engineering” in Kongsberg, Norway, where the scientific whitepaper entitled “A Standards-based Approach for Domain Specific Modeling of Smart Grid System Architectures” received the Best Paper Award.

Carried out by a team at the Josef Ressel Center for User-Centric Smart Grid Privacy, Security and Control at Salzburg University of Applied Sciences and the “OFFIS Institute for Information Technology” in Oldenburg, Germany, substantiates – for the first time – the compatibility of European and American concepts for the realization of Smart Grid. According to Hans Bartmann, CEO of SparxSystems Software Central Europe: “We heartily congratulate the team for their well-deserved recognition, and for clearly showing that American and European Smart Grid models are indeed compatible. We are glad that Enterprise Architect has played an important role in this analysis and, consequently, was instrumental in advancing the conversion of our power grids into sustainable energy sources. Incidentally, the SGAM Toolbox remains available for download at no cost!”

Compatibility of Smart Grid architectures identified

The research group “Secure Architectures and Modeling” at the Josef Ressel Center concerns itself with the development of secure Smart Grid systems architectures. In 2014 they cooperated with the “OFFIS Institute for Information Technology” to create their own domain-specific modeling language as an add-in for Enterprise Architect including the European “Smart Grid Architecture Model” (SGAM). Based on the resulting SGAM Toolbox, in the current version a model of the American “NIST Logical Model“ reference architecture was created with which the compatibility of European and American concepts could be proven. Christian Neureiter, a project contributor at the Josef Ressel Center, comments: “This award by the systems engineering community is not mere recognition of the work of the Josef Ressel Center, but rather a confirmation of the applicability and the practical benefits of its results. This is also another example of how Enterprise Architect has established itself as a widely-accessible tool offering a wide range of modeling, documentation and extension options. Naturally, this award has motivated us to continue our research in this direction!”



Image 1: Director Dominik Engel (right), Christian Neureiter (middle), Goran Lastro (left) and Mathias Uslar (not in picture) of OFFIS in Oldenburg are pleased to receive the Best Paper Award (credit: Salzburg University of Applied Sciences)


Smart Grid Architecture

Fig. 1: Smart Grid Architecture Model (SGAM; credit: CEN/CENELEC/ETSI)

About the Josef Ressel Center for User-Centric Smart Grid Privacy, Security and Control at the Salzburg University of Applied Science

Intelligent power networks, or Smart Grids, are the electrical power grids of the future. However, they can only become a reality if they can find acceptance among users. This is where visible and trustworthy measures are required to ensure users’ data privacy, data security and control. The research conducted at the Josef Ressel Center focuses on relevant technical solutions: Mechanisms, processes, algorithms...computer programs in the broadest sense. Legal and social aspects are observed wherever necessary, with evaluation being carried out under the supervision of social scientists.

About the Salzburg University of Applied Sciences

The Salzburg University of Applied Sciences (“Fachhochschule Salzburg GmbH“) employs around 320 persons at its campus locations in Urstein and Kuchl in Austria. Around 2,700 students attend 17 Bachelors’ and 10 Masters’ Degree courses in the fields of engineering, social and business sciences, design, media & art, and health sciences. Learn more at http://www.fh-salzburg.ac.at/en/

About Sparx Systems

Sparx Systems, founded in Australia in 1996, is the producer of Enterprise Architect – one of the most successful UML modeling platforms in the world. Enterprise Architect enables the conceptualization and creation of software systems, business process models and models of any process or system. Enterprise Architect is valued by over 380,000 users for its high level of performance at an unbeatable price. Enterprise Architect is an intuitive modeling environment geared towards teamwork, supporting organizations in analyzing, designing and creating comprehensibly traceable, well-documented systems. It enables organizations to concentrate and present the work of teams and departments, regardless of size or geographic distribution.

In order to offer the growing number of Enterprise Architect customers the best level of service in their own language and timezone, in 2004 SparxSystems Software Central Europe was established to serve the German-speaking world and adjacent markets with Sparx EA licenses, training and consulting.


Please find more information at http://www.sparxsystems.eu/

Tuesday, 16 August 2016 21:34

Automated FMU Generation from UML Models

Automated FMU Generation from UML Models

Original created by: Manuel Geier and Bernhard Sadransky


The simulation of cyber-physical systems plays an increasingly important role in the development process of such systems. It enables the engineers to get a better understanding of the system in the early phases of the development. These complex systems are composed of different subsystems, each subsystem model is designed with its own specialized tool sets. Because of this heterogeneity the coordination and integration of these subsystem models becomes a challenge.

The Functional Mockup Interface (FMI) specification was developed by an industry consortium as a tool independent interface standard for integration and simulation of dynamic systems models. The models that conform to this standard are called Functional Mockup Units (FMU).

In this work we provide a method for automated FMU generation from UML models, making it possible to use model driven engineering techniques in the design and simulation of complex cyber-physical systems.

Functional Mockup Interface

The Functional Mockup Interface (FMI) specification is a standardized interface to be used in computer simulations for the creation of complex cyber-physical systems. The idea behind it being that if a real product is composed of many interconnected parts, it should be possible to create a virtual product which is itself assembled by combining a set of models. For example a car can be seen as a combination of many different subsystems, like engine, gearbox or thermal system. These subsystems can be modeled as Functional Mockup Units (FMU) which conform to the FMI standard.

The Functional Mockup Unit (FMU) represents a (runnable) model of a (sub)system and can be seen as the implementation of an Functional Mockup Interface (FMI). It is distributed as one ZIP file archive, with a ".fmu" file extension, containing:
  • FMI model description file in XML format. It contains static information about the FMU instance. Most importantly the FMU variables and their attributes such as name, unit, default initial value etc. are stored in this file. A simulation tool importing the FMU will parse the model description file and initialize its environment accordingly.
  • FMI application programming interface provided as a set of standardized C functions. C is used because of its portability and because it can be utilized in all embedded control systems. The C API can be provided either in source code and/or in binary form for one or several target machines, for example Windows dynamic link libraries (".dll") or Linux shared libraries (".so").
  • Additional FMU data (tables, maps) in FMU specific file formats

The inclusion of the FMI model description file and the FMI API is mandatory according to the FMI standard.


Enterprise Architect is a visual modeling and design tool supporting various industry standards including UML. It is extensible via plugins written in C# or Visual Basic. The UML models from which we generate our FMU are defined with Enterprise Architect.

Embedded Engineer is a plugin for Enterprise Architect that features automated C/C++ code generation from UML models.

We further used the FMU SDK from QTronic for creating the FMI API. It also comes with a simple solver which we used to test our solution.

Running Example

Our basic example to test our solution is called Inc. It is a simple FMU with an internal counter which is initialized at the beginning and it increments this counter by a specified step value, each time it gets triggered, until a final to value is reached or exceeded.

State Machine

The state machine contains just an initial pseudo state which initializes the state machine and a state called Step. The Step state has two transitions, one transition to itself, in case the counter is still lower then the to value, if this is the case, the inc() operation will be called and we are again in the Step state. If the value is equal or greater to the to value, it reaches the final state and no further process will be done.

Class diagram

The class diagram consists of two parts. The left part with the Inc class is project specific. It holds three attributes: counterstep and to. All attributes are of type int. The initial value for the counter is 0, for the step it's 5 and for the to value it's 50. The FSM classes on the right are the mandatory classes for the Embedded Engineer to be able to generate the state machine code.
Some specific implementation code also exists in various places. In the state machine you can see, that we have some guards on the transitions. These guards are actually code that will be used to generate the code for the state machine:

me->counter < me->to


me->counter >= me->to

The property me represents a pointer to an instance of the Inc class.

And finally the implementation of the inc() operation is also provided:

me->counter = me->counter + me->step;


Manual Code Generation

First we manually created our reference Inc FMU, the following steps where taken:
  1. UML models were defined in Enterprise Architect (class diagram and state machine diagram)
  2. C code was generated from the previously created models (with the Embedded Engineer plugin)
  3. The FMI model description xml file and the FMI API were created by hand
  4. The (compiled) FMI API was packaged together with the model description file into a FMU file. This was done with a batch script.

Automatic Code Generation

Now we want to automate the creation of the FMI model description file and the FMI API. For this purpose we wrote our own Enterprise Architect plugin. To be able to generate semantically correct FMI model description and FMI API artifacts, we attached additional information to the UML models. This was achived through the definition of various UML stereotypes for UML class attributes and methods. Since the FMI defines its own data types we also had to map the data types used in the UML models to the corresponding FMI data types. With these challenges addressed we were able to implement our FMU generation plugin.


Future Work

Our work comprises a fundamental prototype that is only a start and could be improved in various ways. The following list describes some issues that could be tackled.
  • One limitation of the current implementation is that we are not able to provide initial values for the FMU. Consequently, to test different configurations of our FMU, we always have to set the default values in the UML models and regenerate the FMU for the simulator again. Hence, future work includes creating new stereo types for initialization of FMU settings/variables and testing these bindings.
  • We used the FMU SDK simulator for this project. Other (more powerful) simulators should be tested too. Furthermore, co-simulation with other FMUs needs to be tested.
  • In our project we restricted ourselves to just look at discrete functions by using the event system of the FMU. To continue the journey we also have to consider continuous functions.
  • More complex examples should be considered to test the capabilities of the automatically generated code. By creating more complex examples the practical limitations of modeling a FMU with a class diagram and a finite state machine need to be discovered. Questions like "What can be implemented?" and "What can not be implemented?" need to be answered.
  • The automated code generation process could be reduced to a one-click functionality to directly generate the ".fmu" file without any additional compilation and packaging step necessary.


This work has been supported by LieberLieber in the context of the CDL-Flex project: http://www.sysml4industry.org/.


Screencast FMU with UML

Wednesday, 11 May 2016 10:11

MARTE profile for Enterprise Architect

MARTE profile for Enterprise Architect

The UML Profile for MARTE: Modeling and Analysis of Real-Time and Embedded Systems


MARTE profile adds capabilities to UML for model-driven development of Real Time and Embedded Systems (RTES). This extension provides support for specification, design, and verification/validation stages.

MARTE consists in defining foundations for model-based description of real time and embedded systems. These core concepts are then refined for both modeling and analyzing concerns. Modeling parts provides support required from specification to detailed design of real-time and embedded characteristics of systems. MARTE concerns also model-based analysis. In this sense, the intent is not to define new techniques for analyzing real-time and embedded systems, but to support them. Hence, it provides facilities to annotate models with information required to perform specific analysis. Especially, MARTE focuses on performance and schedulability analysis. But, it defines also a general framework for quantitative analysis which intends to refine/specialize any other kind of analysis.


Enterprise Architect Support for MARTE

The MARTE profile consists of separated UML profiles and Model Libraries referred as Extension Units and are listed in Table 1


Table 1: Extension Units Defined

Table 2 shows the Compliance Cases (Software Modeling, Hardware Modeling, System Architecting, Performance Analysis, Schedulability Analysis, Infrastructure Provider, Methodologist) as defined by the MARTE standard. Addtional information about the MARTE profile, Extension Units and Compliance Cases can be found at http://www.omgmarte.org/ and the official OMG MARTE specification can be downloaded at http://www.omg.org/spec/MARTE/1.1/


Table 1: Extension Units that must be supported in each Compliance Case

We currently support a subset of MARTE Extension Units (GRM, NFP, Time, Alloc, HLAM, GQAM, PAM) and, then, a subset of Compliance Cases (Software Modeling/Base, System Architecting/Base, Performance Analysis/Base).

We are actively working to implement all the Extension Units and support all the Compliance Cases in the next months.

Moreover, we intend to extend the MARTE profile for the sake of dependability analysis with an additional Extension Unit, Dependability Analysis Modeling (DAM). Additional information about DAM are available at www.sce.carleton.ca/faculty/petriu/papers/SOSYM09-prepub.pdf

Model-analysis approaches adopting MARTE and DAM can be found at http://ceur-ws.org/Vol-553/paper3.pdf


EA Screenshots


Figure 1: Operational Profile modeling with DAM (Use Case Diagram).


Figure 2: Software Resource and Service modeling with MARTE GRM (Component Diagram).


Figure 3: Hardware/Platform Resource modeling with MARTE GRM (Deployment Diagram)


Figure 4: Software Behavior Modeling with resource demands (Activity Diagram).

Wednesday, 07 October 2015 18:15

Pong with Enterprise Architect

For some time now we wanted to do funny stuff again. And what’s easier for the proof-of-concept for EA as a gaming engine than the 30 years old classic ‘Pong’?

All it takes is some Wrapper for the EA-Diagram-Coordinates and a basic engine for collision detection. Both was done in C# rapidly.

Astonishing is EA’s performance, because every 50ms the positions are changed and EA.Diagram.Save is called.

Here is the linkt to the Video...

Here you can find the original blog entry...




Monday, 30 March 2015 09:10

Developing and debugging in UML models

Especially when concerning more deeply embedded systems with complex multicore SoCs, it is often not easy to prove functional safety. In this case, using a model-based development platform such as Enterprise Architect along with a code generator optimized for embedded applications and a model-based testing tool with hardware-level debugger, this problem is relatively easy to solve. This combination allows developers to design, test and debug their software on the same level of abstraction - also on the real target.

Model-based development is finding more and more followers, and the field of industrial and automotive embedded systems is no exception. This is hardly surprising, since especially in these challenging areas of technology it is in fact more important than ever to use mechanisms that help to ensure that the product complies with all requirements and safety criteria. A growing use of multicore architectures increases this pressure even further, since the complex interactions in the parallel execution of software also significantly complicate the detection of functional safety.

Basically, working with models to develop embedded applications has many advantages, such as:


  • continuity from requirements management to final C / C ++ - code

  • object- and component-oriented development without having to switch to C ++

  • less effort when switching to C ++ later on


In the case of already-running embedded projects, practical experience shows that the best course of action is to begin to develop parts of the functionality using the model-based approach. In this way, the fairly new model-based approach can be brought - step by step - into the company without having to discard existing code while overwhelming developers.

In general, it is important to always keep in mind the specific requirements of the embedded environment. These include, for example:


  • the limited performance of the hardware; the code must efficiently conserve resources

  • a software bug detected too late is an often costly affair (e.g. expensive auto recalls)

  • that the code must satisfy very specific standards (MISRA), and

  • it should integrate well with existing code.


Modeling with very specific requirements


The use of a model-based development platform such as Enterprise Architect from Sparx Systems demonstrably improves not only the development process of software and systems, but also communication between the people involved. The graphically-oriented representation in UML enables instant documentation of the software architecture and development process, and makes it easier for non-UML professionals to understand.

UML / SysML are very broadly-applicable languages, but were not specifically designed for creating embedded systems. In order to adapt the Enterprise Architect modeling platform (Figure 1) - now with over 350,000 licenses in operation worldwide - to the specific requirements of embedded engineering, LieberLieber software therefore combines two key functions in the "LieberLieber Embedded Engineer" product package: code generation (uml2code) and debugging UML (UML debugger). As part of the entire tool chain, this solution - aimed primarily at embedded software developers and software architects, but which can also be useful for testers and integration managers - enables code generation from UML structures, state machines and activity models and generates platform-independent C ++ - and MISRA-compliant C code from UML models.


Learning to use models


A characteristic valued by most customers is the potential coexistence of handwritten and generated code. However, it should be ensured that generated code is only altered by changes in the model or the generator. This ensures that model and code are identical at all times. Basically, the automatic code generation especially makes sense if the code generator is not a black box, but a living part of the project. The variety of template-based solutions for code generation can have a negative influence on acceptance by developers and thus also the will to adapt.

In practice, code generators are therefore much more successful when they themselves are programs and can thus adapt to the familiar tools. However, should the complexity of the templates become too great, maintainability and finding fault are far more difficult than, for example, in a code generator that was developed in C # and can debug normally with Visual Studio. A particularly great benefit from code generation can be achieved when parts of a project are generated from a model based on the state machines or activities as agreed upon among the respective departments.


Code generation produces high value


Thus, as has already been mentioned, model-based development has a particularly high value when implemented for automatic code generation and subsequent debugging. By eliminating complex configuration parameters and any frameworks, entry into model-based code generation is greatly facilitated by uml2code. Decisions at the model level can be transparently traced in the generated code – which is easy to read and well structured. Project-specific requirements for code generation are implemented directly in the supplied source code. As a result, the requirements are easy to understand. In addition, the generated code can be integrated without any problems into existing software projects, the advantages of the model-based and the traditional development can thus be combined virtually as desired. Moreover, since the code generator source code is included, there is no dependence on the solution suppliers.

In order to shift software development completely to Enterprise Architect, the following rules – necessary for embedded engineering – are also included in “LieberLieber Embedded Engineer for Enterprise Architect”:


  • Instead of dynamic memory management, which is a violation against the MISRA C rules, objects are created statically.

  • State Machines are instead implemented by a whole set of functions via short and effective case distinctions.


Debugging functionality includes the development cycle


The LieberLieber UML Debugger also offers users a graphical UML debugger, integrated into Enterprise Architect, that allows the testing and debugging of the software, modelled in UML or SysML, directly on the model level. The debugging of the model can be started directly with the code generated from the model and compiled with any compiler. The code generator and the debugger form a closed circuit and allow debugging at the implementation level - namely the UML model. Thus, a possible error even right at the source - the model - can be located and corrected.


Testing on the real target


Coupling with the Universal Debugging Engine (UDE) by PLS, a tool specialized in optimized target access and detailed architecture support, allows the execution and debugging of the models directly on the actual target hardware. This is possible thanks to the UDE object model, which is based on COM technology from Microsoft. COM allows programmatic use by a variety of programming languages, including the world of .NET such as C#. COM refers to the totality of all documented objects, methods, properties, and data types as an object model. This means that almost all functional aspects of the Universal Debug Engine are covered. The LieberLieber UML debugger uses the object model of the UDE for, among other things, a connection to the microcontroller and the programming of the application into the FLASH memory of the target. It is also able to set breakpoints. This is done directly in the model, for example, on a particular state of a state machine. Due to the integrated code generation, it is known what line in the generated C / C ++ code this corresponds to. This can be handed over to the debugger for the setting of breakpoints. Furthermore, the program execution can be started and stopped via the object model. It is even possible to read out the variable values and display them in the UML debugger (Figure 2).




The coupling of a modeling tool with a code generator optimized for embedded systems and a model-based testing tool with hardware-level debugger gives the designer the advantage to not only design software at the model level, but also test and debug it on the real target. This seamless integration between tools increases the acceptance of such development methods, reduces the occurrence of errors and represents a large gain in efficiency. This innovative approach is suitable for new as well as existing projects.