Using LabVIEW to develop embedded systems based on 32-bit processors

As 32-bit multi-core processor applications gradually become popular, designers are facing new challenges. Industry experts point out that actor-oriented graphical methods are more suitable tools for embedded software design. NI's LabVIEW Embedded Development Module is a new add-on module for the LabVIEW graphical programming environment. Through this software and the concept of graphical system design, engineers who were previously unable to use embedded programming can enter the field of 32-bit microprocessors. Use the complete tools such as state diagrams, control charts, and signal processing library functions attached to LabVIEW to design their applications to solve various problems. This article introduces this development tool.

As embedded systems become more complex, designers are facing new challenges: As the cost of embedded systems based on 32-bit microcontrollers (MCUs) approaches that of 16-bit systems, 8-bit and 16-bit microcontrollers are gradually giving way to 32-bit systems-on-chip (SoCs) with better scalability and performance in many advanced applications. In addition, since increasing the performance of the entire system simply by increasing the performance of the CPU is no longer a sustainable development trend, major processor manufacturers have turned to multi-core architectures. This trend can be seen in the multi-processor core desktop computer launched by Dell a few months ago. From the perspective of consumers and users, the increase in processing performance is the same. However, from the perspective of an embedded system developer, the design will become more complex because you must understand how to develop and partition your application in a multi-processor environment. According to estimates ten years ago, the average embedded system has 100,000 lines of code. By 2001, this number actually exceeded 1 million, and the current number is estimated to be 5 million.

Now we turn our attention to the current development tools of embedded systems. As the complexity gradually increases, it is difficult for traditional tools to reduce the complexity of programming work. The embedded field needs another method to meet these challenges. The challenge is not only in the tools, but also in the way to solve the problem: embedded application development based on text programming will not be able to solve these problems in the future. This is already the consensus of many industry experts; Dr. Edward Lee is a leader in embedded research at the University of California, Berkeley. He pointed out that the current development methods of embedded systems, such as text-based programming and object-oriented tools, are difficult to use to build embedded real-time systems, because object-oriented tools are difficult to intuitively express time and parallelism, while time or concurrency is essential in today's embedded systems. Dr. Lee proposed that the actor-oriented graphical method is a more suitable tool for embedded software design.

Although the challenges of embedded systems are becoming more and more severe, there are now many directions to solve them. Many vendors have taken the approach of abstracting the design of low-level tools. Every step forward in this approach will attract more users. Another direction is to solve the challenges more thoroughly, that is, to move to platform-based tools, which can better express the entire system and reduce the correlation with specific hardware, making more software designs easy to understand and reuse, and the shift from text-based tools to graphical tools can intuitively express the system and solve the challenges of the system. The concept of Graphical System Design is derived from these trends. By simplifying the complexity of embedded programming, it reduces the requirements for domain experts in each step of the embedded design process; at the same time, it provides a shortcut from design, prototype to deployment, allowing engineers and scientists to iterate designs more quickly.

Although the tools on the market are moving towards graphical, they are still limited by their own limitations because they are tools for specific applications in specific fields, which is not enough to solve the challenges that the industry will face. In fact, the current embedded system market has many similarities with the desktop computer market in the early 1980s, one of which is that it is very fragmented. What the market needs now is a complete graphical programming language that provides enough flexibility and functions to meet the needs of a wider range of applications. Therefore, the key factor in graphical system design is graphical programming.

Apply design methodology directly to implementation

Since its introduction in 1986, the LabVIEW graphical programming language has simplified system complexity and provided acquisition, analysis, and display capabilities on the same platform, automating processes using computing power while allowing the reuse of hardware and software in the prototyping, manufacturing, and testing processes, thus bridging the gap between the three steps caused by different tools. LabVIEW graphical methods have become the standard development tool in all areas involving data acquisition and control. Since then, we have continued to add functional improvements to this programming environment, and now LabVIEW has added hardware timing capabilities to the existing timed loop structure, which is a semantic representation of time and parallelism. Now, we can set operating system priorities, delays, loop rates, etc. with a click; recalling the trend towards multiprocessors mentioned earlier in the article, we can now look forward to using scalable and intuitive graphical programming to develop applications and distribute processing to different processors.

The new NI LabVIEW Embedded Development Module is a new add-on module for the LabVIEW graphical programming environment. Through this software and the concept of graphical system design, engineers who were previously unable to use embedded programming can enter the field of 32-bit microprocessors. They can design their applications through a complete set of tools such as state diagrams, control charts, and signal processing library functions added to LabVIEW to solve various problems.

Domain experts—experts in a particular scientific or engineering field, but not necessarily embedded programmers—generally use different models or tools to solve their academic or engineering problems. For example, an engineer developing an engine control unit (ECU) might use a state diagram to graphically describe the functionality of the ECU. This engineer might be an expert in control theory, but might not have any experience with embedded or C programming. Until now, the implementation of embedded applications has required in-depth knowledge of embedded programming tools, such as C. As a result, many domain experts still rely on dedicated embedded developers to implement their solutions or even simply to prove a concept. This gap between domain experts and embedded programmers increases development time and makes it easy to introduce errors into the system.

The LabVIEW Embedded Development Module bridges the gap between design and implementation. Domain experts can now use the same environment to quickly design algorithms, prototype custom designs, implement their solutions on a target of their choice, and debug them—all graphically.

Developing target-independent code

Embedded targets themselves require programmers to have a deep understanding of the target before writing code. Programmers need to know all kinds of information about the memory map and registers on the board in order to execute their code on the board. In addition, most code is written specifically for a specific target. Thus, using a different microprocessor or different peripherals on a board may require rewriting most of the existing code, or starting from scratch. This means that the scalability of the final product is flawed.

