Workers for LabVIEW
HomeDownload Follow ProjectAbout
  • Welcome to Workers for LabVIEW
  • What's New in v5.0
    • Upgrading to v5.0
    • New Features
      • Development Tools
      • Functional Changes
      • API Changes
      • Example Projects
      • Change Log
  • Fundamental Concepts
    • What is a Worker?
    • Important Terms
    • The Workers Main VI
      • Default Framework Cases
    • subWorker Types
    • Initialization Sequence
    • Shutdown Sequence
    • Priority Queue
    • Launcher VIs
  • Worker APIs
    • Overview
    • Local Requests
      • Creating Local Requests
    • Public Requests
      • Creating Public Requests
    • Public Requests w/Reply
      • Creating Public Requests w/Reply
    • Public Responses
      • Creating Public Responses
      • Registering Public Responses
    • Case Labels
    • Deleting API Items
  • Workers Tools
    • Workers Tools Menu
      • Create/Add Worker
        • Removing Workers
        • Creating Worker Templates
        • Troubleshooting
      • Workers Debug Server
        • Workers Application Manager
          • Right click menu
        • Worker Message Logs
          • Right click menu
        • Settings
        • Troubleshooting
      • Worker Call-Chain Viewer
      • Worker User Library
        • Config File Editor
      • RT Worker Convert
      • Public API Builder
        • Public Requests
        • Public Requests w/Reply
        • Public Responses
        • Override MHL Cases
      • Create Launcher VI
      • Create Worker Base Class
      • Change Inheritance
      • MHL Case Viewer
      • Change Worker Properties
    • Quickdrop Shortcuts
      • Show Private Data (Ctrl+0)
      • Create MHL Case tool (Ctrl+9)
      • Go To MHL Case (Ctrl+8)
  • Getting Started
    • Creating your first application
    • Example Projects
  • Legal
    • Disclaimer
    • Licenses
Powered by GitBook
On this page
  • Why develop with Workers ?
  • Develop in the style of the LabVIEW QMH template
  • Create application trees with reusable modules
  • Structured message flow with decoupled APIs
  • Create HALs using API abstractions
  • Workers 5.0 Introduction Presentation

Welcome to Workers for LabVIEW

Create asynchronous LabVIEW applications efficiently

NextUpgrading to v5.0

Last updated 10 months ago

Welcome to Workers for LabVIEW! Our mission is to provide you with a robust framework and the essential tools needed to efficiently create scalable asynchronous applications in LabVIEW.

Workers is based on the Queued Messenger Handler (QMH) design pattern, and a Workers QMH is designed to have the same look and style as the LabVIEW QMH template that ships with LabVIEW. Familiarity with this or with the 'Producer-Consumer' design pattern is recommended to comfortably start developing with the framework.

While being simplistic in its development style, Workers is also an Object Oriented (LVOOP) framework, allowing developers to develop their applications using inheritance, reducing the amount of re-work and duplicated code required by each modular QMH (called a Worker).

The Workers SDK provides you with a framework API, tools for creating and integrating Workers into multi-process applications, tools to create Worker APIs and HALs, and a debugger for runtime management on your local network. Workers applications can also be created and deployed on NI real-time embedded platforms (such as a CompactRIO).

This documentation will guide you through the framework's core concepts, Worker APIs, and development tools, helping to get you started developing with the framework as soon as possible.

Why develop with Workers ?

Develop in the style of the LabVIEW QMH template

This style is well-known in the LabVIEW community and is easy for both beginner and advanced developers to understand and work with. The framework allows you to create modules (called Workers) with each module's Main VI designed in the style of the LabVIEW QMH template, featuring a Message Handling Loop (mandatory) and an Event Handling Loop (optional).

Create application trees with reusable modules

Workers allows you to create reusable modules that plug together to form application trees. These application trees offer a structured, scalable architecture, and can be built from both statically-linked modules and dynamically loadable modules. The initialization and shutdown sequences of all modules are managed sequentially by the framework from the top to the bottom of the tree.

Structured message flow with decoupled APIs

Worker APIs can be created using the Workers development tools, allowing you to create Workers that are decoupled from their Callers. This makes each Worker highly reusable across projects, easier to test, and sharable with other developers. Asynchronous messages are exchanged between a Worker and its Caller as Requests (to a Worker) and Responses (to a Caller), providing structured message flow that is easy to follow and understand.

Create HALs using API abstractions

Sometimes you need to provide your applications with the flexibility to load interchangeable hardware drivers at run-time. API Abstractions can help you here, where in place of a concrete module, you instead use an API abstraction, and at run-time decide which implementation of the abstraction you want to load into your application. Thanks to the framework's foundational use of LVOOP, the Workers SDK allows you to create Worker HALs using the native architecture of the framework.

Workers 5.0 Introduction Presentation

Workers 5.0 was first presented and introduced to the LabVIEW community at the GLA Summit in March 2024. The video below is the recording of this PowerPoint presentation. This presentation introduces the Workers framework, while focusing on what's new in Workers 5.0, discussing how to create Worker APIs and how to create API Abstractions using the new Public API Builder tool.

Good to know

You do not need prior experience with LVOOP to start developing with Workers. The framework is designed to be user-friendly for developers without LVOOP knowledge. Start your first project and as you gain LVOOP skills, you can explore the advanced features of the framework, such as creating Hardware Abstraction Layers (HALs) and overriding framework API VIs.

GLA Summit 2024 - Introduction to Workers 5.0 Presentation
Worker A : Main.vi
Example Worker call-chain hierarchy of a Workers application
Message flow across a Workers application
Using a HAL in place of a concrete module allows you to load different hardware implementations at run-time