EUROScope is a source-level debugger for embedded systems. Apart from the "usual" features, such as memory view, register view, assembler view, source view, local/global variable view, breakpoints and call-stack, EUROScope offers an integrated terminal window as well as support for programming flash chips within the target system.
EUROScope offers syntax highlighting for C/C++ source code; keywords can be added by the user.
Optimized target connections
The connection to the target system strongly influences developer efficiency. EUROScope and its communication partner EUROSmon use intelligent algorithms. For example, they optimize software downloads to the target system; thus, even with slow serial target links, data is often transferred faster than with comparable products. EUROScope supports serial interfaces, TCP/IP sockets and CAN (IXXAT VCI). BDM or JTAG are supported by add-on DLLs.
Common user interface for all architectures
If you are developing for multiple target architectures, with EUROScope there's no problem! You won't need to learn a new debugger when you switch CPUs. Whether you use ARM, Infineon C16x, Fujitsu F16LX, Fujitsu FR, Intel x86, Mitsubishi M16C, NEC V850, Altera Nios II or PowerPC, all are supported by EUROScope!
"State of the Art" GUI
The sophisticated user interface helps you to keep track of every important piece of information: windows can be "docked" to the edge of the main window without obscuring important data. Multithreading makes the user interface highly responsive and a joy to work with.
EUROScope is the ideal debugging partner when developing EUROS applications: it knows when the EUROS real-time operating system is running on the target system and offers the following enhanced features:
- EUROS object view
You want to know which tasks are waiting for a message to a certain mailbox? You want to see if a driver is currently receiving data or where the stack of a task is located in memory? The EUROS object view delivers detailed information!
- Event visualisation
As an option, EUROScope can process information provided by an instrumented version of EUROS: You gain detailed insights into the runtime behavior of your application and can thus detect and correct performance problems early on! Or add trace points to your software to record important data. The trace buffer in the target system helps you to re-trace the behavior of your application, including its interrupt handlers, during post-mortem analysis!
- Command Line Interpreter
The command line window is a command interface that's driven by text input that is integrated in the EUROScope debugger. It accepts any expression of the C standard. Expressions may even contain identifiers of the current context. For example, if the executed application is interrupted by a breakpoint, all global and local variables that are known at this location are accessible to the command line interpreter. Furthermore, the user is able to process conversions between any types defined in the application. This is true no matter how complex the type definitions are. This enables the performance of difficult tasks when debugging applications.
It is possible to load script files that contain directives to be interpreted. Since the command line interpreter provides commands for controlling EUROScope, automated test suites can be composed. Once started they can load and start a variety of test applications and evaluate the results without user interaction.
EUROScope provides – besides the standard functions of a debugger – also large variety of special extensions, which simplify debugging considerably – even without the usage of an emulator. For example: Events can be traced and displayed graphically during the program execution, status information of the system objects can be shown, the content of the so-called ’Special Function Registers’ can be visualised and modified, static and dynamical code analysis can be performed, control flow graphs can be displayed, the stack-consumption can be calculated, and much more.