Actions
Forum Thread Details
  • Replies 0 replies
  • Subscribers 32 subscribers
  • Views 25 views
  • Users 0 members are here
Related

Forum #2: Interface & Control: Labview - ILS

skruglewicz

Forum #2: Interface & Control: Labview - ILS

Published: May 6, 2026

Hi Everyone,

In this second forum post, I am focusing on the "Command Center" of the Industrial Line Sentinel (ILS): the LabVIEW dashboard. For this project, the goal is to utilize the Emerson | NI LabVIEW trial to create a sophisticated "Digital Twin." This dashboard will serve as the supervisory layer, providing a real-time window into the edge operations of the UNO Q.

The dashboard is designed around three primary visualization objectives:

  • Visualizing Edge Data: Direct representation of the high-level processing results from the UNO Q.
  • Streaming Telemetry: Implementing a robust network pipeline using TCP/IP or MQTT to ensure data is moved reliably from the Linux environment to the PC.
  • Safety Heatmaps and Environmental Monitoring: Correlating AI-detected safety breaches with precise environmental data from OmegaDwyer sensors to identify high-risk operational patterns.

Resources 

This section compiles essential resources for procuring, installing, and mastering LabVIEW, the graphical programming environment foundational to developing the Industrial Line Sentinel's "Digital Twin" supervisory dashboard. The links cover the software's core features, available free trial and download options, and various learning tutorials to quickly establish a robust host-side control interface.

  • NI LABVIEW site
    • Software for applications that require tests with rapid access to hardware & data insights. LabVIEW helps save engineers development time with intuitive, graphical programming. Free Trial. Low Code Test Development. Diagram Complex Logic. Graphical Programming. On-Demand Virtual Demos.
  • NI LabVIEW Free Trial 
    • 7 day trial?
    • Experience the benefits of LabVIEW Professional by getting started with a free trial. For a guided initial experience, there is a web-based trial that offers on-demand access to a LabVIEW sandbox with a resource path that you can access as it fits your schedule. Alternatively, you can access a standard software download trial, which enables connecting to hardware, building a customer user interface, and saving data.
  • Labview Download page 
  • LABVIEW Learning 
    • Getting Started with Arduino and LabVIEW Community Edition (UNO Q NOT SUPPORTED)
      • This tutorial will provide step-by-step instructions to take you from downloading the software to exploring an example.
    • LabVIEW Tutorial 
    • LabVIEW Hands-On Guide
      • The LabVIEW Hands-On Guide includes four hands-on exercises, designed to help you develop a solid foundation in LabVIEW.
    • COMPARISON The main differences between the "Getting Started with Arduino and LabVIEW Community Edition" resource and the "LabVIEW Tutorial" lie in their overall focus, hardware requirements, and the depth of programming concepts taught:
      • Hardware Setup vs. Software Basics: The "Getting Started with Arduino..." resource is specifically tailored for users working with popular hobbyist hardware, guiding you through the physical setup and configuration of an Arduino Uno. It requires physical hardware, including the Arduino Uno and a USB cable. In contrast, the "LabVIEW Tutorial" requires no hardware accessories and is designed purely to teach the core concepts of graphical programming within the software.
      • Scope of Instruction: The Arduino guide focuses on hardware integration, showing you how to install the LINX toolkit, re-image the Arduino's firmware to communicate with LabVIEW, and run a pre-built program. The "LabVIEW Tutorial" provides a deep dive into the LabVIEW development environment, detailing the relationship between the Front Panel (user interface) and the Block Diagram (graphical source code). It thoroughly explains fundamental programming mechanics like data types, dataflow programming, manual wiring, debugging tools, and structures such as For Loops, While Loops, and Case Structures.
      • The Hands-On Examples: The hands-on application in the Arduino resource involves loading a pre-built example ("LINX - Blink (Simple).vi") to control a physical digital output, such as turning the Arduino's built-in LED on and off. The "LabVIEW Tutorial," however, guides you through building a program entirely from scratch; it walks you step-by-step through dropping multiply functions onto the block diagram, creating controls and indicators, and wiring them together to calculate the area of a triangle.

