Graphical system design addresses and mitigates many of the potential pitfalls involved in engineering algorithms for a functional prototype. Graphical system design is an approach to solving design challenges that blends intuitive graphical programming and flexible commercial off-the-shelf (COTS) hardware. With this approach, you can use a single environment across all stages of design. Now take a more in-depth look at how this approach specifically addresses the challenges raised above.
Multiple Models of Computation
One of the virtues of graphical system design is that it gives programmers the ability to create their algorithms regardless of the model of computation (MoC) they are implemented with. As code complexity for algorithms continues to grow, programmers have to use different MoCs to expand their coding capabilities. The following are just a few models of computation that you can use with graphical system design:
Data flow is the MoC most often associated with NI LabVIEW software. With data flow, operations require the developer to insert data in all the inputs before it executes. Data flow is an intuitive coding structure that makes implementing applications such as parallel processes easy.
Textual math is another tool for creating complex functions easily. Text-based math is a human-readable implementation of often complex algorithms that are easier to write in a script description form. Examples of textual math are the formula node and LabVIEW MathScript RT Module. With LabVIEW MathScript, you can choose the most effective syntax for algorithm development, whether you are developing algorithms, exploring signal processing concepts, or analyzing results.
Figure 1. Reusing Text-Based Code with the LabVIEW MathScript RT Module
Sometimes the algorithm you use was originally created in C or C++. In this case, you no longer have to discard the previous work. You can instead use the Inline C Node or the Call Library Function Node to directly call your previous code within LabVIEW. Use the Inline C Node for preexisting C code or implementing a small numeric or array algorithms and use the Call Library Function Node to access C code in DLLs or shared libraries.
Open Software Architecture
Over the years, the LabVIEW platform has seen wide-scale adoption in numerous design disciplines, resulting in a need to incorporate data with different design and simulation tools. LabVIEW accomplishes this intercompatibility with numerous integration tools, libraries, and file formats. LabVIEW also offers a large array of standard integration with other software tools and measurement resources including the following:
- DLLs, shared libraries
- ActiveX, COM, and .NET (Microsoft)
- DDE, TCP/IP, UDP, Ethernet, Bluetooth
- CAN, DeviceNet, Modbus, OPC
- USB, IEEE 1394, RS232/485, GPIB
- Databases (ADO, SQL, and so on)
Using these tools, integration with data from almost every kind of measurement and control device is possible. By combining LabVIEW with general-purpose standards for hardware communication, developers can ensure compatibility and scalability for many years in the future.
The LabVIEW Approach
The hundreds of functions in LabVIEW that cover a wide variety of traditional algorithms in math, signal processing, probability, and control are essential building blocks for any custom algorithm. These functions alleviate the burden of writing low-level code and give engineers the time to focus on a solution instead of implementation.
Because using LabVIEW makes acquiring real-world data so easy, users find it valuable to test their algorithms with actual data as an iterative approach to tuning them. With this interactive test approach, you can experiment with different functions to see if they provide the required expected result. For example, when processing a signal with a filter, you can select from a wide variety of solutions, acquire the actual signal that you need, and look at the results in either a graph or file. If the results are not suitable for the application, then you can select another filter. Often it is easier to acquire the actual signal to apply to an algorithm then to take the time to simulate it on software.
Commercial off-the-shelf hardware not only offers a cheap way to quickly begin prototyping but also, with graphical system design, helps you implement native algorithms on a large number of different targets with integrated I/O. Use real-time processors such as those found on the NI CompactRIO and PXI platforms to integrate I/O with deterministic control for additional reliability. This is essential in cases such as hardware-in-the-loop applications, where you need to tightly integrate hardware and software to dynamically simulate the environment that the control algorithms are trying to control.
Besides using just real-time processors with FPGAs, you can incorporate LabVIEW into your application to transport code from one type of COTS hardware to another. For instance, you can transport code that analyzes a signal on a desktop for real-world I/O and use it in form factors such as PXI, PDAs, and embedded processors without having to significantly rewrite it. In fact, designing and verifying a prototype first on a desktop and then transferring it to a 32-bit processor for deployment in an embedded system can save significant development time and costly rework due to missed design constraints.
Figure 2. LabVIEW Targets
Tools for Simulation and Control Design
Because LabVIEW is an open platform, you can map your measurement data against simulated results. You can even interchange simulated and physical data for behavioral modeling. In addition, you can drive physical tests with simulated stimuli to provide a robust testing environment.
Use simulation with LabVIEW to verify and predict performance for design criteria. You can import designs into separate simulation tools for early design evaluation. The next step involves automated layout or model formation and tooling to automate the build process. Saving system state information and output signals if applicable helps you debug applications as well as establish specifications for the application performance.
Use control block diagrams such as those found in the LabVIEW Control Design and Simulation Module to design a linear, nonlinear, discrete, or continuous control system. With this abstracted programming style, you can program with traditional control concepts such as transfer function blocks, integrators, differentiators, and feedback loops. Using this high-level block diagram, you can develop solutions from the conceptual level, where you can pull from your previous experience and knowledge about a system.
Figure 3. PID Control with Control Design and Simulation