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.
- Using Rhapsody Developer and Animation, basically generate code with instrumentation
- Using a source code debugger provided by the compiler
- 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
Takes 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.
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.
Happy Modeling (and Debugging) with Rhapsody!
Walter van der Heiden (email@example.com)