Don’t let the bedbugs bite…..

Introduction

Using UML and Rhapsody to develop software is a very good way to cope with increasing complexity. The ultimate usage of Rhapsody is using the code generator to generate production code.

Although using UML makes it much easier to maintain an overview over the software, it is still no guarantee for error-free software.

So even in Model Driven Development there is point where there is need for a debugger.

Rhapsody offers a few ways to debug the generated software.

  1. Using Rhapsody Developer and Animation, basically generate code with instrumentation
  2. Using a source code debugger provided by the compiler
  3. Using the Willert Embedded UML Target Debugger

The first solution is directly connected to the use of the Rhapsody Developer, a license that is not generally available. It is also available in the Rhapsody Architect for System Engineers (Designer) which is often used by System Designers. In fact, the Designer can ONLY generate instrumented code.

This is a very comfortable way to debug UML Models, Animation can show „Live“ State-charts, trace Sequence Diagrams and much more. There is, however, a price to be paid for this comfort.

Animation uses a TCP/IP connection and does a lot of communication, also the Code Instrumentation uses an incredible amount of RAM and ROM. This makes it unsuitable for small targets.

Off course it is possible to create models that will be runnable on both PC and embedded target, this is not always easy and allows you to only debug the logic of your software.

When doing Systems Engineering this is mostly exactly what is needed and Animation is very suitable for that.

Using a source code debugger is possible but it requires deep knowledge of the generated source code and the used Framework. Also, the use of object orientation is making debugging in a classic way more difficult. (When using multiple objects, a breakpoint tells you where you are in the code but now in which object.)

A great way to debug is using the WST Embedded UML Target Debugger., short: TD.

What is the TD

The TD, the Willert Software Tools Embedded UML Target Debugger is a tool for debugging UML Models on a model level. It consists of 2 parts:

– The Monitor

The WST RXF has a small monitor built-in that will transport information about what is happening inside the framework to your PC.

– The Target Debugger GUI

TDWorkingTakes the information from the monitor and presents that in the form of UML Diagrams using symbolic information from an XML file that is generated during code generation.

In the process of creating the new version of the framework we also redesigned the TD from the bottom up. The Code is made with Rhapsody (Quote George Clooney: what else…) and the Qt Framework from Willert.

What can the TD do?

It can draw 2 types of UML diagrams: Timing Diagrams and Sequence Diagrams. These diagrams are drawn from the information that the target provides. They provide you with enough information to see what your system is doing.

  • Breakpoints
    Intelligent breakpoints can be used to allow stopping when you need it. The diagrams will then provide you with the correct information.
  • Filters (Host/Target)
    You can filter what information you want to see, dynamically on the host (The diagrams will be re-drawn with the requested information) but also on the target (Only the requested information will be sent, saving valuable resources)
  • Event injection
    Use the TD for your own testing by sending events to your target. You can also predefine sequences of events to be sent to easy do test sequences.
  • Test Conductor integration
    Use the Test Conductor together with the TD to automatically run tests e.g. for nightly testing.
  • Multiple targets
    It is possible to use multiple targets to debug larger systems consisting of multiple components. Synchronize the time between the targets with one button.

The Target debugger is included in the RXF, it must be adapted to your environment and your communication interface. But it can save you loads of time debugging and testing.

 

2 thoughts on “Don’t let the bedbugs bite…..

  1. Walter, the UML Target Debugger seems to be, what I am missing in Rhapsody for a long time. Can I use it with my Rhapsody Developer and how can I get a trial?
    On willert.de I can find some information, but no downloads or trials of your software.

    Maybe it’s helpful for others too, if you provide links directly in the articles

    Like

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s