Accelerate the process of prototyping embedded systems with LabVIEW FPGA

Development Trend of Embedded Systems

An embedded system generally refers to an independent system with a specific purpose. With the rapid development of semiconductor technology, embedded systems are penetrating into all aspects of modern society and are widely used in aerospace, communication equipment, consumer electronics, industrial control, automobiles, ships, etc. The huge market demand has driven the development of embedded systems to a higher technical level.

The development process of embedded systems can generally be divided into three stages: design, prototyping and release. Design is mainly about designing the product itself and the algorithms and concepts involved. Prototyping verifies or evaluates the feasibility of the design. Release is the final realization of the product. In most cases, a variety of software development tools are involved in the entire development process. For example, during design, text mathematical tools may be used for algorithm design, modeling, and simulation. In the prototyping verification stage, graphical development environments have now become the mainstream tools for simulation and verification. In the release stage, microprocessors or FPGAs may be used, which will involve related development environments such as C or VHDL, or even assembly language. In the traditional development model, text programming tools occupy a mainstream position.

Embedded software and its developers seem to be at a crossroads. Industry statistics provided by Venture Development Company (VDC) show that although the number of lines of software code is increasing at a rate of about 26% per year, the annual growth rate of embedded developers is only 8%.

However, there is more to it than that. In addition to accomplishing more work with relatively fewer people, embedded developers must also shorten system design cycles while ensuring product reliability. Increasingly fierce competition has made today's electronic product market extremely sensitive to time-to-market pressures. Taking the consumer market as an example, a typical embedded product design cycle is 9 months, while the market opportunity for launching a product may be as short as 1 to 2 months. If a product is not launched at the market opportunity from the beginning, it is likely to cause a significant reduction in market share or even lead to the failure of product promotion. These factors have greatly increased the pressure of "first-time design success" in embedded system design, which in turn has promoted the need for fast, efficient, and reliable verification at the system level. System prototyping, that is, creating design prototypes that run at real speed in the system environment, is becoming increasingly necessary.

Advantages of FPGA in Embedded Systems

The most cost-effective technology to achieve this kind of prototype verification is to build a prototype based on FPGA. FPGA is a chip with reconfigurable logic gates. Unlike ASIC chips that provide functional definitions from suppliers, FPGA can be configured and reconfigured according to the different needs of each application. Because FPGA allows custom algorithms to be implemented in hardware, it has the advantages of precise timing and synchronization, fast decision-making, and simultaneous execution of parallel tasks. On a PC or a platform with a real-time operating system (RTOS) and a microprocessor, the processor must time-share multiple tasks, while FPGA can be configured as multiple independent parallel computing resources. In short, it is like having multiple microprocessors on the chip, and these microprocessors are optimized for specific tasks.

The performance and flexibility of FPGAs make them a very effective technology for processing input and output. Communicating and generating PWM signals through custom digital protocols are good examples of this type. For example, FPGAs can be configured to communicate using custom digital protocols, such as decoding input information, and then encoding the information combination as an output data packet and sending it out. In some cases, it is even necessary to perform multiple operations simultaneously and synchronize these operations with each other and other input and output tasks. If a software-based system is used to complete this work, even with an RTOS, the output performance may not meet the requirements. FPGA's excellent performance in input and output, parallelism, and real-time performance makes it an ideal tool for embedded system prototyping verification. Intel's new generation of multi-core processors chose FPGA as its prototyping platform.

Accelerate System Prototyping with LabVIEW FPGA

The biggest challenge in integrating an FPGA into an embedded system is how to configure the FPGA's logic and connect sensor inputs and control outputs to it. Many embedded system designers are very skilled at programming microprocessors running under real-time operating systems, but they don't like defining the hardware at the chip level, which requires knowledge of design tools and languages ​​such as VHDL. Of course, entering the chip-level realm also means designing and building the circuit boards around the chip, and although this is outdated for some embedded system designers, there are still many designers who prefer to use off-the-shelf hardware as much as possible, especially when the hardware must accurately measure and digitize sensor data.

Comparison and Selection of FPGA Configuration Tools

