Graphical system design is an integrated hardware and software approach to increase productivity as you develop any measurement or control system.
Each new version of NI LabVIEW system design software represents NI’s commitment to this approach and offers support for the latest hardware platforms.
New features ensure that you have all of the tools you need to design and build your system in less time than with any other approach.
However, it’s not enough to build a system quickly. It’s equally important to build it right, which requires proper planning, a sound architecture, and well-written code.
Bad code can be written in any language, but in G, bad code or “spaghetti code” is arguably easy to spot. Not only is it hard to read, but it also exposes you and your projects to the many risks associated with a system that cannot easily be maintained or tested.
Well-written G code is easy to understand and clearly conveys system functionality and architecture.
Building a system right ensures quality and reliability, minimises maintenance costs, paves the way for team-based development, and guarantees system accuracy and performance.
The new features and resources in LabVIEW 2012 help you meet these needs by accelerating your success and the success of the systems you’re building.
From the latest LEGO robotics toy, to the world’s largest particle accelerator at CERN, multiple layers of intricate software has become a fundamental part of modern technology and scientific applications.
Explosion of hardware targets
Software is the driving force behind the rapid pace of technological advances that engineers and scientists have come to expect and even rely upon, and it is has been a catalyst for the explosion of hardware targets, development tools, and computing platforms that are currently available.
However, the role of software as a key component in such a broad number of industries and applications brings with it an entirely new set of challenges, which underscores the importance of investing in a modern development approach and tools.
A system, by definition, refers to the combination of parts that work together to form a complex and complete mechanism. We interact with numerous examples of a system on a regular and repeated basis, some of which are more obvious than others.
An automobile is a system that combines parts like an engine, tires, brakes, gears and so on, but this simple example also demonstrates just how rapidly things have evolved in a few short decades – a 2011 IEEE study estimated that the typical premium-class automobile contains roughly 100 million lines of code running on as many as 70 to 100 processors and computing platforms.
Similarly, the average smart phone exceeds the capabilities of many cutting-edge personal computers from just a few short years ago, and combines an incredible array of both hardware and software capabilities into a single, integrated system.
Both of these industries, like all other sectors of technology, are under incredible pressure to continue to innovate and add new features and capabilities at a staggering rate.
This rapid pace of innovation is not made possible through the use of software alone, but also by the abstraction provided by high-level tools, which ensures that time and energy is focused on the problem at hand instead of low-level details.
Pulse-width modulated signal
As an example of the importance of abstraction, children are programming incredibly capable robotics using the LEGO NXT because of the benefits achieved through high-level software.
If any of these children had to learn the steps required to create a pulse-width modulated signal on an embedded operating system (OS) by writing low-level code to interface with I/O, it’s safe to assume that very few would ever successfully get a motor moving, let alone build a robotic system that can avoid obstacles.
Similarly, engineers and scientists who cling to low-level tools when building a complex system risk getting distracted by the numerous delicate details associated with low-level software, which can be extremely disruptive to a product’s lifecycle.
Figure 1. The LEGO Mindstorms NXT makes it possible for children to build complex robotics systems that combine advanced sensors using high-level software.
High-level software is the enabling technology behind the wide variety of hardware platforms that are used in different subsystems, but systems are increasingly comprised of heterogeneous hardware.
This is especially true in high-performance and closed-loop control applications that require the use of a wide variety of processors and FPGAs.
Figure 2. High-level software abstracts the complexity of combining different types of hardware targets and I/O capabilities into a single platform, which makes it possible for users to focus on system design.
Traditionally, these different targets require the use of multiple teams with specific vertical expertise, along with specific toolsets, which can become fragmented and difficult to maintain.
System design environments are the next step in the evolution and abstraction of these tools as they provide a common interface that can be used to represent how all of the components of these systems work and communicate with one another.
Once again, making it possible for smaller teams to build incrementally more complex systems with fewer resources.
As the various software products and the hardware they enable become more advanced and cater to a wide variety of markets, it can be difficult to translate a list of new features and capabilities to a specific application.
A specific version of a tool and its respective features may be relevant in the short term, but it’s important to separate these from the longer-term considerations of investing in a platform.
An active and vibrant platform, which should include both hardware and software, has longevity and ensures that future functionality will be readily available and possible to include with minimal effort.
The pillars of a sustainable software platform include hardware support, modularity, reusability and the ease of integration, all of which directly impact the overall cost and level of effort required to support and maintain an application.
Table 1. It’s important to evaluate all of the factors that can impact the cost of supporting and maintaining an application over the entire lifecycle.
Large systems require significant initial investment in tools and processes to manage all of the components of the lifecycle.
Software engineering practices and configuration management tools are required for any complex project, but software requires qualified personnel to consider architecture, organization and design of the overall code.
The practices are very much standard across industries because of the dramatic impact they have on the quality of software and because they help detect defects early in development, which drives down the overall cost of development.
Figure 3. Embraer used a high-level approach to simulate over 50 embedded computers in their latest aircraft.
As an example, Embraer, a leading developer of commercial aircraft, used the NI LabVIEW system design software for full airplane simulation of over 50 different embedded computers in their latest plane, which is the first fly-by-wire plane in its class.
This high-level software-based approach made it possible for them to focus on performing electronic systems integration of 21 different networked real-time systems in roughly 30 months, which was a dramatic time savings compared to the original estimate of 42 months.
Measurement and control applications are at the core of many of the embedded designs going into these systems as well as other important phases of the lifecycle, including prototyping, algorithm development, validation, and integration and production test.
As products change and evolve through rapid iteration and new permutations, these supporting systems must support new functionality and capabilities with minimal effort and time.
A high-level approach makes it possible for these constantly changing systems to evolve and adapt to the changes by abstracting the interfaces with a common hardware platform, which also ensures that the software can leverage the latest capabilities.
In an instant, software went from a “nice to have” tool for use by a small minority to a fundamental part of modern systems.
The flexibility and customisability of software makes it possible to leverage the latest and most-advanced hardware and computing platforms, but often requires a wide array of expertise and expensive infrastructure to build and maintain.
This has driven engineers tasked with developing complex systems to leverage high-level tools as these return the focus to the actual problem that they are tasked with solving.
[Elijah Kerry is Senior Product Manager for LabVIEW at NI and a Certified LabVIEW Architect (CLA).]