What is LabVIEW? – A developer’s perspective

  • Most common misunderstanding about LabVIEW
  • What LabVIEW is best-suited for
  • What you can do with LabVIEW
  • What you can’t do with LabVIEW

If you want the more official answer to this question, check out National Instruments website: http://www.ni.com/en-us/shop/labview.html.

We’ll cover this topic from the perspective of our company, which was built around using LabVIEW and making it work for a variety of automated test applications (and even some non-test applications).

For the sake of transparency: we’re a platinum level National Instruments Alliance Partner, so we’ve obviously got a vested interest in using LabVIEW and making it work in the real world.

LabVIEW is essentially a graphical programming language (technically it’s a development environment, and the language is “G”, but in common usage it’s a language).  Instead of typing words like with C++, Python, or other text-based languages, you place and connect visual objects around your screen.

A picture makes the difference pretty clear:

Here’s a video screen capture of someone programming in LabVIEW:

Common misunderstanding

The most common misunderstanding with LabVIEW is that you can just pop it open and develop solid applications with it right away.  You can certainly develop something right away, but you wouldn’t want to rely on that something to not have bugs, crash, or be updated in the future.  It’s a complex language, similar in complexity to common text-based languages.

What is LabVIEW best-suited for?

LabVIEW is best-suited for developing code for automated test systems, systems used for validating designs (whether early stage R&D, design characterization, or reliability) and systems used to test products before they leave the factory (manufacturing test).

What else is LabVIEW used for?

Besides automated test, LabVIEW is used for two other main categories of applications:

  1. Control/monitoring of industrial equipment & processes (specifically for low annual production volume applications)
  2. Condition monitoring (mostly for not-quite-traditional monitoring applications)

LabVIEW-based systems tend to excel when you need to take a lot of measurements across several channels.  LabVIEW, especially when combined with NI’s hardware, is very good at interfacing with physical objects and systems, especially taking measurements.

Check out the respective sections in this article on What is LabVIEW used for to learn more detail.

What can you do with it?

  • Calculations galore – LabVIEW can perform most math functions you could ever want, from basic operators to DSP-related functions. Functions like: FFT, filtering, integration, PID control loops, correlation, various statistics, geometry calculations…. The list goes on and on.
  • Measure lots of signals from lots of sensors types (with NI hardware)
  • Talk to benchtop instruments
  • Control actuators and motors
  • Create user interfaces (GUIs)
  • Interface with industrial cameras
  • Interface with databases
  • Interface with code from other languages, such as .NET. MATLAB, and Python
  • Communicate over Ethernet, RS-232, USB, EtherCAT, CAN, RS-485, RS-422, LIN, 1553, ARINC, GPIB, and others
  • Develop custom instruments to augment off-the-shelf lab equipment for development teams to use in R&D labs
  • Target NI-specific real-time processing hardware with LabVIEW RT (there’s a separate pallet of VIs that are only appropriate for RT-related functions). This allows you to develop applications with consideration for things like operator safety from fault conditions, equipment protection from fault conditions, and reliable control algorithms.
  • Target NI-specific FPGA-based hardware with LabVIEW FPGA (there’s a separate pallet of VIs that are only appropriate for FPGA-related functions). It’s a significantly lower barrier to entry for FPGA-based programming because you can write some pretty high-powered applications without having to know VHDL.  It can help you with applications that have needs such as:
    • Reliable and fast control algorithms (10s to 100s of kHz)
    • Low latency between input and output (10s of µs)
    • Tight synchronization of signal I/O with HW clocking (10s of ns)
    • Tight cycle-to-cycle determinism (10s of ns)
    • Operator safety and equipment protection from fault conditions (no operating system to get in the way)
    • Multi-channel deterministic I/O (dozens of channels)
    • Dynamically generating complex waveforms/signals on the fly and reacting to those signals in real time

What can’t you do with it (at least not easily)?

  • Develop the latest and greatest GUI functionality – outdated front panel GUI visualization technology (e.g., dynamic re-sizing doesn’t just happen)
  • Web-based applications
  • Mobile applications
  • Database communication – you can do things like basic SQL calls, but it’s a lot of work to take a data structure from LabVIEW and get it into a database. It does not do binding. It does fine inserting data into a database, but using the data, manipulating it, is challenging (LabVIEW handles  the “C” in CRUD, but that’s about it).
  • Web API interfacing – it’s possible to connect to web APIs, but the bar has been raised in other environments, making this method primitive and inefficient for development. You’ll get there eventually, but it’ll take a lot longer.
  • Updating to a new version of LabVIEW and then going backward can be problematic because the LabVIEW development environment is so tightly linked to the G code, so defining LabVIEW code is much more complex than for text. Thus, as NI adds features to either the code or the UI, moving that version back several iterations will break the older LabVIEW environment. NI updates LabVIEW much more frequently than text-based languages.
  • Motion control – while you can do motion control with LabVIEW, there’s a fair amount of competition out there where the main focus is motion control.  Where LabVIEW-based control seems to come alive is in the realm of high-speed closed-loop control (e.g., power inverter control, actuator control, motor control) where an FPGA-based solution can start to shine.
  • Machine vision – you can certainly do machine vision with LabVIEW, but this is another case where there’s a lot of competition and companies where machine vision products is their main focus.

Why use LabVIEW?

There are 5 main reasons to consider using LabVIEW.  Check them out if you’re interested.