There are many FPGA configuration tools available. Some require you to code in VHDL or other languages ​​to define the hardware, some provide a graphical configuration environment, and some allow you to write software using familiar tools and then download the code to the FPGA. There are several things to consider when choosing which approach is right for you. One consideration is your background. Are you an experienced hardware developer with a deep understanding of the basic operation of FPGAs? If so, you can use low-level tools to leverage your experience and get into the details of the configuration. Maybe you are not a hardware engineer, but you are a good programmer and can easily learn new programming languages. In this case, you may need to choose a tool that allows you to fully utilize data structures and program details. Another possibility is that you are neither a hardware nor a software expert, but you design the system because you are very familiar with the theory behind the whole system or the application to which the system is put. If this is the case, then you should choose a tool that allows you to design in your own language without having to learn the complexities of FPGA or hardware description languages.

Another important consideration is what functionality you are planning to achieve with the system you are designing. If you are designing multiple different types of systems, general purpose hardware design tools may be the best fit. There are many people who have spent a lot of time becoming experts in using these tools, and you can join them. If you want to narrow the scope a little, there are tools that will handle those "routine" things, allowing you to focus on your own research area. For example, there are many tools that can help you quickly develop a signal processing system and publish it to an FPGA, and there are also tools optimized specifically for adding measurement and control functions.

You also need to consider the system configuration. What size should it be? Will it connect to a PC? Some FPGA development tools require you to develop all the hardware surrounding the FPGA, while others require you to use a special board with an FPGA built in. For the latter, a lot of the work of connecting to other resources on the board, such as I/O and buses, has already been done, which can greatly speed up development because you don't have to worry about things like noise immunity, settling time, and crosstalk. If the system requires a lot of connection to a PC running Windows or RTOS, then you should choose a design tool that can be cross-platform.

LabVIEW FPGA graphical development environment

In the past, for FPGA

Programming requires a deep understanding of VHDL or other low-level design tools, which requires a long learning process. Through LabVIEW FPGA, FPGA logic can be defined in a graphical environment, allowing more engineers to use FPGA technology to design and prototype systems without having to master VHDL or hardware design expertise.

In addition, by cooperating with some toolkits in LabVIEW, such as the digital filter design toolkit, LabVIEW FPGA can help engineers quickly develop signal processing systems and publish them to FPGAs, and provide many specialized measurement and control functions. For example, LabVIEW FPGA has built-in functions that can be used for closed-loop PID control, 5th-order FIR filtering, one-dimensional lookup tables, linear interpolation, zero-crossing detection, and direct digital synthesis of sine waves.

For system configuration and I/O connection, engineers can use LabVIEW FPGA and NI RIO devices to greatly speed up the development process, because NI RIO devices have already done the work of connecting I/O to the bus. Engineers can quickly customize I/O or control hardware circuits through LabVIEW FPGA, and the performance of these circuits is comparable to the hardware performance defined and optimized by the manufacturer. Using the LabVIEW FPGA module, engineers can develop FPGA programs on a host running Windows, and then compile and run these code programs on hardware with LabVIEW. Because LabVIEW FPGA uses hardware to implement program algorithms, its algorithm execution performance is much better than that of software-based systems. [page]

Support for timing and parallelism

Compared with traditional text programming, LabVIEW is a programming language with a parallel structure. It is very suitable for the parallel structure of FPGA to implement synchronous or asynchronous parallel tasks. Consider an application with 8 PID control loops, as shown in Figure 1. The application will create two completely independent processors on the FPGA, which can run synchronously or asynchronously with the FPGA clock. Even in the same while loop or similar structure, we can increase the execution speed by parallelizing the flow line operation of the code. Divide the processing process into several fragments and execute these fragments in sequence in continuous loops. As shown in Figure 1, we divide the control algorithm into two fragments. Each execution of the while loop will update the PID control output, but the analog input (AI) and control algorithm 1 are executed in parallel with the analog output (AO) and control algorithm 2. The results show that in this way, the algorithm execution speed is much faster than the sequential processing structure.

Figure 1 Parallelization of code flow line operations

Prototyping with LabVIEW FPGA and NI RIO Devices

Many designs are launched later than expected, and some are found to fail to meet the expected functions and indicators after being launched on the market. Therefore, certain measures must be taken to speed up the design process and improve the design quality. One solution is to introduce real-world signals and hardware into the design process earlier, conduct better system prototyping, and thus discover and correct potential problems at an early stage.

But in any design and development process, there is a big gap between the virtual world based on software design and simulation tools and the physical world of electronic or mechanical measurement. The most obvious value of the LabVIEW platform is to build a bridge between the gap between the virtual world and the physical world. Physical measurement is a completely different challenge from design and simulation, requiring tight integration with a wide range of measurement and control hardware and handling a large number of channels or ultra-high-speed throughput with optimized performance. The LabVIEW platform has been continuously evolved to provide extremely high performance and flexibility in the field of physical measurement. More importantly, the LabVIEW platform is open, so designers can map measurement data with simulation results, and even interchange simulation and physical data for behavioral modeling in design, or drive physical testing with simulated stimuli, so as to build system prototypes more effectively and quickly.

