Development tools

Especially for the cross development we offer tools that allows you to build applications comfortably and efficiently: EUROScope - High level language debugger EUROSanalyze - Component for analyzing application code EUROSkit - Cross development environment EUROSflash - Flash tools The development tools can be used as stand-alone systems but will involve their full capability in association with EUROS or EUROSmot.

EUROScope

EUROScope is a source-level debugger for embedded systems. Apart from the "usual" features like 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, and additional keywords can be added by the user.

Optimized target connections

The connection to the target system strongly influences turnaround times. EUROScope and its communication partner EUROSmon use intelligent algorithms, e.g. to optimize software downloads to the target system: 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

You’re developing for multiple target architectures? With EUROScope you don’t have to learn a new debugger when you switch CPUs! Whether you use Infineon C16x, Fujitsu F16LX, Fujitsu FR, ARM, 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 and don’t obscure important data. Multithreading makes the user interface highly responsive and a joy to work with.

EUROS support

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 a instrumented version of EUROS: You gain detailed insights into the runtime behaviour 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 behaviour of your application, including its interrupt handlers, during post-mortem analysis!
• Command Line Interpreter
  The command line window is a text input driven command interface 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, known at this location, are accessible by the command line interpreter. Furthermore the user is able to process conversions between any type defined in the application, independent from how complex the type definitions are. This allows to perform difficult tasks when debugging applications.
  It is possible to load script files which 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 different test applications and evaluate their result without the necessity of user interaction.

Download EUROScope brochure

EUROSanalyze

EUROSanalyze, an additional component for the high level language debugger EUROScope, allows to retrieve important information of an application before debugging has been started. A static analysis of the code is performed by means of the application's executable. The gathered informations can be visualized in different ways:

• Calling-Tree
  The list of functions called by any function can be determined.
• Cross reference
  The list of functions calling any specific function directly or indirectly.
• Control flow
  Within a function their execution paths can be determined. The code sequences found this way can be visualized by means of a flow graph. This makes it easy to detect loops and branches and allows to easily identify the code paths to be tested.
• Stack usage
  EUROSanalyze can determine the stack size allocated or freed by every instruction. This allows determination of the stack totally used by a function. In combination with the call tree, EUROSanalyze can calculate the maximum stack usage off all sub-routines called by this function.

For all analysises only the object code of the application is required as the informations are gathered by analyzing the CPU instructions.

Download EUROSanalyze brochure

EUROSkit

A number of different develpment environments are available for embedded applications. These either come as specialized solutions that are only compatible with certain development tools, or they’re designed as stand-alone development environments.
The former kind of development environments are often quite uncomfortable because they offer only limited functionality and are adapted specifically for one CPU architecture.
Stand-alone development environments offer a larger set of functions, but are not well suited to use different development tools. For example, error messages from the compiler must first be loaded with an editor to find the error location manually.
With EUROSkit a comprehensive stand-alone cross-development environment is now available, based on a powerful editor with project manager, integrating all development tools. There is special support for developing EUROS application with EUROSkit.


These are the EUROSkit advanced features:

• Integrated C parser
  C code is analyzed in real-time and is represented in a structured form by the class view. When typing in a variable available member variables are provided in a listbox.
• Extended Error Parser
  Messages originating from the build process are displayed in a special window. Independent from the development tools the user can select a message and is directed to the corresponding location in the source file.
  
• Makebar
  When building an EUROS application a flexible build process based on GNU make is running in the background. Using the so-called "Makebar" the four makefile parameters "target hardware", "toolset", "application variant" and "library variant" are selected. EUROSkit automatically detects the options available on the development system and offers these in the four Makebar lists.
• Auto Prototype Info
  When typing the name of a EUROS API function or of any other function of the project, a tool-tip window containing the prototype of the function is displayed.
• Auto- and Code-Completion
  EUROSkit knows all identifiers in the project. When typing code a phrase can be completed automatically based on these identifiers.
• Flexible Syntax Highlighting
  C source files and header files are highlighted. The user can add custom syntax descriptions.
• Project Wizard
  New EUROS projects can be created using the Project Wizard. With a few parameters given by the programmer it generates a template project that can be immediately used as an application.
• Integrated online help
  The structured help system contains descriptions of all EUROS services.
• Workspaces
  EUROSkit can manage multiple projects as a single workspace. This feature can be used to better organize project structures.
• Plug-In interface
  Various development tools like SourceSafe or EUROScope can be integrated into EUROSkit.

Download EUROSkit brochure