Global Sources
EE Times-Asia
Stay in touch with EE Times Asia
EE Times-Asia > Interface

Modern IDEs redefine 'integrated'

Posted: 02 Jul 2007 ?? ?Print Version ?Bookmark and Share

Keywords:IDE in application development process? integrated design environment? embedded design?

Faced with the increasing complexity of advanced embedded systems designs and the pressure to shorten time-to-market, developers are looking for ways to streamline their application development process. Multicore processors may be both a solution and a complication to the problem. Such processors promise to lower system costs by enabling the construction of highly integrated real-time systems that delegate competing elements of the application to different processor cores. But they require the developer to seek design tools that support multicore, multi-application embedded design.

One solution is to use an integrated design environment (IDE) that enables the development of real-time and non-real-time portions of an application within the same toolset. The IDE should also support the partitioning of target application code onto different processor cores.

With a single IDE, the developer must master only one user interface. This saves development time, and cuts maintenance and upgrade costs. If its output code can be targeted to leverage multiple CPU cores, the IDE lets developers create a higher-performance coupling between real-time and human-directed application subsystems. Finally, one IDE can be used to manage and develop many related applications for multicore platforms, ensuring uniformity in data structure and sharing among systems.

Combining the ability to develop real-time and human-directed applications with a single IDE is not a new concept. TenAsys included support for development and debugging of its INtime RTOS and Microsoft Windows applications for a single hardware platform 10 years ago. Key to its solution is a virtualized software model that controls each OS's access to the processor hardware.

Partitioning heterogeneous operating environments to run on multicore processors has proved to be a useful solution for complex embedded systems. By implementing multiple virtual machines (VMs) on a multicore processor platform (one VM per core), each OS can be contained without performance loss. The architecture also ensures that runaway processes on one core never affect those on other cores. Even if multiple operating systems are running in separate VMs from the developer's viewpoint, they exist on a unified platform.

One IDE that continues to gain popularity is Microsoft Visual Studio 2005. Although it was designed for commercial applications, embedded system software developers can use it because its plug-in features extend its functionality beyond the standard commercial realm. Using an IDE such as Visual Studio, both real-time and Windows applications can be edited, compiled, debugged and maintained simultaneously within a single environment. It may take a while for developers accustomed to using multiple, incompatible development tools to become acclimated to this environment.

Developers can debug applications at full speed in real-time more easily by using an IDE that supports the simultaneous development and execution of applications for multiple operating environments on a multicore processor platform. Without this capability, the developer would need to use a simulator or debug over a communication interface between the development host and the real-time subsystem. Debugging real-time code in a simulated environment dilutes the effectiveness of the development effort. Because a simulator is not the actual runtime environment, it is very easy to miss subtle timing-specific problems that can only be found when running directly on the RTOS.

Working in real-time
A Visual Studio real-time debugger plug-in can give access to breakpoints and source-level single-stepping, and watch variables in the real-time environment. The plug-in does not deter the ability to debug standard Windows applications. Instead, it adds the ability to work with real-time applications hosted on the RTOS environment.

In the case of TenAsys' INtime OS, the development tools integrate directly into the Microsoft Visual Studio IDE. A single solution file inside the Visual Studio IDE manages direct access to help and wizards, and the ability to edit, compile, debug and trap real-time system faults at the same time as standard Windows applications. Real-time process faults in the INtime VM environment can be trapped without disturbing the Windows virtual operating environment. The multi-OS works whether the real-time and Windows virtual operating environments are hosted on the same processor, on separate processor cores in a multicore CPU chip or even on two systems connected by an Ethernet cable.

The Visual Studio software development process uses "interface" boxes that represent components designed to support the creation and execution of real-time applications within the IDE. Project wizards can be integrated into the environment so that developers can quickly build those applications. The wizards for the real-time path should be designed to guide a developer through the many design decisions and then automatically generate usable code.

APIs that support communication and data transfer between the Windows and real-time runtime environments are facilitated by header files and libraries for the Windows applications. The APIs must be in formats consistent with the various languages supported by the Visual Studio IDE. These consist mostly of dynamic link libraries, including files and library files that are referenced by the compiler and linker when generating object code. The real-time environment must also be able to load and execute real-time object code generated by the Visual Studio compiler. Without this, a developer could not develop and maintain a single Visual Studio solution file.

The environment described allows for the creation of applications that run close to the hardware and that require an OS scheme tuned to the needs of the hardware. But the process of building applications for multiple operating systems within one IDE need not be limited to general-purpose IDEs.

For maximum efficiency, many IDEs are tailored to the task at hand. For example, modern industrial applications that implement programmable logic controller (PLC) functionality on industrial PCs are often programmed using graphical elements to represent the control system's various components. These systems are called soft PLCs because they blend the hard real-time determinism of a dedicated PLC platform with the flexible programming and third-party software environment available on a standard PC.

Ideally, the programmer should be able to tune the application to the target system's behavior directly on the development system. Advanced integrated tools, such as flowchart programming tools for soft PLCs, provide shorter design cycles and lower machine downtime via online diagnostics on the factory floor.

The intuitive nature of flowcharts lets engineers draw machine control sequences as steps, slashing control system design time. Boxes that represent read inputs, set outputs and math or logic functions are arranged diagrammatically on the page. High-level programming also simplifies the addition of diagnostics to the control system. During each step of the process, blocks can be added to check for error conditions. If errors are detected or responses fail to occur within a predefined time frame, the machine can be halted and corrective action immediately displayed on the operator screen.

- Paul Fischer
Senior Technical Marketing Engineer
TenAsys Corp.

Article Comments - Modern IDEs redefine 'integrated'
*? You can enter [0] more charecters.
*Verify code:


Visit Asia Webinars to learn about the latest in technology and get practical design tips.

Back to Top