If embedded system developers want to customize hardware for final release, it is difficult to develop software and hardware in parallel, because the software has never been tested on representative hardware until the system integration step. In addition, designers do not want software development to be purely theoretical. If I/O is not introduced until the system integration test, the design is verified with real-world signals. Once problems are found, it means that it is difficult to complete the design task within the expected time.

Most designers currently use evaluation boards to prototype their systems, but these boards often have only a limited number of analog and digital I/O channels and rarely support vision, motion, or synchronization. In addition, designers often spend a lot of time developing custom prototype boards because they need sensor or special I/O support, just for the purpose of proving the design concept. Using a flexible, commercial prototyping platform can greatly simplify this process, eliminating much of the work involved in hardware verification and board-level design. For most systems, the prototyping platform must include the same components of the final release system, such as a real-time processor for executing algorithms, a programmable logic device for high-speed processing, or an interface between the real-time processor and other components. Therefore, if the commercial system does not meet all requirements, the platform must be scalable and support customization. NI provides a variety of hardware platforms that integrate with LabVIEW to complete the entire process from design to prototype to deployment. For example, using LabVIEW and NI reconfigurable I/O (RIO) devices or NI CompactRIO platforms, you can quickly and easily create prototypes of embedded systems. As shown in Figure 2, a variety of NI RIO devices can be configured through LabVIEW FPGA.

Figure 2 LabVIEW F

PGA Block Diagram and RIO Hardware Platform

One customer case is Boston Engineering. They want to develop a tension control machine for digital photo printing systems. In it, the color ink cartridges are fed to the print head through the drive motor, and the tension is controlled by the tape motor and the propulsion motor. The vibration of the cutter chassis, the number of photos printed each time, and the speed change of each motor will affect the tension on the bottom layer. The control system ensures that the tension of the tape and propulsion is within the set range through the position of the two motors, otherwise there will be color difference. The designed tension control hardware requires two pulse width modulation outputs to control the motor, two encoders to feed back the speed to the motor, two analog input channels to connect the Hall sensor to measure the position, and two digital lines for signaling.

Since traditional prototyping boards cannot meet these requirements, a prototyping platform with customizable I/O is needed, so they use the CompactRIO platform for prototyping. The CompactRIO system includes a 266MHz embedded microprocessor, an Ethernet controller, and a 1 million gate FPGA on the backplane. By programming the FPGA on the backplane with LabVIEW FPGA, their control, mechanical, and electronic engineers can directly participate in programming. They run the hypervisor in the embedded controller and the motor control algorithm in the FPGA. This resource configuration makes the programming mode of prototyping and final system release very similar. In order to run the control algorithm in the FPGA, they converted the ZPK (zero-pole-gain) model into a filter provided by the LabVIEW Digital Filter Design Toolkit. Since this toolkit supports automatic generation and optimization of LabVIEW FPGA code, the original ZPK model can be directly converted into code that can run on the FPGA. In addition, they also used this toolkit to convert the original floating-point algorithm to fixed-point to save FPGA resources, and tested, verified, and corrected the quantized model to obtain the expected results. Through this prototyping method, they saved a lot of development time.

in conclusion

As the complexity of embedded systems continues to increase, designers are facing severe challenges. The pressure of time to market has greatly increased the pressure of "first-time success" in embedded system design, which in turn has promoted the demand for fast, efficient and reliable verification at the system level, and the necessity of system prototyping is increasing. Due to its many excellent features such as high performance, reconfigurability, small size and low engineering development cost, especially its excellent performance in input and output, parallelism and real-time performance, FPGA has become an ideal tool for embedded system prototyping verification.

Using the LabVIEW FPGA module, engineers can develop FPGA programs on a host running Windows, then compile and run these code programs on hardware using LabVIEW. With the LabVIEW FPGA module, you can customize I/O or control hardware circuits without having to master hardware design knowledge or VHDL first, accelerating the process of embedded system prototyping. The graphical programming model allows more engineers and scientists to use their expertise to develop embedded applications. Using a unified environment for design, prototyping, and deployment, LabVIEW provides an extremely efficient development method for embedded system development.