Figure 1: LabVIEW development interface

However, with the LabVIEW Embedded Development Module, engineers and scientists can develop code without knowing the end goal, because the software generates ANSI C code for LabVIEW applications, rather than binary code for a specific target. LabVIEW Embedded is an open framework that can integrate any third-party tool chain to compile the generated C code, LabVIEW Real-Time Library functions, and Board Support Package (BSP) into binary code that targets a specific target and can run on that target. BSP is a low-level code that interfaces between C code and peripheral hardware on the board. Therefore, if the board needs to be upgraded, engineers can simply link a different BSP into LabVIEW and make a small change to the existing graphical code to complete it.

Target-independent code development means that engineers and scientists no longer need to wait for the hardware to be determined before starting to design algorithms. This parallel work and increased efficiency greatly shorten the development cycle and time to market. Finally, the generated LabVIEW code is not platform-specific, so you can easily upgrade to new hardware.

Reduce development time using LabVIEW embedded features

The LabVIEW Embedded Development Module builds on the innovative spirit of LabVIEW for nearly 20 years, helping engineers and scientists take advantage of hundreds of built-in library functions covering advanced algorithms, file I/O, logic and signal processing. Through LabVIEW Embedded, engineers and scientists can use a new feature called Inline C Node to integrate existing embedded code to maintain the open architecture of LabVIEW.

In addition to built-in graphical user interface displays, probes, breakpoints, and function stepping for quick debugging, the LabVIEW Embedded Development Module provides two other seamless interfaces for code debugging. On embedded target platforms, engineers can use "instrumented debugging" to facilitate debugging over TCP/IP, RS232, or CAN. Using the built-in on-chip debugging interface, engineers can debug through industry standard protocols such as JTAG, BDI, and Nexus without affecting program performance.

LabVIEW Embedded Development Module enables domain experts to use existing technologies for more applications, use the same environment for algorithm design, prototyping, and implement their solutions, greatly shortening development time and time to market.

NI provides a variety of hardware platforms that integrate with LabVIEW to complete the entire process from design, prototype to deployment. For example, using LabVIEW and NI reconfigurable I/O (RIO) devices or NI CompactRIO platforms, they can quickly and easily create prototypes of embedded systems. One of NI's existing success stories is helping Drivven, a provider of automotive control and data acquisition solutions, prototype the FPGA-based 2004 Yamaha YZF-R6 motorcycle engine control system through NI CompactRIO. Their goal is to provide a seamless path from prototyping to production for FPGA-based transmission controllers. For this project, Drivven used LabVIEW on software; on hardware, they chose a 4-slot NI CompactRIO embedded system because of its flexibility, small size, and stable form factor. With this system, they can quickly and easily observe data while easily adding sensors and actuators. In addition, they can place the controller in the extremely limited space on a super sports motorcycle. This project includes three main stages: 1. Through the development of custom I/O modules. Three custom I/O modules monitor all of the motorcycle's sensors and control its actuators, and additional CompactRIO modules are being developed for transmission control applications, including modules for driving the electronic throttle and for interfacing with a common exhaust gas oxygen sensor. 2. Mapping the Factory ECU. The performance of the Factory ECU was fully mapped by logging ECU data to 1MB files (up to 20 files at a rate of one file per minute) while the motorcycle was driven at many different combinations of throttle positions and engine speeds (nearly 700 operating points). The driver carefully steered the motorcycle to minimize transient operation. An engineer in a following car periodically received the data files wirelessly from the CompactRIO, transferred them to a laptop, and immediately analyzed the data to cover all operating points. A laptop-based NI LabVIEW application quickly sorted the data into speed/load operating tables while filtering out transient data. The mean and standard deviation were calculated from the data for each operating point. In two hours, the team collected data for 90 percent of the bike’s operating points, which was sufficient coverage to fully understand the mapping of the factory ECU. Later, in the lab, engineers processed the data using LabVIEW, providing 3D and 2D visualizations while graphically modifying the raw data to fill in missing operating points. 3. Engine Control. In the final stage, Drivven used CompactRIO to prototype a research ECU that would have performance comparable to the factory ECU, but with the capabilities to implement future control algorithm research and development (which would not be possible with production electronics). Using CompactRIO, Drivven implemented a number of engine management FPGA cores, all with configurable LabVIEW FPGA diagrams and placed in a block diagram. Using the LabVIEW Real-Time Module, a combination of speed-density and alpha-N engine control strategies (often used in high-performance racing applications) was achieved. Thus, CompactRIO and LabVIEW provided the required reliability and precise timing resources, and the system was robust enough to withstand the high temperatures and vibrations of the operating environment. To read the complete solution, visit ni.com/china and enter the info code cn5k8t.

In addition, using the LabVIEW Embedded Development Module, you can also create embedded boards and deploy them to any 32-bit microprocessor. Just as LabVIEW enables engineers to develop customized virtual instruments instead of relying on vendor-defined desktop instruments, thus revolutionizing the test and measurement field, the LabVIEW Embedded Development Module enables industry experts to use their expertise to develop embedded applications without relying on embedded experts.

As the complexity of embedded system design increases, graphical methods are an inevitable trend. They are redefining embedded design, allowing more engineers to use embedded development in an unprecedented way, thereby improving the speed and quality of design. Integrating the fragmented market, adopting standard and readily available technologies, and releasing integrated, easy-to-use hardware and software platforms - this is the operating model that NI has maintained for many years. Graphical system design is a platform that promotes embedded design to a wider audience. We provide this function through a unified graphical tool that can free field experts from increasingly complex embedded designs. From design, prototype to implementation, the use of unified design tools will undoubtedly greatly improve the efficiency of the entire design process.

NI Embedded Development Module Diagram