Workbench is undoubtedly a very powerful integrated development environment in the current VxWorks software development field.
Problems Faced in Embedded System Development
Embedded software development differs significantly from desktop software system development in that it generally requires a cross-compilation and debugging environment, that is, editing and compiling software is done on the host (such as under the Windows operating system on a PC), and the compiled software needs to be downloaded to the target machine for execution (such as on a PPC target machine running VxWorks). The host and target machine establish a communication link to transmit debugging commands and data. Because the host and target machines often run different operating systems and have different processor architectures, this increases the complexity of embedded development.
In general, the problems faced in embedded development are mainly reflected in the following aspects:
Involvement of Multiple CPUs and Operating Systems
Embedded CPUs or processors can be quite diverse, including PENTIUM, MIPS, PPC, ARM, XSCALE, etc., and are widely used. The operating systems running on them are also numerous, such as VxWorks, Linux, Nucleus, WinCE, etc. Even within a single company, several types of processors and even several embedded operating systems may be used simultaneously. If multiple types of boards need to be debugged at the same time, each with multiple tasks or processes running on it, the complexity is understandable.
Diverse Development Tools
Not only do various operating systems have their own development tools, but different stages of development within the same system also require different development tools. For example, during the early stages of user target board development, hardware emulators are needed to debug the hardware system and basic drivers. During the application debugging phase, interactive development environments can be used for software debugging. In the testing phase, specialized testing tools are required for functional and performance testing, while in the production phase, programs need to be solidified and factory testing performed, etc. Generally, each type of tool needs to be purchased from different vendors, and each must be learned and mastered separately, which undoubtedly increases the overall company’s expenditure and management difficulty.
Observation and Control of the Target System
Due to the vast differences in embedded hardware systems, software modules, and system resources, to ensure that the system operates normally, software developers must have complete observation and control capabilities over the target system, such as various hardware registers, memory space, operating system semaphores, message queues, tasks, stacks, etc.
In addition, embedded systems change quickly, and there are tight time requirements for development, especially for consumer products. If there is a powerful integrated development tool for embedded software that can meet the needs of various stages of embedded software development while being easy to use and having a user-friendly interface, that would be ideal. The “Workbench” embedded software development platform recently launched by Wind River Systems (hereinafter referred to as “Wind River”) is such a versatile player.
Features and Advantages of the Workbench Embedded Development Platform
Wind River has been dedicated to research in the embedded software field for a long time, with its historically significant Tornado development environment and VxWorks embedded operating system products being widely used in the embedded field, renowned for their industry-leading strong real-time performance and stability. The new generation Workbench development platform inherits the consistent advantages of its original Tornado integrated development platform, while also being more powerful. With the adoption of the advanced Eclipse software framework, the entire system has become more open and easier to extend. Its main advantages are as follows:
Based on the Open Eclipse Platform, the Debugging Environment Can Be Fully Customized
The Eclipse software framework is a complete and open base platform that can integrate graphical tools and any necessary functions into the same development environment through standard interfaces. Currently, commercial development tool providers such as IBM, HP, and Borland support the Eclipse development platform, and there are many communities online that develop plugins for the Eclipse platform. Since Workbench is compliant with the Eclipse framework, these commercial and free plugins that conform to the Eclipse platform interface can be integrated into the Workbench development environment, greatly expanding the functionality of Workbench. For example, if users want to use their familiar configuration management tools or editors, they can find such plugins and integrate them in, making the development process very suitable for their needs.
Moreover, Wind River has made various enhancements to Eclipse, significantly improving system performance. For example, Workbench implements asynchronous interface functionality, allowing long-running tasks to run in the background while still receiving debugging requests from developers, thus avoiding long waits; additionally, Workbench has optimized the data request mechanism for the target machine, meaning the system only retrieves the small amount of data needed for the current view in the integrated development environment, while not requesting data that is not visible, greatly increasing the response speed during cross-debugging and reducing system load.
A Single Full-Featured Platform Covering the Entire Product Development Cycle
The “substantial” process of software development for an embedded product includes everything from the initial hardware boot, BSP (Board Support Package) and driver development, application development, to later testing, validation, and finally the production phase. Generally, different tools can be found for each stage (and this is mostly the case). However, Wind River’s Workbench development platform changes this situation by providing almost all the functions required for the aforementioned development stages on a single Workbench platform. Specifically, this includes hardware system simulation capabilities (with accompanying hardware emulators), project management and build systems, editors, version management, command interpreters, debugging tools, system analysis tools, system observation tools, FLASH programming tools, etc., combined with various software function modules and development tool plugins provided by Wind River and third-party manufacturers, all integrated under the unified Workbench platform, which will greatly improve the embedded software development environment. For a company, this can improve efficiency, reduce investment, and simplify management. The various stages of embedded software development and the functions provided by Workbench at each stage are illustrated in Figure 2.
Wide Applicability, Especially Suitable for Complex Target Systems
The wide applicability of the Workbench platform is mainly reflected in the seven “multi” aspects: multi-tasking, multi-target, multi-mode, multi-OS, multi-CPU, multi-connection forms, and multi-host environments.
-
Multi-tasking: In the Workbench debugging environment, multiple different tasks (or processes) on the target system can be connected simultaneously, and each task can be set with breakpoints and stepped through individually. Developers no longer need to disconnect one task to connect to another for debugging. This provides convenience for developing target systems with multiple tasks, especially when needing to observe the interaction between multiple tasks.
-
Multi-CPU: It is known that Wind River’s Tornado development environment supports a full range of mainstream CPUs (or processors), and Workbench inherits this tradition. The currently released Workbench 2.2 version already supports all mainstream CPUs of the PENTIUM, PPC, and MIPS series. Support for ARM, XSCALE, SH, and other series is being ported and tested, with a formal version (Workbench 2.3) to be released soon.
-
Multi-OS: Currently, Workbench 2.2 not only supports the VxWorks embedded operating system (version 6.0 and above) but also supports the Linux operating system, which indeed brings good news to a large number of Linux embedded developers. It is known that due to the “free” nature of the Linux operating system, its software development systems have always been relatively scattered and isolated, making them not particularly convenient to use. With Workbench, embedded Linux development becomes as easy and fast as developing under VxWorks. Furthermore, if necessary, support for other types of embedded operating systems can be added in the future, as Workbench itself is open and extensible.
-
Multi-target: Workbench’s strong support for complex target systems is also reflected in its ability to connect multiple target boards simultaneously for debugging. Importantly, these target boards can have different processors, and the operating systems running on the target boards can be arbitrary (both VxWorks and Linux can run), with debugging work being carried out simultaneously in the same Workbench interface, greatly facilitating debugging of complex systems.
-
Multi-connection: Multi-connection refers to the various ways in which communication can occur between the host where Workbench is located and the target machine. If the target system has an Ethernet interface, Ethernet connection should be the first choice due to its speed; if the target system does not have an Ethernet interface, serial ports can also be used for communication connection, which, apart from being slower, is functionally no different from Ethernet connection. Additionally, during the initial debugging phase of the target board, connection can also be made through Wind River’s hardware emulator (WindRiver ICE / WindRiver Probe) to observe hardware status and quickly locate hardware issues.
-
Multi-mode: In Workbench, debugging programs can be done in either task mode or system mode. Task mode means that each task runs independently, and pausing one task does not affect the operation of other tasks (mainly used for debugging individual tasks); while system mode means that if any part of the system is paused, the entire system stops (mainly used for debugging interrupt programs).
-
Multi-host: This means that Workbench can run under the three major popular host operating systems: Windows, Linux, and Solaris. This not only caters to different developers’ usage habits but also facilitates the development of certain target systems, such as debugging and running Linux system target boards in a Linux host environment (though this is not mandatory).
Rich and User-Friendly Debugging Methods, Greatly Accelerating Debugging Progress
-
Dynamic Linking: Those who have used the Tornado development environment are well aware of its unique feature of downloading modules individually and dynamically linking them to the target system, and Workbench fully inherits this feature. With this functionality, developers no longer need to complete all application modules before debugging, nor do they need to compile and download the application modules and operating system together every time. Instead, they can compile a small module and, if they wish to validate it, simply download that small module (even if it’s just a function) to the target board for testing, greatly speeding up the debugging and validation process, especially when there is a low-speed connection between the target board and the host.
-
Target Visualization: Visualization of the target system is a desired feature for every embedded software developer. To achieve this, Workbench provides not only traditional viewing tools for memory, registers, variables, and call trees but also several enhanced system viewing tools: target browser, system observer, and SCOPETOOLS toolset. The target browser can be used to view the usage and current status of each system resource in the target system, including various modules, tasks, semaphores, message queues, memory, stacks, etc. The system observer provides detailed analysis and graphical visualization of system events, while also displaying the complex interactions between relevant tasks, interrupts, and system objects executed on the target machine. It can clearly show context changes and system events such as semaphores, message queues, signals, tasks, user events, and timers, much like a software “oscilloscope.” By using these system viewing tools, developers can easily diagnose and resolve scheduling issues (such as deadlocks, starvation, and competition), performance issues (such as priority settings, resource contention, and mutual exclusion), timing issues, etc. The RTI SCOPETOOLS is a powerful visualization toolset specifically designed for device-class software development, allowing users to dynamically observe the entire system platform, including application code, third-party libraries, and even the operating system itself. Workbench 2.2 integrates tools for observing function execution efficiency (ProfileScope), for monitoring memory usage efficiency and detecting memory leaks (MemScope), and for detecting dynamic changes in values at specified memory locations (StethoScope). Additionally, optional tools for real-time tracking of code execution (TraceScope) and for detecting code execution coverage (CoverageScope) are available.
-
Simulation Environment: Before the hardware development of the target system is completed, software system development often needs to proceed simultaneously. The simulated environment provided by Workbench (applicable only for applications developed for the VxWorks operating system) offers a means for this synchronous development. The VxWorks software emulator runs in the host operating system environment and is a local application migrated from the VxWorks 6.0 operating system. It can accurately implement the advanced complex features of VxWorks 6.0, including real-time processes, memory protection, and has a complete file system and network functionality, and can call host system APIs. These features make it possible to develop complex systems within the VxWorks software emulator. For example, multiple networks can be built in the VxWorks software emulator, allowing for inter-network communication and external connectivity through the host system’s network interface, creating a completely realistic network environment; another example is that the host system’s display can be used to develop applications with graphical user interfaces by calling the host system’s graphics-related APIs. Generally, users can write APIs for any resources of the host system and call them in the VxWorks software simulation environment, greatly extending the functionality of the VxWorks software emulator and facilitating synchronous development of application software.
-
In addition to the aforementioned features that need special emphasis, the powerful debugging capabilities of Workbench also include support for various types of breakpoint settings, convenient and flexible operating system kernel configuration tools, host Shell and target machine Shell, four types of command interpreters, and a rich view interface, etc. For detailed information, please refer to the Workbench documentation and manuals, which will not be elaborated here. In summary, using Workbench provides developers with a sense of convenience and flexibility, powerful functionality, and almost limitless capabilities.
Comparison of Functions Between Workbench and Tornado
The Workbench platform enhances various functions compared to the Tornado platform, and many new features have been added, as outlined in the table below:
Workbench is a significant upgrade from Tornado, but it cannot be said that Workbench can completely replace Tornado at this time. This is because Workbench only supports versions of VxWorks 6.0 and above (which have the concept of “process”). If users wish to use versions of VxWorks below 6.0 (which have flat address spaces where applications run within the kernel), they must use Tornado for development.
Current Application Status of Workbench
| Item | Tornado | Workbench |
|---|---|---|
| Project Management | Basic project management functions with limited support for hierarchical projects, requiring manual modification of makefiles, which is cumbersome. | Supports hierarchical control of any project, allowing for easy construction of project hierarchies using simple drag-and-drop methods, very convenient. |
| Project Types | Supports downloadable project types and customized VxWorks project types. | Increased support for system boot project types, real-time process project types, file system project types, user-defined project types, etc. |
| Editor | Functionality is relatively simple, only capable of general editing functions. | Has syntax analysis capabilities, can perform syntax highlighting, symbol definition lookup, symbol completion, function parameter hints, and has powerful symbol search and browsing capabilities. |
| Breakpoint Settings | Supports task-level breakpoints and global breakpoints. | Increased support for hardware breakpoints on processors, and provides various control methods for different breakpoints. |
| Simulation Environment | Basic VxWorks simulation environment, can operate files and network access in the host system. | Enhanced complex networking capabilities in the simulation environment, provides the ability to call host system APIs, and can simulate the generation of interrupt signals. |
| Target Connections | Supports network, serial port, and other connection methods. | Increased support for connections to hardware emulators. |
| Downloaded Code Size | Downloaded target code generally within 10MByte; exceeding 10MByte may lead to slow download speeds and system instability. | Designed to support downloadable target code of up to 750MByte, fully meeting development and debugging needs. |
| Target Operating Systems | Only supports VxWorks operating system. | Increased support for Linux operating systems, and can also be extended to other target operating systems. |
| Number of Target Systems | Single target system, only one connection can be established in the same development environment to debug one type of single board. | Can simultaneously debug multiple target boards and multi-CPU architectures. |
| Multi-task Debugging | Not supported, can only connect one task or perform system-level debugging. | Supports simultaneous connection of multiple tasks or processes on the target system for debugging. |
| Third-party Tools | Structure is relatively closed, making integration of third-party tools difficult. | Adopts the open architecture of Eclipse, making it easy to integrate third-party tools, with abundant resources. |
As mentioned above, Workbench is undoubtedly a very powerful integrated development environment in the current embedded software development field. It is most suitable for developing complex systems or collaborative development among multiple development teams, such as when a complex system requires multiple CPUs or multiple target operating systems, or when the application software itself is very complex, with multiple tightly related tasks, or when multiple project teams need to collaborate and share software modules, or when a company involves the entire process from hardware development to software development to production testing. In these cases, considering the use of the Workbench platform is very appropriate, as it not only enables rapid and effective system development but also facilitates effective project organization and management, ultimately reducing overall costs for the enterprise.