LabVIEW Installation Log & Architecture Hurdles

During the initial integration phase, I evaluated two distinct LabVIEW deployment pathways to establish the optimal supervisory layer for the UNO Q.

Primary Attempt: Community Edition & LINX Integration

I initially leveraged the Getting Started with Arduino and LabVIEW Community Edition resource, executing the procedural setup until the final firmware deployment stage.

At this milestone, I identified a significant Hardware Incompatibility: the LINX utility is not compatible with the UNO Q architecture. While the LINX Firmware Wizard is designed to flash pre-compiled firmware onto traditional microcontroller architectures like the Uno R3, the Arduino UNO Q features a sophisticated Single Board Computer (SBC) "dual-brain" design (Cortex-A53 and Cortex-M33). Consequently, the wizard fails to recognize the device, resulting in deployment errors.

Secondary Attempt: Professional Version 2026 Q1 Deployment

To bypass these firmware limitations, I transitioned to a standard software deployment using LabVIEW Professional 2026 Q1 (64-bit).

I accessed the official NI LabVIEW Download page: 

https://www.ni.com/en/support/downloads/software-products/download.labview.html#585712

The following configuration was selected for the "Digital Twin" supervisory interface:

  1. Version: 2026 Q1 (Released January 28, 2026).
  2. Included Editions: Base, Full, and Professional.
  3. Operating System: Windows.
  4. Bitness: 64-bit (Language: English; Driver Software: Included by default).
  5. File Size: 8.78 MB (Initial downloader).

During the integration of the Primary Attempt: Community Edition & LINX Integration, I encountered a critical obstacle: the LINX Firmware Wizard is fundamentally incompatible with the UNO Q's Single Board Computer (SBC) architecture. Because the LINX utility is designed for traditional microcontrollers like the Uno R3, it cannot deploy the pre-compiled firmware required for standard operation.

To resolve this, I pivoted to the Secondary Attempt: Professional Version 2026 Q1 Deployment. My current strategy focuses on validating the host-side logic via Custom Serial Communication using NI-VISA,  the most robust, high-performance, and architecture-agnostic way to bridge the UNO Q to LabVIEW. By writing custom firmware on the UNO Q to handle hardware-level timing, we can utilize LabVIEW strictly as the supervisory GUI and data processing engine.

I am currently performing these initial validation tests on the UNO R4 Minima. By developing custom firmware to stream comma-separated telemetry, I can leverage LabVIEW as a high-fidelity supervisory interface. This architecture ensures the system remains chipset-agnostic while maintaining peak performance.

The validation workflow consists of four primary phases:

  1. Prerequisite Installation: Configuring the host environment with necessary NI-VISA drivers.
  2. Edge Node Development: Implementing firmware to stream high-resolution 12-bit sensor data.
  3. Host-Side Parsing: Building the LabVIEW Block Diagram to decode the real-time serial data stream.
  4. Execution and Visualization: Running the live stream and monitoring telemetry via LabVIEW waveform charts.

Next Action Item  : I need to finish working through the unchecked steps in my log to get Step 4 (Execution) fully operational on the R4 Minima. Once verified, I will adapt this technique for the final implementation on the UNO Q.

Here is the step-by-step architecture to get them talking.

Step 1: Install Prerequisites

Before starting, ensure LabVIEW has the necessary drivers to talk to standard COM ports.

  1. Open NI Package Manager.
  2. Search for and install NI-VISA. This is the standard driver API used by LabVIEW to communicate over Serial, USB, and Ethernet.
  3. Restart your computer if prompted.

Step 2: The Arduino Firmware (The "Edge" Node)

Instead of letting LabVIEW poll the pins directly, we will program the Minima to stream data continuously over its native USB CDC connection.

Open the Arduino IDE 2.x and upload this baseline sketch. This example reads the Minima's true 12-bit DAC (Pin A0) and a standard analog pin (A1), formats them as a comma-separated string, and sends them to LabVIEW.

C++

const int dacPin = A0; 

const int sensorPin = A1;

unsigned long previousMillis = 0;

const long interval = 50; // Stream data every 50ms (20Hz)

void setup() {

  // The Minima's native USB CDC ignores the baud rate, 

  // but we set it for standard compatibility.

  Serial.begin(115200); 

  

  // Set A0 to 12-bit read/write resolution

  analogReadResolution(12);

  analogWriteResolution(12);

}

void loop() {

  unsigned long currentMillis = millis();

  if (currentMillis - previousMillis >= interval) {

    previousMillis = currentMillis;

    // Simulate reading a sensor and generating a DAC value

    int sensorValue = analogRead(sensorPin);

    int dacOutput = random(0, 4095); 

    analogWrite(dacPin, dacOutput);

    // Format: "SensorValue,DACValue\n"

    Serial.print(sensorValue);

    Serial.print(",");

    Serial.print(dacOutput);

    Serial.print('\n'); // Newline is crucial for LabVIEW to know when the message ends

  }

}

Step 3: The LabVIEW Block Diagram (The "Host")

Now, we build the LabVIEW VI to parse that comma-separated data stream.

  • Initialize the Serial Port:
    • Drop a VISA Configure Serial Port node onto the Block Diagram.
    • Right-click the VISA resource name input and create a Control. (This is where you will select the Minima's COM port).
    • Right-click the baud rate input, create a Constant, and set it to 115200.
    • Crucial Step: Ensure the Enable Termination Char input is set to True, and the Termination Char is 0xA (Line Feed / \n). This ensures LabVIEW reads exactly one packet of data at a time.
  • The Read Loop:
    • Create a While Loop.
    • Inside the loop, place a VISA Read node. Connect the VISA resource wire and error wire from the configuration node.
    • Wire a constant of 50 to the byte count input of VISA Read (it will stop reading early once it hits the \n termination character we set up).
  • Parse the Data:
    • Take the read buffer string output from the VISA Read node and wire it into a Spreadsheet String to Array function.
    • Set the delimiter to a comma (,) and wire a Double Precision (DBL) array constant to the format string input.
    • This instantly converts your "Value1,Value2\n" string into a numeric array in LabVIEW.
    • Use an Index Array node to split the sensor data and the DAC data into separate wires.
  • Visualize and Close:
    • Wire the separated numeric values to a Waveform Chart on your Front Panel.
    • Wire the VISA resource out of the While Loop and into a VISA Close node.
    • Add an Unbundle by Name (checking for errors) or a Stop Button to the While Loop's conditional terminal to ensure the program exits cleanly and releases the COM port.

Step 4: Execution

  • Plug in the Minima. Note the COM port assigned by your OS.
  • In the LabVIEW Front Panel, select that COM port from the VISA Resource dropdown.
  • Click Run. You should immediately see the data streaming into your charts.

Next Action Item : Dashboard Design and Full System Integration

  • Finalizing Network Telemetry: Establish the primary data pipeline using either TCP/IP sockets or an MQTT broker on the UNO Q's Linux environment (A53 core). This ensures high-bandwidth streaming of telemetry data to the LabVIEW host.
  • Developing the Safety Heatmap UI: Design a "Digital Twin" interface in LabVIEW that correlates AI-detected breaches with environmental data from OmegaDwyer sensors. The UI will visualize "Red Zone" incursions and safety violation heatmaps to identify high-risk operational patterns.
  • Dual-Brain Integration: Monitor the M33 core's real-time safety actions via the RPC bridge. The dashboard will provide a supervisory window into the deterministic CAN Bus safety logic, including the broadcasting of Emergency Stop frames via the ADI MAX33041E Shield.

Thank you to the other challengers for taking the time to review this forum post. I encourage collaboration and sharing of your knowledge of LabVIEW (learning resources, tips & tricks,workarounds,bugs ,etc.) and your techniques for connecting the Arduino UNO Q with LabVIEW. If you have any experiences with the 3-month free trial and how to obtain it, please share your insights!