LabVIEW Wiki - User contributions [en]

ProjectItem

2026-02-25T23:09:50Z

Dnatt: Alphabetized list by Type String column (first column)

A '''Project Item''' is an individual item in a [[LabVIEW Project]], [[LabVIEW Project Library]], [[LabVIEW Class]], or [[XControl]]. A Project Item can be one of many types with an associated type GUID. The [[ProjectItem class]], [[ProjectItem class/Type String property|Type String Property]] can be used to get the ''Type String''. The [[ProjectItem class]], [[ProjectItem class/Type GUID property|Type GUID Property]] can be used to get the ''Type GUID''. In cases where no Type String exists the [[ProjectItem class/Type String property|Type String Property]] returns the Type GUID.

The ''Type String'' is used in the [[ProjectItem class]], [[ProjectItem class/Get All Descendents method|Get All Descendents method]] to get a filtered list of the Descendents by the inputted type. A list of valid ''Type Strings'' with associated ''Type GUIDs'' are listed below. (Add to this list as more are discovered.)

{| class="wikitable"
|-
! Type String
! Type GUID
! Description
|-
| Ability VI
| {DAABD3DA-4F44-4C3D-8BA3-E5D035A4F27A}
| Ability VI within an XControl or XNode
|-
| BeagleBone Black
|
| BeagleBone Black target (available with the [[LabVIEW LINX|LINX Toolkit]])
|-
| Build
| {0C750917-83D7-9871-8908-BB4ED6A8099B}
| Build Specifications node under every target
|-
| Class Private Data
| {64A9BF48-4C55-45DB-8F18-9C796DA0C113}
| Private Data Control inside a LabVIEW Class
|-
| Compact Vision System Target
|
| Real-Time Compact Vision System target
|-
| CompactRIO Ethernet Device
|
| Ethernet RIO target
|-
| CompactRIO Windows
|
| Windows CompactRIO target
|-
| cRIO Chassis
|
| CompactRIO Chassis under a cRIO RT target
|-
| Dependencies
| {0D75D917-83D7-9871-AA09-A0FFD6A8099B}
| Dependencies node under every target
|-
| Directives
|
| Directives items created for VIs by FPGA IP Builder
|-
| DLL
| {20A41099-3F2C-42C3-9544-7ABCC1E6CB0D}
| Shared Library (DLL) node under Build Specifications
|-
| Document
| {D60740D6-F255-4BBC-5675-8858F35B820E}
| Includes:
* Another [[LabVIEW Project]] [[LVLIB File Extension|''(*.lvproj)'']] file when nested inside of a Project
* [[ALIASES File Extension|Aliases ''(*.aliases)'']]
* [[LVLPS File Extension|Local Projects Settings ''(*.lvlps)'']]
* [[LabVIEW Library|LabVIEW Libraries]] [[LLB File Extension|''(*.llb)'']] (Depending on how it was added to the Project)
* [[Run-time Menu]] [[RTM File Extension| ''(*.rtm)'']]
* other Non-LabVIEW files, like images, text files, etc.
|-
| ECATEbusSlave
|
| EtherCAT slave device
|-
| ECATEnetSlave
|
| EtherCAT slave device
|-
| ECATMaster
|
| EtherCAT master device
|-
| Elemental IO
|
| IO Resource under an FPGA target
|-
| elvisRIO Chassis
|
| Chassis under an ELVIS RIO target
|-
| Embedded Vision System Target
|
| NI Embedded Vision System target
|-
|EXE
|{9A75366A-79D3-4BFD-9532-E3070185C1E8}
|Application (EXE) node under Build Specifications
|-
| Folder
| {D60740D6-F254-4BBC-5675-8858F35B820E}
| Includes:
* [[Auto-populating Folder]]s,
* [[Virtual Folder]]s
* [[LabVIEW Library|LabVIEW Libraries]] [[LLB File Extension|''(*.llb)'']] (Depending on how it was added to the Project)
|-
| FPGA Base Clock
|
| Base clock under an FPGA target
|-
| FPGA Component Level IP
|
| RIO DRAM
|-
| FPGA Derived Clock
|
| Derived clock under an FPGA target
|-
| FPGA FIFO
|
| FIFO node under an FPGA target
|-
| FPGA Generic Target
|
| Networked Computer/Device target
|-
| FPGA Memory Block
|
| Memory node under an FPGA target
|-
| FPGA Register
|{730535F4-F2D1-43C7-8D98-0EBD6BAE3470}
| Register item under an FPGA target
|-
| FPGA Target
|
| FPGA target (R-series device, cRIO target, etc.)
|-
|HTTP WebResources Container
|{CC977D9A-0BF1-470B-B5A7-DF1D00EF9C9B}
|Web Resources folder under a Web Service node
|-
| Hyperlink
| {CC472C20-0441-48DC-AF25-3E82ECC9376F}
|
|-
| IO Server
|
| I/O Server node under a target
|-
|Installer
|{B912C944-F9D3-49E7-B0A6-073ED50A150B}
|Installer node under Build Specifications
|-
| IP Builder Target
|
| IP Builder node under an FPGA target
|-
| Library
| {ABC740D6-F254-4BBC-5675-8858F35B820E}
| [[LabVIEW Project Library]] [[LVLIB File Extension|''(*.lvlib)'']]
|-
| LibraryData
| {AE832914-DFCB-471F-930C-C57747746FF2}
| Hidden ProjectItem that contains internal information about an LVStatechart library
|-
| Localhost
|
| In some projects with a Real-Time target, the 'My Computer' target will have a type of 'Localhost' instead of 'My Computer'.
|-
|LVClass
|{EFD740D6-F254-4BBC-5675-8858F35B820E}
|Includes: [[LabVIEW Class]] [[LVCLASS File Extension|''(*.lvclass)'']] and [[Interface (object-oriented programming)|Interfaces]]
|-
| LVLibp
| {CF31838A-5E97-4315-AE50-9EBA613BCBBB}
| [[Packed Project Library]] [[LVLIBP File Extension|''(*.lvlibp)'']]
|-
| LVStatechart
| {FB056C2C-833C-414C-8330-397F164A5211}
| [[LabVIEW StateChart]] [[LVSC File Extension|''(*.lvsc)'']]
|-
| LVStatechartVIItem
| {FB056C2D-833C-414C-8330-397F164A5211}
| Hidden ProjectItem that contains internal information about an LVStatechart library
|-
| Method VI
| {DAABD3DC-4F44-4C3D-8BA3-E5D035A4F27A}
| Method VI in an XControl
|-
| Module Container
|
| Real-Time Scan Resources node under an RT Chassis
|-
| My Computer
| {CEFE1B10-1732-4678-A70A-299293455410}
| My Computer node under the root Project
|-
| NI-DAQmx Channel
| {B5F05770-7C71-3A03-C9FB-F73F35629FC1}
| DAQmx Virtual Channel
|-
| NI-DAQmx Scale
| {BC977C97-1833-3D51-4EF6-D82E6838A8F3}
| DAQmx Scale
|-
|NI-DAQmx Task
|{0A806145-1BF3-3A50-0B5E-F969F56C8E2A}
|DAQmx Task
|-
| Packed Library
| {E4492117-CED3-4F31-9F8D-E2118AE04F12}
| Packed Library node under Build Specifications
|-
| Project
| {D60740D6-F254-4BBC-9975-8858F35B810E}
| Root project item at the top of the [[Project Explorer]] for the [[LabVIEW Project]]
|-
| Property Definition
| {81C68620-8BE3-4643-B04A-4E83AA6363D2}
| Property definition folder under a [[LabVIEW Class]]
|-
| Property Folder
| {D60740D6-F254-4BBC-5675-8858F35B820E}
| Property folder in an [[XControl]]
|-
| Property VI
| {DAABD3DB-4F44-4C3D-8BA3-E5D035A4F27A}
| Property VI in an [[XControl]]
|-
| Raspberry Pi 2 B
| {838AE6B2-6884-4111-A0FB-AF9B59F4094F}
| Raspberry Pi 2 B target (available with the [[LabVIEW LINX|LINX Toolkit]]). Includes Raspberry Pi 3 B+ and 4 B+
|-
| RIO C Series Module
|
| CompactRIO module that appears under the FPGA Target node under an RT CompactRIO target
|-
| RIO Subresource
|
| Resource under a RIO module. For example, an SD Card node.
|-
|Robotics Environment Simulator
|
|Simulated robot device
|-
| RT CDAQ Chassis
|
| Real-Time CompactDAQ Chassis target
|-
| RT CompactRIO
|
| RT CompactRIO target
|-
| RT Desktop
|
| Real-Time Desktop target
|-
| RT elvisRIO
|
| ELVIS RIO target
|-
| RT FlexRIO
|
| Real-Time FlexRIO target
|-
| RT Generic
|
| Generic RT Target
|-
| RT Industrial Controller
|
| Real-Time Industrial Controller target
|-
| RT myRIO
|
| myRIO target
|-
| RT PXI Chassis
|
| RT PXI Target
|-
| RT roboRIO
|
| roboRIO target
|-
| RT Single-Board RIO
|
| RT Single-Board RIO Target
|-
| sbRIO Chassis
|
| Single-Board RIO Chassis that appears under an RT Single-Board RIO target
|-
| Smart Camera Target
|
| Real-Time Industrial Smart Camera Target
|-
| Source Distribution
| {15DA4F9E-0591-4AB1-A339-C3B4D54902D8}
| Source Distribution node under Build Specifications
|-
| Startup VIs Container
| {F0D505FA-F9AD-43D8-8811-2F23BBC4C8A2}
| Startup VIs folder under a Web Service node
|-
| Target Folder
| {AB0740D6-F254-4BBC-5675-8858F35B820E}
|
|-
| TestItem
| {39B74B88-DF2D-4BA8-BEB5-FD65FC0FD56D}
| Test file from the Unit Test Framework [[LVTest File Extension| ''(.lvtest)'']]
|-
| TestVectorItem
| {50E0C210-38A2-420B-AB4E-3BEFFC710090}
| Test vector file from the Unit Test Framework [[LVTest File Extension| ''(.lvvect)'']]
|-
| TouchPanel
|
| Touch Panel target
|-
|Variable
|9BA597C5-4996-4622-B9BB-444431834D0D}
|Variable node under a library or a target. Includes shared variables, I/O Variables, and more.
|-
| VI
| {D60740D6-F254-4BBC-5675-8858F35B810E}
| Includes:
* [[VI]]s [[VI File Extension| ''(.vi)'']]
* [[CTL File Extension|Controls ''(*.ctl)'']]
* [[Polymorphic VI]]s
* [[Malleable VI]]s [[VIM File Extension| ''(.vim)'']]
* [[Global Variable]]s
* [[VI Template]]s [[VIT File Extension| ''(.vit)'']]
|-
| Web Service
| {2386AD17-A358-4EA9-86F1-7808B4D5B5ED}
| Web Service node
|-
| XControl
| {2E4BD3AC-4E04-45C9-B6C5-AD138962C435}
| [[XControl]]
|-
| XNode
| {35CAD751-77A8-4D0F-BF61-85A48475F6A5}
| [[XNode]]
|-
| Zip File
| {51F0E16F-7FA4-4E9F-AE30-C81D9D0444B0}
| Zip File node under Build Specifications
|-
| .NET Interop Assembly
| {0E6E9692-2CDC-4645-B4F6-93F9260BF6FA}
| .NET Interop Assembly node under Build Specifications
|-
|{117D6E82-86E4-4435-99C8-B638EE47B29E}
|{117D6E82-86E4-4435-99C8-B638EE47B29E}
|Real-Time Application node under Build Specifications (under a Raspberry Pi 2 B Target)
|-
| {69A947D5-514E-4E75-818E-69657C0547D8}
| {69A947D5-514E-4E75-818E-69657C0547D8}
| Real-Time Application node under Build Specifications (under an RT Target)
|-
| {9C5E1E31-72F0-41E9-9B17-FFBE4626F549}
| {9C5E1E31-72F0-41E9-9B17-FFBE4626F549}
| IP Build node under Build Specifications (under an IP Builder target)
|-
| {CED73189-3D7D-4B2F-B6C9-EA03FBC59E14}
| {CED73189-3D7D-4B2F-B6C9-EA03FBC59E14}
| Linux RT Package node under Build Specifications
|-
| {E661DAE2-7517-431F-AC41-30807A3BDA38}
| {E661DAE2-7517-431F-AC41-30807A3BDA38}
| Package node under Build Specifications
|-
| {F4C5E96F-7410-48A5-BB87-3559BC9B167F}
| {F4C5E96F-7410-48A5-BB87-3559BC9B167F}
| Compilation node under Build Specifications (under an FPGA target)
|}

[[Category:Project]]

LabVIEW Community Managed Discord Servers

2026-02-11T20:05:48Z

Dnatt: update LabVIEW Discord join link

The LabVIEW users community maintains a number of discord servers for discussion and organisation around community activity and events.

The table below contains links to join the servers (where appropriate) and information about the topics covered by each one.

{| class="wikitable"
| '''General''' ||
|-
| <imagemap> File:LabVIEWButton.png|96px|thumb|[https://discord.gg/labview Join LabVIEW Discord]</imagemap>|| General discussion related to LabVIEW, Test & Measurement and programming.
|-
| '''Event Related''' ||
|-
| <imagemap> File:DiscordIconGDEV.png|96px|thumb|[https://discord.gg/d5DNNE6rUb Join GDEV Con Europe ]</imagemap> || Attendee organisation and discussion before/during event and archived discussions from previous years conferences
|-
| <imagemap> File:DiscordIconsGDEVConNA.png|96px|thumb|[https://discord.gg/9TUFqVWTAN Join GDEV Con North America ]</imagemap> || Attendee organisation and discussion before/during event and archived discussions from previous years conferences (2023 & 2024)
|-
| <imagemap> File:DiscordIconsGDEVConNA2025.png|96px|thumb|[https://discord.gg/4yZjdbeaxd Join GDEV Con North America (2025) ]</imagemap> || Attendee organisation and discussion before/during/after the 2025 event
|-
| <imagemap> File:VIWeekIcon.png|96px|thumb| [https://discord.gg/a4WA8Bm Join VIWeek] </imagemap>|| Discussion of the [[VIWeek|VI Week]] 2020 event with a channel for each topic
|-
| <imagemap> File:DiscordIconsSummerOfLabVIEW96px.png|96px|thumb|[https://discord.gg/KxtUER4NGS Join Summer of LabVIEW ]</imagemap> || Support for participants of the [https://summeroflabview.com/ Summer of LabVIEW] challenges
|-
| <imagemap> File:DiscordIconAdventOfCode.png|96px|thumb|[https://discord.gg/AgKWURdGak Join Advent of Code ]</imagemap> || Chat with people participating in the Advent of Code challenges with LabVIEW and get access to the shared leader board
|-
| '''User Groups''' ||
|-
| <imagemap> File:DiscordIconsNordicsUsergroup.png|96px|thumb| [https://discord.gg/qNKWv6Uqtz Join Nordics LabVIEW User Group] </imagemap> || Organisation of User Groups in the Nordics Region
|-
| <imagemap> File:DiscordLabVIEWTurkeyy.png|96px|thumb| [https://join.slack.com/t/labviewtrkye/shared_invite/zt-2x22wiltw-FJoUHwDeXFahq5N2ixJ6Aw Join LabVIEW Turkiye User Group] </imagemap> || LabVIEW Turkiye User Groups
|-
| <imagemap> File: DiscordIconsFrenchUsergroup.png|96px|thumb| [https://discord.gg/VayzxJV2aq Join French LabVIEW User Group] </imagemap> || Organisation of French User Group
|-
| <imagemap> File:DiscordIconTheBusinessOfLabVIEW.png|96px|thumb| [https://discord.com/invite/4WrBygZdMf Join The Business of LabVIEW] </imagemap> || Discord Aimed at LabVIEW Consultants and those that sell software development services using NI products
|-
| '''Special Interest''' ||
|-
| <imagemap> File:DiscordIconAFGuild.png |96px|thumb|[https://discord.gg/vYFZ9Qzavs Join AF Guild]</imagemap> || Discussion focused on the Actor Framework and open source development of AF Tools. The [[AF Guild|Actor Framework Guild]] is a group of Actor Framework enthusiasts.
|-
| <imagemap> File:CommunityTrainingInitiativeLogo.png |96px|thumb| [https://discord.gg/f3prw5M4yJ Join Community Training Initiative]</imagemap> || Discussion for folks interested in the [https://www.gcentral.org/cti/ Community Training Initiative]
|-
| <imagemap> File:DiscordIconsNIOpenSource.png|96px|thumb|[https://discord.gg/q4d3ggrFVA Join NI Open Source] </imagemap>|| Discussion around NI's Initiative to make elements of the LabVIEW IDE and some Toolkits Open Source. Meet and co-ordinate with contributors, organise beta testing and get help with the process for contributing source code, opening issues and submitting feedback.
|-
| <imagemap> File:DiscordIconsVIPM.png|96px|thumb|[https://discord.gg/PqvffkFHCx Join VIPM Discord]</imagemap> || Discussion and support for VIPM Users and package builders/publishers on VIPM.io
|-
| <imagemap> File:DiscordIconsHampelSoftwareEngineering.png|96px|thumb| [https://discord.hampel-soft.com/ Join Hampel Software Engineering Open Source Code] </imagemap> || Discuss collaboration around Hampel Software Engineering's Open Source Code and Toolkits
|-
| <imagemap> File:DiscordIconsWovalabZulip.png|96px|thumb| [https://wovalab-open-source-projects.zulipchat.com/ Join Wovalab ] </imagemap> || Discuss collaboration around Wovalab's Open Source Code and Toolkits on their ZulipChat Server
|-
| <imagemap> File:DiscordIconsZyahSolutions.png|96px|thumb| [https://discord.gg/rA74hbtHTQ Join Zyah Solutions] </imagemap>|| Connect with Zyah Solutions
|-
| <imagemap> File:DiscordIconsLabVIEuler.png|96px|thumb| [https://discord.gg/XF2T45hMfp Join Project-LabVIEuler] </imagemap>|| Discuss solving the Project Euler series of challenging mathematical/computer programming problems with LabVIEW
|-
|}

[[Category:Communities]]

Tunnel Appearance

2025-11-11T00:13:48Z

Dnatt: minor wording edits

{| class="wikitable"
|+Loop Input Tunnels
!Tunnel Type
!Appearance
|-
|'''Non-indexing''' (for array types, the entire array enters the loop)
|[[File:Disabled indexing (normal).png|thumb]]
|-
|'''Indexing''' (for 1D array types, the array enters the loop one element at a time)
(for 2D array types, the array enters the loop one row at a time)
|[[File:Autoindexing Tunnel.png|thumb]]
|}
{| class="wikitable"
|+Loop Output Tunnels
!Tunnel Type
!Appearance
|-
|'''Indexing''' (for scalar elements, a 1D array of the elements is built up on the loop border)
(for 1D arrays, a 2D array of the rows is built up on the loop border)
|[[File:Output Indexing Tunnel.png|thumb]]
|-
|'''Last Value''' (the value generated by the last iteration of the loop is output by the tunnel)
|[[File:Last Value.png|thumb]]
|-
|'''Concatenating''' (for 1D arrays, the value generated by each loop iteration is concatenated onto the end of the previous value, resulting in a tunnel output of all the individual 1D arrays concatenated as a single 1D array)
|[[File:Concatenating.png|thumb]]
|-
|'''Conditional''' (for scalar elements and a ''Last Value'' tunnel, the tunnel will output the last value where a TRUE was wired to the conditional tunnel)
(for scalar elements and an ''Indexing'' tunnel, the tunnel will output a 1D array containing all loop iteration values where a TRUE was wired to the conditional tunnel)
|[[File:Conditional.png|thumb]]
|-
|'''Shift Register'''
|[[File:Shift Register.png|thumb]]
|}
{| class="wikitable"
|+Multi-frame Structure (Case, Event, Disable) Output Tunnels
!Tunnel Type
!Appearance
|-
|'''Linked Tunnels''' (when new frames are created, wires are automatically created between linked tunnels)
|[[File:Linked Input and Output.png|thumb]]
|-
|'''Use Default if Unwired''' (for frames that do not have a wire sourcing this output tunnel, the default value for its datatype will be used if that frame executes)
|[[File:Default if unwired.png|thumb]]
|}

Tunnel Appearance

2025-11-10T21:25:23Z

Dnatt: created page stub, will fill in details later

stub page... fill in details and graphics about the different tunnel types (last value, indexing, concatenating, conditional, etc.)

Heap Peek

2025-09-28T01:24:33Z

Dnatt: formatting

Heap Peek is a debug feature available at least since [[LabVIEW 3.0]]. It allows to view internal data structures created for all loaded VI files, including Front Panel Heap and Block Diagram Heap. The feature is intended for use by LV R&D, though users may in some cases be instructed by LV Support to check something there.

== Enabling Heap Peek ==

The Heap Peek keyboard shortcut is by default disabled in fresh installations of [[LabVIEW]]. To enable it:
* Close LabVIEW
* Put the key "LVdebugKeys=True" in your [[LabVIEW configuration file]]

Then, to launch the Heap Peek window:
* Open your VI
* Press one of the following key combinations, depending on your situation:
** (LabVIEW 2025 Q1 and earlier) Press '''Ctrl + Shift + D + H'''.
** (LabVIEW 2025 Q3 and later) Press '''Ctrl + Shift + : + H''' ''(that's a colon).''
** On Mac, use the ''Cmd'' key instead of ''Ctrl''.

== Using Heap Peek ==
[[File:HeapPeak.png]]

The window is divided into 5 sections:
* Loaded Container Files are in top-left,
* Heap View is top-right,
* Structure selection for info pane in middle-left,
* Toolbar at the middle,
* Information pane is at base.

The first section, as for usage flow, is top-left one. Start there, by left clicking to select the specific file and specific heap you want to look at.
When the heap is selected, you can display many details on it by clicking rows of either top-right or middle section. These details will show at base, in Information pane.

'''Note:''' Heap Peek only displays information and does not have any ability to change the objects. It does, however, display the locations in memory where the information is stored, which makes it easy to use external memory editing software for this purpose.

== Loaded Container Files list ==

The list is divided into Contexts. In each of these, you can see memory location of the item (within LabVIEW process memory), and entries marked ''BDHP'' or ''FPHP''.
* ''BDHP'' is Block Diagram Heap
* ''FPHP'' is Front Panel Heap

'''Note:''' There are [[VI|VIs]] in LV that are not real VIs (for example, a pseudo VI that is created to represent a Call By Reference to another application instance on another machine), and attempting to do Find to jump to their components can cause problems because those VIs never expect to actually draw themselves.

== Heap View ==

Heap, for LV, is really a [[Front Panel]] or [[Block Diagram]]. Despite the name, they don't really have a heap-like structure. Both FP and BD are stored in form of a tree, strongly inspired by [https://en.wikipedia.org/wiki/XML XML format]. The main difference is - the LV Heap format is binary, not text-based.

In ''Heap View'', Heaps are displayed in a flattened form, not in its full tree-like glory. Part of the entries show properties of the whole pane, and the rest is [[Control|controls]], [[Indicator|indicators]] and other elements added to the pane.

The view for ''FPHP'' reveals that controls and indicators are composed of several [[Control Parts|parts]] - ie. Numeric controls consist of: Label, Frame, Up/Down buttons, Edit field, Radix and Annex. Each [[Control_Parts#List_of_parts|part has partID]], which is used by LV to identify type of that part.

'''Note:''' To learn more about LV Heaps, consider [[Heap storage format|exporting a few to XML]], and looking at them there. The flat list visible in ''Heap View'' will be very helpful when you understand them, but it's not the best way to acquire that understanding.

== Structure selection ==

Here you can select one of the structures within VI files other than ''FPHP''/''BDHP''. These are per-file, not per-heap - so you won't find any difference in them if you select different part of the same file in Loaded Container Files list.

The selectable options are:
* ''VI Fields'' - lists values of many common settings and flags of the VI file
* ''DS Fields'' - lists Data Space properties, including Table of QEs and Table of TMEs
* ''OH Fields''
* ''Stats'' - statistics for objects used within Heaps
* ''Link Info'' - content of all LinkObj lists
* ''Names In Memory''
* ''IL Code Stream'' - Prints Intermediate Language Code used during code compilation process
* ''Code Disassembly'' - Prints assembly generated by the compiler for given VI file
* ''Transform Metrics''
* ''UDClass Info''
* ''Full OMUDClassPtr List''
* ''Available Implementers''

=== DS Fields ===

[[Data Space]] in an important concept in LV internals. In short, ''Data Space'' contains filling for all type mapped [[data type]]s. Be sure to read more on [[Data Space]] to understand it better.

The ''DS Fields'' section contains some general information on [[Data Space]] of the file, and then displays whole mapping of the Data Space (''DSTM''). As of LV2014 it doesn't show values stored in data space, but it shows offsets within said Data Space, and Type Map Entries ('''TME'''s) with information about which data type is stored there, with all its properties. The ''DSTM'' data in this section is cut to only show part of Data Space which is used for different purposes than Heap - the complete Data Space is always larger.

== Toolbar ==

The toolbar consists of several fields.
* Next/prev buttons
* Currently selected item name text
* '''U''' button
* '''F''' button - Click on it to find the object selected in Heap View. LabVIEW will switch to the block diagram or front panel and select related object.
* '''uo''' button - Toggles between sorting the list on the right by UID (the default) or by memory address.

'''Note:''' A previous author said that few developers really know the capacities of heap peek. This is true... it's a debugging tool, and it gets hacked up to debug whatever anyone needs to debug.

[[Category:LabVIEW internals]]
[[Category:Debugging]]

Heap Peek

2025-09-28T01:24:08Z

Dnatt: formatting

Heap Peek is a debug feature available at least since [[LabVIEW 3.0]]. It allows to view internal data structures created for all loaded VI files, including Front Panel Heap and Block Diagram Heap. The feature is intended for use by LV R&D, though users may in some cases be instructed by LV Support to check something there.

== Enabling Heap Peek ==

The Heap Peek keyboard shortcut is by default disabled in fresh installations of [[LabVIEW]]. To enable it:
* Close LabVIEW
* Put the key "LVdebugKeys=True" in your [[LabVIEW configuration file]]

Then, to launch the Heap Peek window:
* Open your VI
* Press one of the following key combinations, depending on your situation:
** (LabVIEW 2025 Q1 and earlier) Press '''Ctrl + Shift + D + H'''.
** (LabVIEW 2025 Q3 and later) Press '''Ctrl + Shift + : + H''' ''(that's a colon).''
** On Mac, use the ''Cmd'' key instead of ''Ctrl''. This will open the Heap Peek window.

== Using Heap Peek ==
[[File:HeapPeak.png]]

The window is divided into 5 sections:
* Loaded Container Files are in top-left,
* Heap View is top-right,
* Structure selection for info pane in middle-left,
* Toolbar at the middle,
* Information pane is at base.

The first section, as for usage flow, is top-left one. Start there, by left clicking to select the specific file and specific heap you want to look at.
When the heap is selected, you can display many details on it by clicking rows of either top-right or middle section. These details will show at base, in Information pane.

'''Note:''' Heap Peek only displays information and does not have any ability to change the objects. It does, however, display the locations in memory where the information is stored, which makes it easy to use external memory editing software for this purpose.

== Loaded Container Files list ==

The list is divided into Contexts. In each of these, you can see memory location of the item (within LabVIEW process memory), and entries marked ''BDHP'' or ''FPHP''.
* ''BDHP'' is Block Diagram Heap
* ''FPHP'' is Front Panel Heap

'''Note:''' There are [[VI|VIs]] in LV that are not real VIs (for example, a pseudo VI that is created to represent a Call By Reference to another application instance on another machine), and attempting to do Find to jump to their components can cause problems because those VIs never expect to actually draw themselves.

== Heap View ==

Heap, for LV, is really a [[Front Panel]] or [[Block Diagram]]. Despite the name, they don't really have a heap-like structure. Both FP and BD are stored in form of a tree, strongly inspired by [https://en.wikipedia.org/wiki/XML XML format]. The main difference is - the LV Heap format is binary, not text-based.

In ''Heap View'', Heaps are displayed in a flattened form, not in its full tree-like glory. Part of the entries show properties of the whole pane, and the rest is [[Control|controls]], [[Indicator|indicators]] and other elements added to the pane.

The view for ''FPHP'' reveals that controls and indicators are composed of several [[Control Parts|parts]] - ie. Numeric controls consist of: Label, Frame, Up/Down buttons, Edit field, Radix and Annex. Each [[Control_Parts#List_of_parts|part has partID]], which is used by LV to identify type of that part.

'''Note:''' To learn more about LV Heaps, consider [[Heap storage format|exporting a few to XML]], and looking at them there. The flat list visible in ''Heap View'' will be very helpful when you understand them, but it's not the best way to acquire that understanding.

== Structure selection ==

Here you can select one of the structures within VI files other than ''FPHP''/''BDHP''. These are per-file, not per-heap - so you won't find any difference in them if you select different part of the same file in Loaded Container Files list.

The selectable options are:
* ''VI Fields'' - lists values of many common settings and flags of the VI file
* ''DS Fields'' - lists Data Space properties, including Table of QEs and Table of TMEs
* ''OH Fields''
* ''Stats'' - statistics for objects used within Heaps
* ''Link Info'' - content of all LinkObj lists
* ''Names In Memory''
* ''IL Code Stream'' - Prints Intermediate Language Code used during code compilation process
* ''Code Disassembly'' - Prints assembly generated by the compiler for given VI file
* ''Transform Metrics''
* ''UDClass Info''
* ''Full OMUDClassPtr List''
* ''Available Implementers''

=== DS Fields ===

[[Data Space]] in an important concept in LV internals. In short, ''Data Space'' contains filling for all type mapped [[data type]]s. Be sure to read more on [[Data Space]] to understand it better.

The ''DS Fields'' section contains some general information on [[Data Space]] of the file, and then displays whole mapping of the Data Space (''DSTM''). As of LV2014 it doesn't show values stored in data space, but it shows offsets within said Data Space, and Type Map Entries ('''TME'''s) with information about which data type is stored there, with all its properties. The ''DSTM'' data in this section is cut to only show part of Data Space which is used for different purposes than Heap - the complete Data Space is always larger.

== Toolbar ==

The toolbar consists of several fields.
* Next/prev buttons
* Currently selected item name text
* '''U''' button
* '''F''' button - Click on it to find the object selected in Heap View. LabVIEW will switch to the block diagram or front panel and select related object.
* '''uo''' button - Toggles between sorting the list on the right by UID (the default) or by memory address.

'''Note:''' A previous author said that few developers really know the capacities of heap peek. This is true... it's a debugging tool, and it gets hacked up to debug whatever anyone needs to debug.

[[Category:LabVIEW internals]]
[[Category:Debugging]]

Heap Peek

2025-09-28T01:21:54Z

Dnatt: Added new Heap Peak shortcut info for LabVIEW 2025 Q3 and later.

Heap Peek is a debug feature available at least since [[LabVIEW 3.0]]. It allows to view internal data structures created for all loaded VI files, including Front Panel Heap and Block Diagram Heap.
The feature is intended for use by LV R&D, though users may in some cases be instructed by LV Support to check something there.

== Enabling Heap Peek ==

The Heap Peek keyboard shortcut is by default disabled in fresh installations of [[LabVIEW]]. To enable it:
* Close LabVIEW
* Put the key "LVdebugKeys=True" in your [[LabVIEW configuration file]]

Then, to launch the Heap Peek window:
* Open your VI
* (LabVIEW 2025 Q1 and earlier) Press '''Ctrl + Shift + D + H'''. (LabVIEW 2025 Q3 and later) Press '''Ctrl + Shift + : + H''' ''(that's a colon).'' On Mac, use the ''Cmd'' key instead of ''Ctrl''. This will open the Heap Peek window.

== Using Heap Peek ==
[[File:HeapPeak.png]]

The window is divided into 5 sections:
* Loaded Container Files are in top-left,
* Heap View is top-right,
* Structure selection for info pane in middle-left,
* Toolbar at the middle,
* Information pane is at base.

The first section, as for usage flow, is top-left one. Start there, by left clicking to select the specific file and specific heap you want to look at.
When the heap is selected, you can display many details on it by clicking rows of either top-right or middle section. These details will show at base, in Information pane.

'''Note:''' Heap Peek only displays information and does not have any ability to change the objects. It does, however, display the locations in memory where the information is stored, which makes it easy to use external memory editing software for this purpose.

== Loaded Container Files list ==

The list is divided into Contexts. In each of these, you can see memory location of the item (within LabVIEW process memory), and entries marked ''BDHP'' or ''FPHP''.
* ''BDHP'' is Block Diagram Heap
* ''FPHP'' is Front Panel Heap

'''Note:''' There are [[VI|VIs]] in LV that are not real VIs (for example, a pseudo VI that is created to represent a Call By Reference to another application instance on another machine), and attempting to do Find to jump to their components can cause problems because those VIs never expect to actually draw themselves.

== Heap View ==

Heap, for LV, is really a [[Front Panel]] or [[Block Diagram]]. Despite the name, they don't really have a heap-like structure. Both FP and BD are stored in form of a tree, strongly inspired by [https://en.wikipedia.org/wiki/XML XML format]. The main difference is - the LV Heap format is binary, not text-based.

In ''Heap View'', Heaps are displayed in a flattened form, not in its full tree-like glory. Part of the entries show properties of the whole pane, and the rest is [[Control|controls]], [[Indicator|indicators]] and other elements added to the pane.

The view for ''FPHP'' reveals that controls and indicators are composed of several [[Control Parts|parts]] - ie. Numeric controls consist of: Label, Frame, Up/Down buttons, Edit field, Radix and Annex. Each [[Control_Parts#List_of_parts|part has partID]], which is used by LV to identify type of that part.

'''Note:''' To learn more about LV Heaps, consider [[Heap storage format|exporting a few to XML]], and looking at them there. The flat list visible in ''Heap View'' will be very helpful when you understand them, but it's not the best way to acquire that understanding.

== Structure selection ==

Here you can select one of the structures within VI files other than ''FPHP''/''BDHP''. These are per-file, not per-heap - so you won't find any difference in them if you select different part of the same file in Loaded Container Files list.

The selectable options are:
* ''VI Fields'' - lists values of many common settings and flags of the VI file
* ''DS Fields'' - lists Data Space properties, including Table of QEs and Table of TMEs
* ''OH Fields''
* ''Stats'' - statistics for objects used within Heaps
* ''Link Info'' - content of all LinkObj lists
* ''Names In Memory''
* ''IL Code Stream'' - Prints Intermediate Language Code used during code compilation process
* ''Code Disassembly'' - Prints assembly generated by the compiler for given VI file
* ''Transform Metrics''
* ''UDClass Info''
* ''Full OMUDClassPtr List''
* ''Available Implementers''

=== DS Fields ===

[[Data Space]] in an important concept in LV internals. In short, ''Data Space'' contains filling for all type mapped [[data type]]s. Be sure to read more on [[Data Space]] to understand it better.

The ''DS Fields'' section contains some general information on [[Data Space]] of the file, and then displays whole mapping of the Data Space (''DSTM''). As of LV2014 it doesn't show values stored in data space, but it shows offsets within said Data Space, and Type Map Entries ('''TME'''s) with information about which data type is stored there, with all its properties. The ''DSTM'' data in this section is cut to only show part of Data Space which is used for different purposes than Heap - the complete Data Space is always larger.

== Toolbar ==

The toolbar consists of several fields.
* Next/prev buttons
* Currently selected item name text
* '''U''' button
* '''F''' button - Click on it to find the object selected in Heap View. LabVIEW will switch to the block diagram or front panel and select related object.
* '''uo''' button - Toggles between sorting the list on the right by UID (the default) or by memory address.

'''Note:''' A previous author said that few developers really know the capacities of heap peek. This is true... it's a debugging tool, and it gets hacked up to debug whatever anyone needs to debug.

[[Category:LabVIEW internals]]
[[Category:Debugging]]

Compiled object cache

2025-05-16T17:56:42Z

Dnatt: Created page with "The [https://www.ni.com/docs/en-US/bundle/labview/page/compiled-object-cache.html Compiled Object Cache] is the location where LabVIEW stores the compiled code for VIs. If you are having problems with loading/running/building your LabVIEW code, and you suspect the compiled object cache may be involved, you can use the [https://www.ni.com/docs/en-US/bundle/labview-api-ref/page/project/viobjcache-dialog.html Clear Compiled Object Cache] dialog box to clear some parts of th..."

The [https://www.ni.com/docs/en-US/bundle/labview/page/compiled-object-cache.html Compiled Object Cache] is the location where LabVIEW stores the compiled code for VIs. If you are having problems with loading/running/building your LabVIEW code, and you suspect the compiled object cache may be involved, you can use the [https://www.ni.com/docs/en-US/bundle/labview-api-ref/page/project/viobjcache-dialog.html Clear Compiled Object Cache] dialog box to clear some parts of the compiled object cache, which will cause LabVIEW to recompile any VIs that were previously in the cache when they are loaded in the future.

There are multiple compiled object caches on your machine:

* '''App Builder Cache''' - This cache contains the compiled code for VIs that are built into EXEs, PPLs, and other build outputs. The cache is located here: ''[LabVIEW Data]\AppBuilderCache\[version]''

* '''Core LabVIEW Cache''' - This cache contains the compiled code for VIs that are inside the ''[LabVIEW 20xx]'' folder on disk. This includes core APIs that ship with LabVIEW, VI-based features of LabVIEW, VIPM toolkits that install in ''user.lib'' or ''vi.lib'', etc. This cache is located here: ''[LabVIEW 20xx]\VIObjCache''

* '''User + LVAddons Cache''' - This cache contains the compiled code for VIs that are part of your source code. Additionally, it also contains compiled code for any drivers, toolkits, or addons that are installed in the ''[LVAddons]'' folder. This cache is located here: ''[LabVIEW Data]\VIObjCache\[version]''.

Note that the Clear Compiled Object Cache dialog allows you to clear the App Builder Cache *and* any of your compiled source code from the User + LVAddons Cache. There is no interactive way to clear the cache for the Core LabVIEW Cache, or for ''[LVAddons]'' code in the User + LVAddons Cache. You can manually delete the contents of the folders above to clear those caches. '''Note''': After you do this, the LabVIEW editor will be extremely slow in loading APIs and VI-based features that need to recompile. You should only clear these caches as a last resort when debugging issues with LabVIEW. Another option is to repair the LabVIEW installation, which will also regenerate these caches.

Events

2025-01-06T21:05:23Z

Dnatt: Updated 2025 events

{| class="wikitable" style="width: 75%; margin:auto;"
! colspan=2 style="background-color:#616366; font-size:200%; border:none; margin:0; padding:.3em; color:#FFD500; text-align:center;" | Community Calendar
|-
! style="background-color:#FFD500; border:none; margin:0; color:#000000; text-align:center;" | '''Do you want your event added to the Community Calendar?'''
| rowspan=2 style="text-align:center; width:75%;background-color:#FFFFFF;"| {{#widget:Google Calendar}}
|-
| style="width:25%; vertical-align:top;" | To get your event on the calendar:
# Create Meeting Invitation
# Invite the LabVIEWWiki as a guest
The email address is:
<div style="text-align:center;">'''''labviewwiki -at- gmail -dot- com'''''</div>
<div style="font-size:75%; text-align:center;">(written this way to avoid the spammers)</div>
Be sure to include event details such as:
* Event Title
* Dates and Times
* How to register or rsvp if required
* Where the event is located or how to connect if virtual
* Any other details (abstract/topic, links to websites, etc.)
|}

{| class="wikitable" style="width: 75%; margin:auto;"
! colspan=2 style="background-color:#616366; font-size:200%; border:none; margin:0; padding:.3em; color:#FFD500; text-align:center;" | Event Pages
|-
! style="background-color:#616366; color:#FFD500; text-align:center;" | '''Event Archive'''
! style="background-color:#616366; color:#FFD500; text-align:center;" | '''Upcoming Events'''
|-
| rowspan = 5 style="width:25%; vertical-align:top; background-color:#EFEFEF;" | {{#tree:
*{"expanded":true}[[Americas CLA Summit]]
**[[Americas CLA Summit 2015]]
**[[Americas CLA Summit 2016]]
**[[Americas CLA Summit 2017]]
**[[Americas CLA Summit 2018]]
**[[Americas CLA Summit 2019]]
*{"expanded":true}[[European CLA Summit]]
**[[European CLA Summit 2018]]
**[[European CLA Summit 2019]]
*{"expanded":true}[[GDevCon]]
**[[GDevCon-1|GDevCon #1]]
**[[GDevCon-2|GDevCon #2]]
**[[GDevCon-3|GDevCon #3]]
**[[GDevCon-4|GDevCon #4]]
**[[GDevCon-5|GDevCon #5]]
*{"expanded":true}[[GDevCon ANZ]]
**[[GDevCon ANZ 1|GDevCon ANZ #1]]
**[[GDevCon ANZ 2|GDevCon ANZ #2]]
*{"expanded":true}[[GDevCon North America]]
**[[GDevCon North America 2021]]
**[[GDevCon North America 2022]]
**[[GDevCon North America 2023]]
**[[GDevCon North America 2024]]
*{"expanded":true}[[GLA Summit]]
**[[GLA Summit 2020]]
**[[GLA Summit 2021]]
**[[GLA Summit 2022]]
**[[GLA Summit 2024]]
*{"expanded":true}[[LUGE]]
**[[LUGE 2020]]
**[[LUGE 2021]]
**[[LUGE 2022]]
*{"expanded":true}[[NI Connect]]
**[[NI Connect 2021]]
**[[NI Connect 2022]]
**[[NI Connect 2023]]
**[[NI Connect 2024]]
*{"expanded":true}NIDays
**[[NIDays 2019]]
*{"expanded":true}[[NIWeek]]
**[[NIWeek 1995]]
**[[NIWeek 1996]]
**[[NIWeek 1997]]
**[[NIWeek 1998]]
**[[NIWeek 1999]]
**[[NIWeek 2000]]
**[[NIWeek 2001]]
**[[NIWeek 2002]]
**[[NIWeek 2003]]
**[[NIWeek 2004]]
**[[NIWeek 2005]]
**[[NIWeek 2006]]
**[[NIWeek 2007]]
**[[NIWeek 2008]]
**[[NIWeek 2009]]
**[[NIWeek 2010]]
**[[NIWeek 2011]]
**[[NIWeek 2012]]
**[[NIWeek 2013]]
**[[NIWeek 2014]]
**[[NIWeek 2015]]
**[[NIWeek 2016]]
**[[NIWeek 2017]]
**[[NIWeek 2018]]
**[[NIWeek 2019]]
*{"expanded":true}[[VIWeek]]
**[[VIWeek 2020]]
}}
| style="width:75%;background-color:#FFFFFF;vertical-align:top;" | <gallery class="center" heights="90" widths="90" style="text-align:center">
File:NIButton.png|[https://www.ni.com/en/events/niconnect.html NI Connect 2025 (Fort Worth, TX--April 28-30 2025)]
File:GDevCon-ANZButton.png|link=GDevCon_ANZ_2|[[GDevCon ANZ 2|GDevCon ANZ #2 (Lindfield, Australia--May 27-28 2025)]]
File:GLASummitButton.png|[https://www.glasummit.org/ GLA Summit 2025 (Jun 23-24 2025)]
File:GDevCon-NAButton.png|[https://www.gdevconna.org/ GDevCon NA #5 (Chicago, IL--July 22-24, 2025)]
File:GDevConButton.png|[https://www.gdevcon.com/ GDevCon #6 (Brighton, UK--Sept 9-11 2025)]
</gallery>
|-
! style="background-color:#616366; color:#FFD500; text-align:center;" | '''Recurring Events'''
|-
| style="width:75%;background-color:#FFFFFF;vertical-align:top;" | <gallery class="center" heights=90px widths=90px style="text-align:center">
File:LVAoC.png|link=Advent of Code|[[Advent of Code|Advent of Code (December)]]
File:Summer_of_LabVIEW_logo.png|link=Summer of LabVIEW|[[Summer of LabVIEW|Summer of LabVIEW (June, July, August)]]
</gallery>
|-
| style="background-color:#616366; color:#FFD500; text-align:center;" | '''Past Events'''
|-
| style="width:75%;background-color:#FFFFFF;vertical-align:top;" | <gallery class="center" heights="90" widths="90" style="text-align:center">
File:GDevConButton.png|[https://labviewwiki.org/wiki/GDevCon-5 GDevCon #5 (Stuttgart 11-13 September 2024)]
File:GDevCon-NAButton.png|link=GDevCon_North_America_2024|[[GDevCon North America 2024|GDevCon North America 2024 (23-25 July 2024)]]
File:NIButton.png|link=NI_Connect_2024|[[NI Connect 2024|NI Connect 2024 (Austin—20-22 May 2024)]]
File:GLASummitButton.png|link=GLA_Summit_2024|[[GLA Summit 2024|GLA Summit 2024 (25-26 March 2024)]]
File:GDevCon-ANZButton.png|link=GDevCon_ANZ_1|[[GDevCon ANZ 1|GDevCon ANZ #1 (24-25 October 2023)]]
File:GDevConButton.png|link=GDevCon-4|[[GDevCon-4|GDevCon #4 (Glasgow—20-21 September 2023)]]
File:GDevCon-NAButton.png|link=GDevCon_North_America_2023|[[GDevCon North America 2023|GDevCon North America 2023 (18-20 July 2023)]]
File:NIButton.png|link=NI_Connect_2023|[[NI Connect 2023|NI Connect 2023 (Austin—23-24 May 2023)]]
File:NIButton.png|link=NI_Connect_2022|[[NI Connect 2022|NI Connect 2022 (Munich— 9 November 2022)]]
File:GLASummitButton.png|link=GLA_Summit_2022|[[GLA Summit 2022|GLA Summit 2022 (14-15 November 2022)]]
File:NIButton.png|link=NI_Connect_2022|[[NI Connect 2022|NI Connect 2022 (Shanghai— 2023 TBD)]]
File:GDevConButton.png|link=GDevCon-3|[[GDevCon-3|GDevCon #3 (Amsterdam—8-9 September 2022)]]
File:GDevCon-NAButton.png|link=GDevCon_North_America_2022|[[GDevCon North America 2022|GDevCon North America 2022 (19-21 July 2022)]]
File:NIButton.png|link=NI_Connect_2022|[[NI Connect 2022|NI Connect 2022 (Austin—24-25 May 2022)]]
File:LUGE.png|link=LUGE_2022|[[LUGE 2022|LUGE 2022 (??? 2022)]]
File:GLASummitButton.png|link=GLA_Summit_2021|[[GLA Summit 2021|GLA Summit 2021 (15-16 November 2021)]]
File:GDevCon-NAButton.png|link=GDevCon_North_America_2021|[[GDevCon North America 2021|GDevCon North America 2021 (20-21 October 2021)]]
File:NIButton.png|link=NI_Connect_2021|[[NI Connect 2021|NI Connect 2021 (27-28 July 2021)]]
File:LUGE.png|link=LUGE_2021|[[LUGE 2021|LUGE 2021 (??? 2021)]]
File:GLASummitButton.png|link=GLA_Summit_2020|[[GLA Summit 2020|GLA Summit 2020 (9-10 November 2020)]]
File:VIWeekIcon.png|link=VIWeek_2020|[[VIWeek 2020|VIWeek 2020 (17-23 May 2020)]]
File:LUGE.png|link=LUGE_2020|[[LUGE 2020|LUGE 2020 (7 May 2020)]]
File:CLA-AButton.png|link=Americas_CLA_Summit_2019|[[Americas CLA Summit 2019|Americas CLA Summit 2019 (25-27 Sept 2019)]]
File:GDevConButton.png|link=GDevCon-2|[[GDevCon-2|GDevCon #2 (21-22 Aug 2019)]]
File:NIEagleButton.png|link=NIWeek_2019|[[NIWeek 2019|NIWeek 2019 (20-23 May 2019)]]
File:CLA-EButton.png|link=European_CLA_Summit_2019|[[European CLA Summit 2019|European CLA Summit 2019 (2-4 Apr 2019)]]
File:CLA-AButton.png|link=Americas_CLA_Summit_2018|[[Americas CLA Summit 2018]]
File:GDevConButton.png|link=GDevCon-1|[[GDevCon-1|GDevCon #1 (4-5 Sep 2018)]]
File:CLA-EButton.png|link=European_CLA_Summit_2018|[[European CLA Summit 2018]]
File:NIEagleButton.png|link=NIWeek_2018|[[NIWeek 2018|NIWeek 2018 (21-24 May 2018)]]
File:CLA-AButton.png|link=Americas_CLA_Summit_2017|[[Americas CLA Summit 2017]]
File:NIEagleButton.png|link=NIWeek_2017|[[NIWeek 2017|NIWeek 2017 (22-25 May 2017)]]
File:NIEagleButton.png|link=NIWeek_2016|[[NIWeek 2016|NIWeek 2016 (1-4 Aug 2016)]]
File:CLA-AButton.png|link=Americas_CLA_Summit_2016|[[Americas CLA Summit 2016]]
File:NIEagleButton.png|link=NIWeek_2015|[[NIWeek 2015|NIWeek 2015 (3-6 Aug 2015)]]
File:CLA-AButton.png|link=Americas_CLA_Summit_2015|[[Americas CLA Summit 2015|Americas CLA Summit 2015 (2-5 March 2015)]]
File:NIEagleButton.png|link=NIWeek_2014|[[NIWeek 2014|NIWeek 2014 (4-7 Aug 2014)]]
File:NIEagleButton.png|link=NIWeek_2013|[[NIWeek 2013|NIWeek 2013 (5-8 Aug 2013)]]
File:NIEagleButton.png|link=NIWeek_2012|[[NIWeek 2012|NIWeek 2012 (6-9 Aug 2012)]]
File:NIEagleButton.png|link=NIWeek_2011|[[NIWeek 2011|NIWeek 2011 (2-4 Aug 2011)]]
File:NIEagleButton.png|link=NIWeek_2010|[[NIWeek 2010|NIWeek 2010 (3-5 Aug 2010)]]
File:NIEagleButton.png|link=NIWeek_2009|[[NIWeek 2009|NIWeek 2009 (4-6 Aug 2009)]]
File:NIEagleButton.png|link=NIWeek_2008|[[NIWeek 2008|NIWeek 2008 (5-7 Aug 2008)]]
File:NIEagleButton.png|link=NIWeek_2007|[[NIWeek 2007|NIWeek 2007 (7-9 Aug 2007)]]
File:NIEagleButton.png|link=NIWeek_2006|[[NIWeek 2006|NIWeek 2006 (8-10 Aug 2006)]]
File:NIEagleButton.png|link=NIWeek_2005|[[NIWeek 2005|NIWeek 2005 (16-18 Aug 2005)]]
File:NIEagleButton.png|link=NIWeek_2004|[[NIWeek 2004|NIWeek 2004 (17-19 Aug 2004)]]
File:NIEagleButton.png|link=NIWeek_2003|[[NIWeek 2003|NIWeek 2003 (13-15 Aug 2003)]]
File:NIEagleButton.png|link=NIWeek_2002|[[NIWeek 2002|NIWeek 2002 (14-16 Aug 2002)]]
File:NIEagleButton.png|link=NIWeek_2001|[[NIWeek 2001|NIWeek 2001 (2001)]]
File:NIEagleButton.png|link=NIWeek_2000|[[NIWeek 2000|NIWeek 2000 (2000)]]
File:NIEagleButton.png|link=NIWeek_1999|[[NIWeek 1999|NIWeek 1999 (18-20 Aug 1999)]]
File:NIEagleButton.png|link=NIWeek_1998|[[NIWeek 1998|NIWeek 1998 (25-27 Aug 1998)]]
File:NIEagleButton.png|link=NIWeek_1997|[[NIWeek 1997|NIWeek 1997 (19-21 Aug 1997)]]
File:NIEagleButton.png|link=NIWeek_1996|[[NIWeek 1996|NIWeek 1996 (6-8 Aug 1996)]]
File:NIEagleButton.png|link=NIWeek_1995|[[NIWeek 1995|NIWeek 1995 (1995)]]
</gallery>
|}

[[Category:Events]]

Style Guide

2024-12-05T22:00:44Z

Dnatt: fixed a bug in the connector pane section

{{TOCright}}

The following guidelines are provided as a reference for LabVIEW development. Individuals and organizations are encouraged to cater these to best serve their needs and preferences.

= Organization and Names of Files =
The following guidance is applicable to all the items and artifacts that are contained within a LabVIEW Project, including VIs and containers such as Projects, Libraries, and Classes.

== Organize all files logically ==

You should organize directories and files so that someone with a reasonable skill level is able to navigate the directory structure.

If you are consistently working on similar projects, you may want to come up with standards for your projects. The authors of this Guide have seen several different and reasonable directory organizations that were appropriate for different projects, which is why this Guide isn't detailed on this topic.

== Naming Files and Directories ==

''' Choose names so they are easy to read and describe the purpose of the file or directory '''

- Create names that describe the purpose of the file or directory.
- Use full words except where an abbreviation is well known by the intended audience, such as "USB Port" for "Universal Serial Bus Port".
- Use book title case with single space characters between words.
- You may use dashes in situations where dashes are ordinarily used, such as for “Real-Time”.
- Make sure those names work in all relevant platforms.

''Details:''
Refer to Appendix A: Book Title Case for definition and examples.

''' Windows file path length limitation '''
When coming up with file and directory names, keep in mind the Windows file path length limitation of 260 characters.

''' Avoid special characters in file names '''
For greatest cross-platform compatibility and to simplify reading of file names, avoid the use of special characters in file names such as:

* File separators like : (colon) / (forward-slash) \ (backward-slash).
* Symbols like ¢™$®.
* Punctuation marks, parentheses, quotation marks, brackets, and operators like . , [ ] { } ( ) ! ; " ' * ? < > |.
* White space characters such as tabs, new lines, and embedded returns. Note: Spaces are acceptable for most applications.

''' Do not use camel-case, Pascal-case, or underscore characters for separation of adjacent words '''

''Bad:''
- GRTC.lvproject
- GenRTCntrl.lvproj

''Good:''
- GenericRealTimeControl.lvproj
- Generic Real-Time Control.lvproj
- ExitAllOnErr.vi
- Exit All on Error.vi

''' Use names of control VIs as labels '''
Use names of control VIs as labels for corresponding controls. For example, use the label ''alarm boolean'' as the label in Alarm Boolean.ctl.

''' Name polymorphic VI instances '''
Name polymorphic VI instances by using space-dash-space between the poly VI name and the specific instance designation. For example, if the poly VI is called Read My Special File.vi, then an instance VI may be called Read My Special File - I32.vi.

''' File and Directory Names for Examples, Templates, and Sample Projects '''
This subsection applies to the examples, templates, and sample projects installed in relevant directories within the LabVIEW directory structure.

'''= Do not include the word "example" in any file or folder names '''=

'''= Add a prefix to all example names when developing for a specific driver or addon '''=
Use the form `<Short Product Name><space><Example Name>`. E.g., NI-DAQmx Voltage - Continuous Input.vi.

'''= Avoid deeply nested file folders '''=
Ensure that none of your project’s file folders on disk are too deeply nested. If the user’s project contains a file with a path that exceeds 260 characters in length (for Windows), the project copy will fail. Aim for having a maximum path length of less than 150 characters so there is plenty of room to account for a user saving their project in a deeply-nested path.

'''= Name your .lvproj file the same as the folder that contains it '''=
For templates and sample projects, name your .lvproj file the same as the folder that contains it, e.g., the “PC USRP-RIO Streaming” template folder contains “PC USRP-RIO Streaming.lvproj”.

== Project Organization ==

''' Place the top-level VIs for the project directly under appropriate targets '''
Place the top-level VIs directly under the appropriate targets. Because you cannot mark a VI as a top-level VI, placing the top-level VIs under the corresponding target helps clarify which VIs are top-level.

''' Organize VIs in a hierarchical directory '''
Organize VIs in a hierarchical directory with easily accessible top-level VIs and subVIs in subdirectories. Limit the number and level of directories in a project.

''' Place all VIs in libraries, classes, or virtual folders '''
Avoid using auto-populating folders unless you have a good reason to use them.

''' Remove all unused files '''

''Details:''
- Remove all unused files both from the applicable projects/libraries and from the disk.

''Tip:''
- Right-click the project root in the Project Explorer window and select Find Items with No Callers from the shortcut menu to display the Find Items with No Callers dialog box. This dialog box identifies all the items you can remove.

== Libraries ==

''' Consider using virtual folders to delineate between public and private members of a library '''
(VI Analyzer) Consider using virtual folders to delineate between public and private members of a library.

''' Place APIs in a library '''
Place APIs in a library to improve organization.

''' Mark non-API VIs as private '''
Mark any VIs in a library as private if they are not part of the API.

== LabVIEW Classes ==

''' Name all classes as nouns '''
''Example:''
- Name an example class Waveform Reader.lvclass rather than Reads Waveforms.lvclass.

''' Name all member VIs of a LabVIEW class as verbs '''
''Example:''
- Name an example member VI Read Value.vi rather than Value.vi.

''' Avoid including the name of the class in VI names '''
''Example:''
- If we have a class ''Circle'' and it needs a VI to return the area, this VI should just be called ''Calculate Area'' as opposed to ''Calculate Circle Area'' or ''Circle Calculate Area.'' Note that LabVIEW provides a namespace for VIs in a library such that it is considered as ''Circle: Calculate Area.''

''' Use "Read" for VIs that read data '''
Use the word "Read" to begin the name of any VI that strictly reads data from the private data of a class. Avoid using the word "Get" or any synonym of "Get."

''' Use "Write" for VIs that bundle data into the private data '''
Use the word "Write" to begin the name of any VI that strictly bundles data into the private data of a class. Avoid using the word "Set" or any synonym of "Set."

''' Use Book Title Case for class virtual folders and VI names '''
Use Book Title Case for all class virtual folders and VI names.

''Details:''
- When auto-created by LV, the class property virtual folder name and the class property VI names may initially match the case of the control label in the class control. Since labels should follow the label guidelines listed in section 3.1.8, you may need to change the class property virtual folder and VI names to be Book Title Case.
- The name of a class property virtual folder is used as the name in a class property node.
- Because this is auto-generated by LV and may be tedious to change, this guideline is a recommendation at this time.
- A LabVIEW Developer tool may be created that will correct the auto-generated virtual folder and VI names to match these guidelines.

= Monitor Size, Window Size, and Window Placement =

* Code should look good on a 1536 x 824 monitor: Write code so that it looks good on a monitor with 1536 x 824 pixels for most individual file windows, or the target monitor size if designing a UI front panel.

''Details:''
* If you have a computer running Windows 10, 1536 x 824 pixels corresponds to 1920 x 1080 pixel resolution with 125% scaling. These are often default settings on a 15" laptop.
* With properly configured LabVIEW.ini tokens you can use the Arrange VI Window Quick Drop (Ctrl-Space, Ctrl-F) to make sure your VI front panel and block diagram windows comply with this guideline.
* VIWin.DisplayWorkspaceRight=1536
* VIWin.DisplayWorkspaceBottom=824

== Save files with minimal white space ==
Save files so all relevant content that can be shown is shown without showing a lot of extraneous white space.

== Position window near the upper-left corner of the monitor ==
Save files so the upper left corner of the window is close to the upper left corner of the monitor.

= VI Window Considerations =

== Size the windows so the entire toolbar fits ==
(VI Analyzer) Size the windows so the entire toolbar fits.

''Tip:''
- Use front panel cleanup to comply with this guideline for front panels. Use Arrange VI Window Quick Drop (Ctrl-Space, Ctrl-F) to comply with this guideline for block diagrams.

== Size front panels and block diagram windows appropriately ==
Size the front panel and block diagram windows reasonably for the content and never full-screen.

''Tip:''
- Use Arrange VI Window Quick Drop (Ctrl-Space, Ctrl-F) to comply with this guideline.

== Consider sizing panels with tall type definitions ==
If a front panel contains a tall type definition cluster, consider sizing the panel to fit existing regular controls and include part of the type definition.

[[File:Items.png|thumb]]

== Include wide type definition clusters in the panel ==
If a front panel contains a wide type definition cluster, consider including the cluster below the visible screen and a note indicating that the user can scroll down to see it.
[[File:Items wide.gif|thumb]]

== Entire block diagram should fit on the monitor ==
The entire block diagram of a VI should fit on the monitor.

''Details:''
- If this guideline is impossible to comply with, write the block diagram so you can read it scrolling in only one direction.

= VI, Library, and Class Interfaces =

== Front Panel ==

''' Set reasonable default values for controls '''
Set reasonable default values for controls. Use data type defaults for indicators.

''' Avoid overlapping labels and displays '''
(VI Analyzer) Avoid overlapping the labels, digital displays, or other parts of controls and indicators.
- Allow for extra space between controls and indicators to account for font changes on different platforms, and for Windows scale and layout settings.
- Overlapped controls and indicators slow down screen updates and can make the control or indicator flicker.

''' Use path controls and indicators '''
Use path controls and indicators instead of string controls and indicators to specify the location of files or directories.

''Rationale:''
- Unlike strings, path controls format paths using the standard syntax for the platform you use.

''' Set appropriate browse options for path controls '''
When using path controls, set the browse options appropriately. For example, if a path control is intended for existing directories, select the Folders only and Existing only options on the Browse Options page of the Properties dialog box.

== GUI VI Front Panels ==

''Note:''
In this context, a GUI is a VI front panel that is used as a visual part of a UX, for example the visual piece of a LabVIEW-built application or the visual piece of a plug-in to a framework. As a counter-example, VIs that are parts of APIs are not considered GUI VIs, even if they happen to go on palettes.

''' Minimize the use of colors '''
Minimize the use of colors. Use colors logically and consistently.

''' Hide the toolbar '''
Hide the toolbar.

''' Use consistent control styles '''
Use one consistent style for all controls. Use system controls when possible.

''' Customize appearance with strict type definitions '''
Use custom controls or strict type definition controls to customize the appearance of a control. Use strict type definition controls only to preserve the exact appearance of a control in each location of use.

''' Use standard fonts '''
(VI Analyzer) Use the standard application, system, and dialog fonts for all user interfaces in the application.

''Details:''
- Use the standard font unless you have a specific reason to use a different font. For example, you can use monospace fonts because they are proportionally spaced for string controls and indicators that constrict character use.

''' Configure numeric inputs to coerce values '''
Configure numeric inputs to coerce values to the valid data range if applicable.

''' Arrange controls logically '''
Arrange controls from top left to bottom right.

''Details:''
- Place controls in the order of typical use. For top-level VIs visible to users, place the most important controls in the most prominent positions.

''' Organize UI elements with logical layout '''
Organize UI elements using proximity, alignment, decorations, and UI features such as tab controls and subpanels.

''' Configure the front panel to fit the monitor '''
Configure the front panel to fit the monitor resolution used in the application.

''Details:''
- Monitor resolution used in the deployed system may be different from monitors used for development.

''' Use labels for controls and indicators '''
Use labels to describe the function of controls and indicators. Limit caption use to controls and indicators that require more information than the label conveys or when you need the ability to change the display text of a control programmatically.

{| class="wikitable"
|-
! Situation !! Example
|-
| If the control is visible to the user, use captions to display a long description and add a short label to prevent using valuable space on the block diagram. || When you label a ring or slide control with options for volts, ohms, or amperes, selecting a caption such as "select units for display" is more usable than the label V/O/A. Use Property Nodes to change captions programmatically.

|-
| If you use the VI with the control on multiple platforms, avoid using special characters in control names. || Use degree Celsius instead of °C because the ° symbol might not display correctly on all platforms.
|}

''Details:''
- Use captions for descriptive text if the label is insufficient.

''' Set intuitive keyboard shortcuts '''
Set up intuitive keyboard shortcuts and tabbing order for controls.

''Details:''
- Some users prefer to use the keyboard instead of a mouse. Consider including keyboard shortcuts for VIs, even if the use of a mouse is available. Set the tabbing order for controls from left to right and top to bottom. Use the <Enter> key for the default control and the <Esc> key for the Cancel button.

''' Write descriptions and tip strips '''
Write descriptions and create tip strips for UI front panels and controls to describe the purpose of an object and give users instructions for using the object.

== Dialog Front Panels ==

''' Use system control style '''
(VI Analyzer) Use the system control style when possible to ensure that dialogs look consistent with the operating system.

''' Do not use scroll bars on entire front panels '''
Do not show scroll bars on the entire front panel windows. Design the dialog box to display all information. Use scroll bars on individual controls and indicators as appropriate.

''Tip:''
- Set the VI Window Appearance to Dialog through File > VI Properties.

''' Provide meaningful window titles '''
Provide a meaningful window title that explains the purpose of the dialog.

''' Avoid default menus '''
If the dialog has menus, only use menus that are specific to the dialog window. Avoid using default menus.

''' Limit dialog box use '''
Limit dialog box use to critical user interactions. Avoid overusing dialogs.

''' Ensure dialogs are modal or floating '''
Make sure that all dialogs are either modal to the main application or floating.

''' Use the system panel background color '''
Use the system panel background color for dialog user interfaces to maintain consistency.

''' Center the dialog on the main monitor '''
Center the dialog on the main monitor.

== Non-GUI VI Front Panels ==

''' Use default colors for UI elements '''
(VI Analyzer) Use the default colors for all UI elements of the front panel.

''' Arrange controls and indicators relative to connector pane terminals '''
(VI Analyzer) Arrange controls and indicators relative to corresponding connector pane terminals.

''Tip:''
- Use Arrange VI Window Quick Drop (Ctrl-Space, Ctrl-F) to arrange the panel objects.

''' Group related data into clusters '''
Consider grouping related input and output data into clusters. Make the cluster a type definition.

''' Use Modern style controls '''
Use Modern style controls, except if you use a type definition from a dependency that isn’t a Modern style control.

''' Use buttons for Boolean controls and LEDs for Boolean indicators '''
Make sure controls look like controls and indicators look like indicators. For example, use buttons for Boolean controls and LEDs for Boolean indicators, except if you use a type definition.

''' Use labels, not captions, unless localization is required '''
Use control and indicator captions only if you need to localize non-GUI VIs. Otherwise, only use labels.

== Control and Indicator Labels/Captions ==

''' Choose descriptive names '''
Choose names so they are easy to read and describe the purpose of the control or indicator.

- Create names that describe the purpose of the control or indicator.
- Use full words except where an abbreviation is well known by the intended audience, such as "USB Port" for "Universal Serial Bus Port".
- In GUI VIs, use Book Title Case.
- In non-GUI VIs, use all lowercase characters except for proper nouns and common uppercase abbreviations.
- Use single space characters between words.
- You may use dashes in situations where dashes are ordinarily used, such as for "Real-Time."
- Make sure those names work on all relevant platforms.

''Details:''
- Refer to Appendix A: Book Title Case for definition and examples.
- In this context, a GUI is a VI front panel that is used as a visual part of a UX, for example, the visual piece of a LabVIEW-built application or the visual piece of a plug-in to a framework. As a counter-example, VIs that are parts of APIs are not considered GUI VIs, even if they happen to go on palettes.

''' Avoid duplicate labels '''
(VI Analyzer) Avoid using duplicate labels.

''' Add "in" and "out" to input/output pairs '''
If a VI contains an input and output pair, add a suffix of "in" to the control label and a suffix of "out" to the indicator label. For example, if a VI includes an input called object in, name the corresponding output object out.

''' Label error inputs and outputs as "error in" and "error out" '''
If a VI has an error input or an error output, label them as "error in" and "error out" exactly as shown, unless there is a specific reason not to.

''Details:''
- There is no value in including the default value ("no error") because you never want a different default value for the error input.

''' Use parenthesis in labels only for units '''
Use parenthesis in labels only to document units of a control or indicator when it makes sense to do so.

''Details:''
- Avoid using parenthesis for any other purposes.
- You should not include the default value in the label in parenthesis.

''' Use SI units '''
When including units in a label, use units approved and documented in The International System of Units.

''Details:''
- Refer to Appendix B: The International System of Units for a list of conventional units.

''' Use "Size to Text" for labels '''
Use Size to Text for labels so the text rectangle automatically resizes to accommodate the text you enter. By default, Size to Text is enabled for one line of text.

''Details:''
- The three standard fonts (application, system, and dialog) vary depending on the platform. For example, preferences and video driver settings in Windows affect the size of the fonts. Text may appear larger or smaller on different systems. To compensate for font variations, allow extra space for larger fonts and enable the Size to Text option via the label's shortcut menu.

''' Use the default Application font for labels '''
Use the default Application font with all default cosmetic settings unless you have a good reason not to.

''' Use transparent background color for labels '''
(VI Analyzer) Use transparent background color for labels.

== Free Labels on Front Panels ==

''' Avoid the use of free labels on front panels '''
Avoid the use of free labels on front panels except where particularly useful.

''Example Exceptions:''
- VI Analyzer template front panels contain useful free labels instructing you what not to change about the controls and indicators.
- Certain globals used as constants contain useful free labels reminding you to save changes to control values as default values.
- Some example programs contain useful instructions on front panels.

''' Use carriage returns only to separate paragraphs '''
(VI Analyzer) Use carriage returns in free labels only to separate paragraphs.

''' Use Size to Text for single-line labels '''
(VI Analyzer) If a free label occupies a single line, use Size to Text. Size free labels with multiple lines so that all the text is visible and provide extra space at the bottom of a free label to account for font size changes across platforms.

''' Use the standard application font for free labels '''
Use the standard application font for free labels unless you have good reasons not to do so.

== Classes and Property Nodes ==

''' Support Property Node syntax for data accessors '''
Consider supporting the syntax of Property Nodes for data accessor VIs. However, accessors that use Property Node syntax require error terminals and take more time to execute than data accessor VIs without error terminals. Evaluate and choose appropriately for each class.

== VI Description ==

''' Describe what the VI does in the VI Description text box '''
For each VI intended to be used by others, such as API VIs and examples, describe what the VI does in the VI Description text box.

== VI Connector Pane ==

''' Use the 4x2x2x4 conpane for all VIs '''
(VI Analyzer) Use the default 4x2x2x4 conpane for all VIs, which provides 12 terminals total. This pattern provides a balance of flexibility of terminal location and density of terminals. Connector panes with more terminals (such as 5x3x3x5) can be difficult to wire due to the smaller terminal size. If you find yourself needing to increase the number of terminals on your subVI beyond 12, your subVI may not be sufficiently modular, and may require a redesign.

''' Use left terminals for controls and right terminals for indicators '''
Use the left terminals for controls and right terminals for indicators. When using the top and bottom terminals, place all controls to the left of indicators.

''' Place related controls and indicators at the same relative position '''
Place related controls and indicators at the same relative position on the connector pane. For example, if you assign a data in control to the top left terminal, assign the corresponding data out indicator to the top right terminal.

''' Ensure consistency for similar controls across APIs '''
If a control or indicator serves the same function throughout an API, name the control or indicator consistently and place it in the same position throughout all API connector panes.

''' Place paths, references, and classes in the top corners '''
(VI Analyzer) Place paths, references, and LabVIEW Classes in the top corners.

''' Place error terminals at the bottom corners '''
(VI Analyzer) Assign error in and error out terminals to the corresponding bottom left and right terminals.

''' Preserve empty terminals for future expansion '''
(VI Analyzer) Preserve empty terminals on the connector pane to allow for future expansion.

''' Set required terminals for must-wire inputs '''
Configure input terminals for parameters that must be wired for the VI to function as Required.

''' Set recommended terminals for inputs with good defaults '''
Configure input terminals that have good default values as Recommended. If you are not sure whether an input should be required or not, make it Required.

== VI, Library, and Class Icons ==

''' Use glyphs for high-visibility VIs '''
Use glyphs in icons for VIs that will have high visibility, such as APIs for software products. Use text in icons otherwise.

''Rationale:''
- The effort required to create good glyph-based icons is rarely justified for VIs with limited audience.

''' Always create standard size (32x32 pixel) icons '''
Always create standard size (32x32 pixel) icons.

''Exceptions:''
- In very rare cases it may be appropriate to have a shorter icon. For example, if you use an enumeration with names of hardware registers, you may want to use a short icon for a commonly used register-name-to-register-address subVI to preserve block diagram space in subVI call locations.

''' Use glyphs from the Glyphs tab in the icon editor when applicable '''
Use glyphs from the Glyphs tab in the icon editor when applicable.

''' Avoid using colloquialisms in icons '''
Avoid using colloquialisms in icons because they may not work across cultures and languages. For example, avoid representing a data logging VI with a picture of a tree branch or a lumberjack. On the other hand, a pencil is generally understood as a utensil for writing.

''' Use standard text settings for icons '''
Use the following font settings for the text used in icons:
- Font: Small Fonts
- Alignment: Center
- Size: 9
- Center text vertically: Checked
- Capitalize text: Checked
- Color: Black, with a possible exception for the library layer set forth below

''' Use text that matches all or part of the VI name '''
Use text that matches all or part of the VI name in the icon.

''' Limit the text to three lines with a library or class banner '''
Limit the text to three lines if a library or class icon banner is included or to four lines otherwise.

''' For non-library VIs, use a plain transparent square with a single pixel black border '''
For VIs that are not part of a library or class, use a plain transparent square with a single pixel black border as the base layer for the icon.

''' For library or class VIs, use a library layer with a black border '''
For VIs that are part of a library or class, use a library layer and a plain transparent square with a single pixel black border as the base layers for the icon.

''' Use 32x9 pixel rectangles for library/class banners '''
Use 32x9 pixel rectangles with black frames for library and class library icons. Position those rectangles at the very top of the 32x32 pixels allocated for the icons.

''Tip:''
- Reduce the size of the default library and class icon by three vertical pixels.

''Rationale:''
- Taking into account a pixel for the bottom border, this leaves 22 vertical pixels for individual VI icons. If you are using text with the settings specified below, and you have three lines of text, 23 vertical pixels give you two pixels of vertical spacing between the top and text, two pixels of vertical spacing between the lines, and one pixel of vertical spacing between the last line and the bottom border, which makes the text for the individual icon look reasonably good.

''' Limit text in the banner to a single line '''
Limit text in the banner of the library and class icons to a single line.

''' Ensure contrast between front and background colors '''
If you put text in the library or class icon banner, make sure there is enough contrast between front and background colors so that you can easily read the text.
- If the library icon background color is light, use black color for the text.
- If the library icon background color is dark, use white color for the text.

== LabVIEW Class Wires ==

''' Avoid excessive wire patterns and colors '''
Avoid creating excessive wire patterns and colors if you change the wire appearance of a LabVIEW class wire.

''Details:''
- The number of colors and patterns in the block diagram window can affect the readability of LabVIEW code. Change the wire appearance of LabVIEW class wires only if necessary to differentiate between other class wires in the block diagram window.

''' Use dark colors on the exterior of class wires '''
Use dark colors on the exterior of class wires to provide contrast against the white background.

''' Use refnum color for wires if the private data contains only refnum types '''
If the private data of a class contains only refnum types, use the standard refnum color for the class wire. Locate the color named "Refnum Wire" in the User Colors dialog box for the LabVIEW color picker.

''Note:''
- This guideline takes precedence over other wire color guidelines.

''' Match class wire color to the icon banner color '''
Make the color of the class wire match the color of the class icon banner.

= Programming VI Block Diagrams =

''' Avoid duplicating code '''
Avoid duplicating code. Use subVIs or loops, as appropriate, to avoid code duplication.

''' Remove unused code '''
(VI Analyzer) Remove unused code from block diagrams.

''' Avoid race conditions with appropriate synchronization '''
Avoid race conditions by using appropriate synchronization techniques.

''Details:''
- You can use queues, data value references, and semaphores to prevent race conditions.
- You can also use functional global variables to prevent race conditions if the functional global variable protects a critical code section containing actions that modify data.
- However, you cannot use a functional global variable to prevent race conditions if the functional global variable protects sections containing actions that only read and write data.

''' Handle unsupported values appropriately '''
Handle all unsupported values appropriately.

''Example:''
- If you create an API, consider returning an error for unsupported inputs.

''' Avoid creating platform-specific versions of VIs '''
When designing multi-platform VIs, avoid creating per-platform versions of a VI. Instead, place platform-specific functionality in a Conditional Disable structure specific to a target.

''Details:''
- Specifically, pay attention to Call Library Function Nodes as library file extensions may be different between platforms. If applicable, use an asterisk instead of the library file extension so the same configuration works on different platforms.

''' Avoid using absolute paths '''
Avoid using absolute paths.

''Details:''
- When possible, either use relative paths and define a root path in your code or determine the root path dynamically at run-time based on system settings or the application location. Ensure that relative file paths work for the operating system on which the code is intended to run.
- Absolute paths can cause problems when you build an application or run the VI on a different computer. If you must use an absolute path, consider ensuring that you include code to check whether the path exists and to create a path if the path does not exist.

== Layout and Wiring ==

''' Use a left-to-right and top-to-bottom layout '''
(VI Analyzer) Use a left-to-right and top-to-bottom layout.

''' Ensure data flows left to right '''
(VI Analyzer) Wire so data flows from left to right, unless you use feedback nodes. If you need to use vertical wires in addition to horizontal wires, top-to-bottom flow is preferred over bottom-to-top flow when practical.

''Details:''
- If your diagram contains a wire from right to left that is not associated with a feedback node, explain that decision using a wire label or an attached label.

''' Avoid using long wires unless necessary '''
Avoid using long wires unless you have good reasons. If you must use long wires, use wire labels on those wires.

''' Wire neatly and efficiently '''
(VI Analyzer) Wire neatly and efficiently. Keep the number of bends and wire crossings reasonable.

''Rationale:''
- Poor wire organization can make the block diagram difficult to read and debug or make the VI appear to do things it does not do.

''' Arrange objects neatly on the block diagram '''
(VI Analyzer) Neatly arrange objects on the block diagram.

''Tip:''
- Use the Align Objects and Distribute Objects pull-down menus on the toolbar to arrange objects on the block diagram.

''' Avoid leaving front panel terminals unwired '''
(VI Analyzer) When possible, avoid leaving front panel terminals unwired on the block diagram. Do not use a variable when you can use a terminal wire to transfer data.

''Rationale:''
- LabVIEW is a data flow language, so wires are preferred from the maintainability perspective. Also, every local variable that reads the data makes a copy of the data.

''' Align control terminals to the left, indicator terminals to the right '''
Align control terminals to the far left and indicator terminals to the far right of the block diagram. Align controls along their right edges and indicators along their left edges.

''Exception:''
- This does not apply to indicator terminals used inside structures.

''' Lay objects neatly with reasonable spacing '''
Lay objects neatly and with reasonable spacing to create a visually appealing block diagram. Do not wire under objects. Avoid unnecessary white space and overcrowding of the block diagram. Provide just enough white space for visual guidance.

''Tip:''
- To increase space between tightly grouped objects, press <Ctrl> and drag in the direction you want to add space. (MacOS) Press <Option>.
- To reduce space between scattered objects, press <Ctrl-Alt> and drag in the direction you want to remove space. (MacOS) Press <Option-Ctrl>.

== Colors ==

''' Avoid coloring diagrams '''
Avoid coloring diagrams. Color can distract users.

''' Use default colors for structures '''
Use default colors for structures, such as Case or Event structures.

== Structures ==

''' Avoid using Sequence structures '''
Avoid using Sequence structures unless you must use them to define execution order.

''' Arrange parallel loops vertically '''
If you have several loops that execute in parallel, arrange them vertically if possible.

''' Avoid placing control and indicator terminals inside loops or structures '''
Avoid placing control and indicator terminals inside loops or structures unless the values need to be read or updated regularly, like a latched Boolean in its value change event case or a graph in a while loop.

''' Set conditional structures wide enough to show full case or event selector '''
Set conditional structures such as Case structures and Event structures wide enough to view the full case selector, event selector, or similar text. If you have multiple conditions in the same frame, you may make an exception (and not show all of the text) to avoid increasing the structure width.

''' Save VIs with the most important frame of multi-frame structures visible '''
Save each VI with the most important frame of multi-frame structures visible.

''' Wire selector terminal inside Case structures '''
When you use a Case structure, avoid creating a separate tunnel for the wire connected to the selector terminal. Instead, wire the selector terminal inside the structure.

[[File:Case Structure Tunnels.png]]

''' Avoid converting non-Boolean types to Booleans for Case selectors '''
Do not convert integers, enums, strings, and error clusters to Booleans only to wire such Booleans into the selectors of Case structures. Use non-Boolean selectors instead.

''' Do not include default case for Case structures wired to enums '''
(VI Analyzer) Do not include a default case for Case structures wired to enums.

''Rationale:''
- If you add a new element to an enum wired to the default case of a Case structure, the code executes the default case, which is unlikely to be desired behavior.

''Exception:''
- You may include a default case if you have an enum with a large number of values and a case structure where non-default cases apply only to a handful of values.

''' Use In Place Element structure to modify data structures '''
When applicable, use the In Place Element structure to clearly convey that elements of a data structure are getting modified. Use of the In Place Element structure may also be beneficial from the performance perspective.

''' Ensure that For Loops behave as expected if they execute zero times '''
Ensure that For Loops behave as expected if they execute zero times.

''Details:''
- If necessary, use a shift register to pass a value through the loop in this situation. If you wire a value or a reference to pass through a For Loop, use shift registers instead of tunnels.

''' Identify number of times a For Loop executes '''
(VI Analyzer) Verify that you can easily identify the number of times a For Loop executes. Avoid using both Auto-indexing and the N terminal to govern iterations of the same For Loop. If you use more than one of these options, you can cause confusion about how many times the loop executes. Be cautious when auto-indexing on multiple arrays, as such arrays may have different sizes.

''' Use Event Structure to monitor UI events instead of polling '''
(VI Analyzer) Use an Event Structure to monitor UI events and other applicable events instead of polling, where appropriate.

''Details:''
- Avoid polling front panel controls when you can use a Value Change event in an Event Structure more appropriately.
- Place the control terminal for a Value Change event configured for a control in the Value Change event case.

''Exception:''
- The following illustration shows a situation in which you can acceptably place the control terminal as a stop button outside the event structure.

''' Resize Event Data Nodes to contain only necessary data '''
(VI Analyzer) Resize Event Data Nodes to contain only data being used. If the node is not used, resize the node to one element and move it to a corner of the frame. In LabVIEW 2020 and later, you can right-click on the frame to hide the event data nodes entirely (Visible Items >> Event Data Node for This Case).

== Functions ==

''' Display the subVI icon instead of the connector pane '''
Make sure the subVI icon, rather than the connector pane, is visible on the block diagram.

''Rationale:''
- A well-designed subVI icon is more helpful than the connector pane on the block diagram.

''Tip:''
- If you see a subVI call with the connector pane, right-click the subVI call, select Visible Items, and make sure that the Terminals option does not contain a checkmark.

''' Display terminals for front panel objects '''
(VI Analyzer) Display the terminal for front panel objects on the diagram, not the icon. You may make exceptions for type definitions. Well-designed type definition icons display useful information about the type definitions.

''Tips:''
- To make an exception for a type definition, right-click the corresponding terminal and select Show as Icon.
- Navigate to Tools > Options > Block Diagram to change the default for this option.

''' Use built-in LabVIEW string constants '''
(VI Analyzer) Avoid creating a string constant that contains a single, difficult-to-read value. Use the built-in LabVIEW string constants. For example, use a Space Constant instead of a String Constant with a single space.

''' Use Bundle by Name and Unbundle by Name for clusters '''
Use the Bundle by Name and Unbundle by Name functions when you access cluster elements. Avoid using the unnamed Bundle and Unbundle functions.

''' Show index display for array constants '''
(VI Analyzer) Array constants on block diagrams must include index or indices display. Array constants must display all elements of the array and the next empty element, if practical. If only a subset of elements can be displayed, the constant must have a scroll bar.

''' Show names for Property, Invoke, and Call Library Function Nodes '''
Make sure that Property Node, Invoke Node, Call Library Function Node, and similar nodes are shown with names. If both short and long names are available, use short names to preserve space.

''Exception:''
- The Long Names option may be appropriate in certain instances. For example, use the Long Names option for an element if that element shares the same short name with another element.

''' Avoid using named queues and notifiers '''
Avoid using named queues and named notifiers.

''Details:''
- If possible, pass the reference wire in place of using named queues and notifiers. If you must use named queues and named notifiers, avoid name collisions.

''' Close every reference opened '''
Make sure the code closes every reference it opens. If practical, open and close references in the same VI.

''Details:''
- You can use subVIs for opening and closing references. If you use subVIs to open or close a reference, pair the subVIs up. Use VI names and icons that reflect these pairings. For example, use pairs of words such as "Open" and "Close" or "Obtain" and "Release."

''Exception:''
- You don't need to close references to GObjects because they get closed automatically when the VI reference is closed.

''' Use path constants for file locations '''
Use path constants instead of string constants to specify the location of files or directories.

''Rationale:''
- Unlike strings, path constants format paths using the standard syntax for the platform you use.

== Data Types ==

''' Avoid using strict type definitions '''
Do not use strict type definitions unless the control or indicator is used in multiple UI VIs, and you want to keep consistent appearance in those locations.

''' Use type definitions for enums and clusters '''
Use type definitions for enums and clusters.

''' Use enums instead of rings '''
Use enums instead of rings unless you have a strong reason not to.

''Exceptions:''
- If you must use a ring control, configure it as a strict type definition so that all menu items update for each use. If you do create a strict type definition, extend the size beyond the longest words to allow for easier expansion of future options. Ring controls allow you to easily interact with front panels if you want to programmatically change the string labels.
- Use rings instead of enums for controls and indicators on VIs that are part of a public API where the item names must be localized.

''' Avoid creating clusters with identical element names '''
(VI Analyzer) Avoid creating clusters that contain multiple elements with identical names.

== Timing ==

''' Provide a mechanism to abort infinite timeouts '''
If you use an infinite timeout, consider providing a mechanism to abort the wait.

''' Avoid arbitrary timing delays '''
Avoid using arbitrary timing delays. If an important event executes during a delay, make sure that the important event occurs before proceeding. If you must use a delay, provide a comment about the purpose of the delay and the rationale behind the duration.

== Labels and Comments ==

''' Document non-obvious constants '''
Use a specific and detailed label or attached comment to document constants that contain non-obvious values.

''' Use comments to explain non-obvious code '''
Use comments on the block diagram to explain code when the reasoning behind the code is not obvious. When practical, use constant labels, attached labels, structure labels, or subdiagram labels rather than free labels.

''' Do not include default values in constant labels '''
Do not include default values in constant labels. This typically comes up when creating constants by right-clicking on function terminals.

''' Label shift registers and wires when necessary '''
Label shift registers and wires when the content is potentially unclear or confusing.

''' Place terminal labels correctly '''
Place terminal labels to the middle left of the terminal for controls and to the middle right of the terminal for indicators.

''' Use line feeds in comments only for paragraphs '''
(VI Analyzer) Use line feeds in comments only to separate paragraphs.

''' Use Size to Text only for single-line labels '''
(VI Analyzer) Use Size to Text setting only for single-line labels. Size multi-line labels so that all the text is visible and provide extra space at the bottom of a free

''' Use the standard application font for labels '''
Use the standard application font for labels.

''' Use default text and background colors for labels '''
(VI Analyzer) Use the default text and background colors for all labels.

''Exceptions:''
- You can make exceptions under special circumstances, such as for background color for #CodeRequired and #CodeRecommended labels in templates and sample projects.

== Error Handling ==

''' Handle errors appropriately '''
Handle errors appropriately.

''Details:''
- Carefully consider every place in the code that may generate an error.
- Add comments to explain any potentially confusing decisions about error handling.
- Use a consistent error handling strategy. Make sure the program can deal with all error conditions. Determine the actions for errors, such as log, terminate, and/or notify the user.

''' Disable automatic error handling '''
(VI Analyzer) Disable automatic error handling for all VIs, including new VIs. Automatic error handling stops execution in the event of an error and waits on an input before continuing. This automatic stopping can cause problems in a deployed system or application.

''Tips:''
- Navigate to Tools > Options > Block Diagram > Error Handling to change the default for new VIs.
- To change the setting on existing VIs, navigate to File > VI Properties > Execution.

''Exception:''
- You may use automatic error handling during development, but make sure it is disabled by the build process, so it is not used by a deployed system.

''' Prioritize errors during error merging '''
Carefully consider the priority of errors when merging them. Give priority to errors that occurred first unless you have a good reason not to do so.

''Details:''
- When using the Merge Errors function, wire the first error to the top input terminal.

''' Consider creating a custom error file '''
Consider creating a custom error file to contain all the error descriptions for an application or a library.

== Performance ==

''' Avoid reallocating memory inside loops '''
(VI Analyzer) Unless necessary, avoid including code that reallocates memory inside of loops, such as code that contains the Build Array or Concatenate Strings functions. Reallocating memory inside of loops can cause slow performance.

''' Avoid unnecessary type coercions '''
(VI Analyzer) Avoid unnecessary type coercions. Type coercions can allocate memory and cause slow performance.

''' Avoid unnecessary data copies '''
Avoid unnecessary data copies, especially if the data is large.

''' Open and close resources outside of loops '''
Consider placing code that opens and closes resources, such as DAQ or File I/O code, outside of loops. Repeatedly opening and closing references inside of a loop is inefficient.

''' Separate application timing from execution timing '''
(VI Analyzer) Make an explicit decision to separate application timing from execution timing. Include code to limit the execution speed of continuously running loops when they don't need to execute at maximum speed.

''Details:''
- Application timing is the time your application defines for things to happen. Execution timing is how fast the computer will execute the code.
- By default, While Loops and For Loops execute as quickly as possible and use all available CPU resources during this time. To preserve system resources, use a blocking mechanism, such as a Wait function or timeout value, to ensure a loop executes only as often as needed.

''' Avoid time-consuming code inside Event structures '''
Avoid using time-consuming code inside the Event structure. Consider using a producer-consumer pattern or a similar pattern instead.

''' Use inlining and subroutine priority strategically '''
(VI Analyzer) Use inlining and subroutine priority strategically to improve execution speeds.

''' Configure For Loop iteration parallelism '''
(VI Analyzer) Consider configuring For Loop iteration parallelism to improve performance.

''' Use local variables instead of the Value property '''
(VI Analyzer) Use a local variable instead of the Value property when needed to update a front panel control or indicator value.

''Details:''
- This is often needed in UI VIs to initialize control values at run time.

''' Use Get/Set Control Values by Index for front panel updates '''
(VI Analyzer) If you perform many updates to the front panel, use the Get Control Values by Index and Set Control Values by Index functions.

''' Use the In Place Element Structure for compound data types '''
(VI Analyzer) When modifying portions of compound data types, such as arrays and clusters, use the In Place Element Structure instead of individual nodes such as Bundle and Unbundle.

== Source Code Distribution ==

''' Remove breakpoints before distributing VIs '''
(VI Analyzer) Remove all breakpoints before distributing VIs to prevent unintended and unwanted halts in execution.

''' Disable debugging to improve performance '''
(VI Analyzer) Disable debugging to improve performance.

''Tip:''
- Change this setting in the build specification rather than source code if practical.

''' Disable automatic error handling on all VIs '''
(VI Analyzer) Disable automatic error handling on all VIs.

= Guidelines for LabVIEW RT =

''' Use while loops for non-deterministic tasks '''
Whenever possible, use while loops, not timed loops, for non-deterministic tasks.

''' Use the term "deterministic" instead of "time critical" '''
In your documentation, use the term "deterministic" instead of "time critical" to describe code running in timed loops. The term "time critical" is commonly recognized as a VI priority you can use to schedule parallel tasks.

''' Use timed structures instead of deterministic priority setting on SubVIs '''
Whenever possible, use timed structures instead of a deterministic priority setting on SubVIs.

''' Serialize code within timed structures '''
Serialize code within timed structures so that it executes in a defined, sequential order.

''' Use inline property for VIs in timed structures '''
To minimize subVI overhead, use the inline property for VIs in timed structures.

''' Use subroutine priority with Skip Subroutine Call If Busy '''
When you use subVIs in timed loops that access a shared resource, consider using subroutine priority and the Skip Subroutine Call If Busy setting.

''Tip:''
- To turn on Skip Subroutine Call If Busy on a subVI, right-click on the subVI and select the menu option.

''' Avoid placing controls or indicators in timed loops '''
Avoid placing controls or indicators within timed loops because they execute slowly and non-deterministically.

''' Merge errors properly in timed loops '''
With timed loops, merge inner left ear error with error input to catch any configuration errors. Also, merge outer right ear error with error outputs.

''' Use the Select function instead of a Case structure in deterministic code '''
If possible, use the Select function instead of a Case structure in deterministic code. The Select function provides greater determinism.

''' Check time-critical loops for lateness '''
Check all time-critical loops for lateness.

== Handling Data Guidelines ==

''' Optimize file I/O performance by establishing appropriate chunk sizes '''
If file I/O performance matters, establish the best chunk size for writing and reading. Note that this may vary by target.

''' Use RT FIFO functions for streaming data '''
Use RT FIFO functions instead of RT FIFO-enabled Shared Variables for streaming data. However, you can use RT FIFO-enabled shared variables for current value communication.

''' Use the Flush File function to handle critical data '''
For critical data, use the Flush File function to flush the file frequently. Reliance and FAT only flush once per second.

''' Limit size and quantity of log files '''
Limit the size and quantity of log files to improve system reliability. A directory with a large and growing number of files can grow slow and demonstrate changes in system behavior. As a result, you may encounter unexpected behavior.

== Initialization and Shutdown Guidelines ==

''' Implement shutdown code to stop initialized resources '''
Implement shutdown code to stop anything initialized, even if the next step calls for a reboot.

''' Avoid writing to configuration files from within the application '''
Avoid writing to configuration files from within the application. Writing to configuration files can corrupt the file and prevent you from properly initializing the next reboot. If you must write to a configuration file, develop a strategy to recover from or limit the damage of corruption.

''' Place reboot code in a conditional disable structure '''
Place code that reboots a controller in a conditional disable structure so you can easily disable the reboot at the end of a program. If you place reboot code in a conditional disable structure, you can disable the code when debugging and enable the code when deploying the application.

== Miscellaneous ==

''' Use RT Timing palette for real-time timing '''
Use Timing VIs from the Real-Time>RT Timing palette instead of the ones from the Programming>Timing palette.

''' Monitor processor and memory usage from development through deployment '''
Monitor the processor and memory usage for the system from development through deployment.

''Details:''
- Ensure processor usage does not stay high long enough to cause unacceptable thread starvation when a thread does not get time to execute.
- Verify that memory usage does not grow continually and that a plan exists to recover in case memory usage does grow continuously.

= Guidelines for LabVIEW FPGA =

''' Keep in mind that top-level VI controls and indicators are resource intensive '''
When you plan how to use FPGA resources, keep in mind that top-level VI controls and indicators are resource intensive.

''' Handle errors locally on FPGA '''
If you use a node that has an error output, include code to handle the error immediately.

''Details:''
- Localized error handling in FPGAs typically results in lower FPGA resource utilization because the error cluster in FPGA consists of 33 bits, one bit for status and 32 for the error code. You can often reduce 33 bits down to one.

''' Avoid writing to hardware outputs inside Case structures in timed loops '''
Avoid writing to hardware outputs inside a Case structure, especially when inside a single-cycle Timed Loop. Instead, explicitly define hardware outputs for each case and write to hardware outputs outside the Case structure.

''' Monitor DMA FIFO timeouts '''
Monitor the timeout output of DMA FIFO reads and writes and respond accordingly.

''Details:''
- Also monitor the timeout output of target-scoped FIFOs unless you either do not care if a timeout occurs or are certain a timeout will never occur.
- To handle the length of timeouts, either latch the output and notify the host that the FPGA should be restarted to ensure data integrity or use a handshaking protocol to handle resending data.

''' Use 4-Wire handshaking protocol where applicable '''
Use 4-Wire handshaking anywhere appropriate, and be sure to label the wires, such as "input valid," "ready for output," "output valid," and "ready for input".

''' Convert fractional data types to single precision before sending to host '''
Consider converting fractional data types to the single data type before passing them up to the host.

== FPGA Host Interface ==

''' Call the Reset and Run methods explicitly '''
Consider calling the Reset and Run methods specifically instead of automatically running the VI from the Open FPGA Reference function. This ensures the FPGA is in a known state before it executes.

''' Avoid reallocating memory or polling the CPU when reading from DMA FIFOs '''
When reading from DMA FIFOs, do not reallocate memory or poll the CPU.

''Details:''
- Consider using the Configure method to set an appropriate host-side buffer. Avoid using large FPGA size buffers when possible to preserve block RAM.
- Set the DMA Read timeout to 0.
- Read a fixed-size number of elements (a multiple of the number of data channels).
- Wait until the buffer is full before reading elements.

''' Use the Dynamic reference type for FPGA APIs '''
Use the Dynamic reference type when creating an API that communicates with an FPGA.

= Appendix A: Book Title Case =

''Source:'' http://labview.ni.com/docs/labview-style/#FileOrganization10

|| **Rule** || **Yes** || **No** ||
|| Capitalize the first word. || General Error Handler || General error handler ||
|| Capitalize all nouns, pronouns, adjectives, verbs, adverbs, and subordinate conjunctions (as, because, although). || General Error Handler || General error handler ||
|| Capitalize the second part of a hyphenated compound. || Fixed-Point || Fixed-point ||
|| Do not capitalize articles (a, an, the), coordinate conjunctions (and, or, nor), or prepositions regardless of length, unless they are the first or last word (exception: capitalize Boolean operators, such as AND, OR, etc). || Search and Replace || Search And Replace ||
|| Do not capitalize "to" in an infinitive phrase, unless the phrase is the first word. || Path to String, To String || Path To String, to String ||
|| Use industry capitalization. || PolyBezier, IrDa || Polybezier, IRDA ||
|| Capitalize all acronyms. || FIFO, URL || Fifo, Url ||
|| Use single spaces between words. || Feedback Node || FeedbackNode, Feedback Node ||
|| Do not use special characters. || Search and Replace || Search & Replace, Search_and_Replace ||

= Appendix B: International System of Units =

''Source:'' https://www.bipm.org/utils/common/pdf/si_brochure_8_en.pdf

== Table 1. SI Base Units ==

|| **Quantity** || **Name** || **Symbol** ||
|| length || metre || m ||
|| mass || kilogram || kg ||
|| time, duration || second || s ||
|| electric current || ampere || A ||
|| thermodynamic temperature || kelvin || K ||
|| amount of substance || mole || mol ||
|| luminous intensity || candela || cd ||

== Table 3. Coherent Derived Units in the SI with Special Names and Symbols ==

|| **Derived quantity** || **Name** || **Symbol** ||
|| plane angle || radian || rad ||
|| solid angle || steradian || sr ||
|| frequency || hertz || Hz ||
|| force || newton || N ||
|| pressure, stress || pascal || Pa ||
|| energy, work, amount of heat || joule || J ||
|| power, radiant flux || watt || W ||
|| electric charge || coulomb || C ||
|| electric potential difference, electromotive force || volt || V ||
|| capacitance || farad || F ||
|| electric resistance || ohm || Ω ||
|| electric conductance || siemens || S ||
|| magnetic flux || weber || Wb ||
|| magnetic flux density || tesla || T ||
|| inductance || henry || H ||
|| Celsius temperature || degree Celsius || °C ||
|| luminous flux || lumen || lm ||
|| illuminance || lux || lx ||
|| activity referred to a radionuclide || becquerel || Bq ||
|| absorbed dose, specific energy, kerma || gray || Gy ||
|| ambient/directional/personal dose equivalent || sievert || Sv ||
|| catalytic activity || katal || kat ||

== Table 6. Non-SI Units Accepted for Use with the International System of Units ==

|| **Quantity** || **Name** || **Symbol** ||
|| time || minute || min ||
|| || hour || h ||
|| || day || d ||
|| plane angle || degree || ° ||
|| || minute || ′ ||
|| || second || ″ ||
|| area || hectare || ha ||
|| volume || litre || L ||
|| mass || tonne || t ||

== Section 5.2 Unit Names ==

Unit names are normally printed in roman (upright) type, and they are treated like ordinary nouns. In English, the names of units start with a lower-case letter (even when the symbol for the unit begins with a capital letter), except at the beginning of a sentence or in capitalized material such as a title. In keeping with this rule, the correct spelling of the name of the unit with the symbol °C is “degree Celsius” (the unit degree begins with a lower-case d and the modifier Celsius begins with an upper-case C because it is a proper name).

Although the values of quantities are normally expressed using symbols for numbers and symbols for units, if for some reason the unit name is more appropriate than the unit symbol, the unit name should be spelled out in full. E.g., 2.6 m/s, or 2.6 meters per second.

When the name of a unit is combined with the name of a multiple or sub-multiple prefix, no space or hyphen is used between the prefix name and the unit name. The combination of prefix name plus unit name is a single word. E.g., milligram, not milli-gram.

In both English and French, when the name of a derived unit is formed from the names of individual units by multiplication, then either a space or a hyphen is used to separate the names of the individual units. E.g., pascal second, or pascal-second.

== External links ==
*[http://www.ni.com/pdf/manuals/321393d.pdf LabVIEW Development Guidelines (PDF)]
*[http://www.amazon.com/LabVIEW-National-Instruments-Virtual-Instrumentation/dp/0131458353 The LabVIEW Style Book (Amazon.com)]

[[Category:LabVIEW fundamentals]]
[[Category:Beginner]]

Quick Drop

2024-12-04T21:01:14Z

Dnatt: Major edits and reorganization of Quick Drop page

== Introduction ==
Quick Drop was introduced in LabVIEW 8.6 as an alternative to using the palettes for dropping objects on the front panel and block diagram. You can press Ctrl-Space to launch the Quick Drop window:
[[Image:Quick_Drop_Window.png|Quick Drop]]
If the front panel is active when you press Ctrl-Space, you will see a list of front panel objects to drop. If the block diagram is active when you press Ctrl-Space, you will see a list of block diagram objects to drop.

== Community ==
The Quick Drop Enthusiasts community page on ni.com provides several resources and discussion threads around Quick Drop. You can visit this community at https://www.ni.com/quickdrop.

== Drop Mechanisms ==
You only need to type enough text in Quick Drop so that the first item in the list is the desired drop object:
[[Image:Quick_Drop_Top_Item.png|Quick Drop Top Item]]
At this point, you can drop the item with one of three possible approaches:
<ol>
<li>Press Enter - Pressing Enter while Quick Drop is active will place the top list item on your cursor, which you can then use to drop the object in the desired location.</li>
<li>Double-Click List Item - You can double-click the top item in the list, which will place it on your cursor, which you can then use to drop the object in the desired location.</li>
<li>Super Quick Drop - Click on the panel or diagram in the location where you want to drop the item. It will be placed wherever you click. This is the fastest, most efficient way to use Quick Drop.</li>
</ol>

== Object Shortcuts ==
Instead of typing the entire name of a drop obejct, you can use an object shortcut to define a short name (i.e. 2 or 3 characters) for the object. For example, 'cs' for Case Structure, or 'wat' for Wait (ms). LabVIEW ships with many pre-defined object shortcuts for commonly-dropped objects, but you can also configure your own by clicking 'Configure' in Quick Drop and selecting either 'Front Panel' or 'Block Diagram' in the resulting configuration dialog:
[[Image:Quick_Drop_Configure_-_Object_Shortcuts.png|Quick Drop Configure Object Shortcuts]]
As a general rule, you'll want most of your object shortcuts to be typeable with your left hand only. This allows you to keep your left hand on the keyboard and your right hand on the mouse, and with Super Quick Drop (see above), your hands won't need to leave those default positions while dropping objects.
To become more familiar with the object shortcuts that ship with LabVIEW, check out the [https://forums.ni.com/t5/Quick-Drop-Enthusiasts/Falling-Shortcuts/m-p/3537204 Falling Shortcuts!] game on the Quick Drop Enthusiasts community.

== Ctrl-Key Shortcuts ==

=== Basic Functionality ===
While Quick Drop is open, you can press a Ctrl-Key shortcut to perform a variety of helpful editor operations. The full list of installed Ctrl-Key shortcuts can be seen by clicking 'Configure' in Quick Drop and selecting 'Ctrl-Key Shortcuts:
[[Image:Quick_Drop_Configure_-_Ctrl_Key_Shortcuts.png|Quick Drop Configure Ctrl-Key Shortcuts]]
You can change the default mapping of various shortcuts in this dialog. Here are some of the most commonly-used Ctrl-Key shortcuts:
<ol>
<li>Ctrl-D: Create controls and indicators (or constants) for unwired terminals on selected object(s).</li>
<li>Ctrl-R: Remove selected object(s) and rewire remaining objects.</li>
<li>Ctrl-T: Move control terminal labels to the left and indicator terminal labels to the right.</li>
<li>Ctrl-P: Replace selected object(s) with the object specified in Quick Drop.</li>
<li>Ctrl-I: Insert the object specified in Quick Drop on the selected wire(s).</li>
<li>Ctrl-B: Change the class name (or configured property/method) of the selected object(s).</li>
<li>Ctrl-W: Wire selected objects together.</li>
<li>Ctrl-K: Assign a text-based icon to the current VI with the text specified in Quick Drop.</li>
</ol>

=== Custom Ctrl-Key Shortcut Plugins ===
The Ctrl-Key Shortcut feature in Quick Drop is plugin-based, which means you can write your own Ctrl-Key shortcuts. See [http://labviewartisan.blogspot.com/2012/11/getting-started-with-custom-quick-drop.html this blog post] for more information on writing your own Ctrl-Key shortcuts. The Quick Drop Enthusiasts community maintains a list of community shortcuts [https://forums.ni.com/t5/Quick-Drop-Enthusiasts/List-of-Community-Quick-Drop-Keyboard-Shortcuts/gpm-p/3527206 here].

== Quick Drop Miscellany ==
<ul>
<li>To launch Quick Drop in LabVIEW for MacOS, press Cmd-Shift-Space.</li>
<li>To launch Quick Drop in LabVIEW on Chinese Windows, press Ctrl-Shift-Space</li>
<li>You can change the keyboard shortcut for Quick Drop to something other than Ctrl-Space by going to Tools > Options > Menu Shortcuts, selecting View > Quick Drop in the Menu Item list, and pressing a new Ctrl-Key combination.</li>
<li>By default, Quick Drop uses keyword matching to support inexact string matches. For example, you could type 'Exit', and it would list 'Quit LabVIEW' in the list. This feature is handy, but causes Quick Drop to be slightly less responsive to key presses, as it takes more time to perform keyword matching. To disable this functionality, you can launch Quick Drop, press 'Configure', go to the 'Options' tab, and deslect 'Enable relevancy-based search'. This will cause Quick Drop to only perform simple string matches to object names, but will also enable faster responsiveness to key presses.</li>
</ul>

[[Category:LabVIEW fundamentals]]

File:Quick Drop Top Item.png

2024-12-04T20:33:14Z

Dnatt: Quick Drop Window displaying a drop item as the top item in the list Category:LabVIEW fundamentals

== Summary ==
Quick Drop Window displaying a drop item as the top item in the list

[[Category:LabVIEW fundamentals]]

File:Quick Drop Configure - Options.png

2024-12-04T20:24:47Z

Dnatt: Configuration dialog for additional Quick Drop options Category:LabVIEW fundamentals

== Summary ==
Configuration dialog for additional Quick Drop options

[[Category:LabVIEW fundamentals]]

File:Quick Drop Configure - Ctrl Key Shortcuts.png

2024-12-04T20:24:25Z

Dnatt: Configuration dialog for Quick Drop Ctrl-Key Shortcut mappings Category:LabVIEW fundamentals

== Summary ==
Configuration dialog for Quick Drop Ctrl-Key Shortcut mappings

[[Category:LabVIEW fundamentals]]

File:Quick Drop Configure - Object Shortcuts.png

2024-12-04T20:23:57Z

Dnatt: Configuration dialog for Quick Drop object shortcuts Category:LabVIEW fundamentals

== Summary ==
Configuration dialog for Quick Drop object shortcuts

[[Category:LabVIEW fundamentals]]

File:Quick Drop Window.png

2024-12-04T20:23:27Z

Dnatt: The main Quick Drop window Category:LabVIEW fundamentals

== Summary ==
The main Quick Drop window

[[Category:LabVIEW fundamentals]]

Events

2024-12-03T23:22:47Z

Dnatt: Add section with links to recurring events (AoC and SoL)

{| class="wikitable" style="width: 75%; margin:auto;"
! colspan=2 style="background-color:#616366; font-size:200%; border:none; margin:0; padding:.3em; color:#FFD500; text-align:center;" | Community Calendar
|-
! style="background-color:#FFD500; border:none; margin:0; color:#000000; text-align:center;" | '''Do you want your event added to the Community Calendar?'''
| rowspan=2 style="text-align:center; width:75%;background-color:#FFFFFF;"| {{#widget:Google Calendar}}
|-
| style="width:25%; vertical-align:top;" | To get your event on the calendar:
# Create Meeting Invitation
# Invite the LabVIEWWiki as a guest
The email address is:
<div style="text-align:center;">'''''labviewwiki -at- gmail -dot- com'''''</div>
<div style="font-size:75%; text-align:center;">(written this way to avoid the spammers)</div>
Be sure to include event details such as:
* Event Title
* Dates and Times
* How to register or rsvp if required
* Where the event is located or how to connect if virtual
* Any other details (abstract/topic, links to websites, etc.)
|}

{| class="wikitable" style="width: 75%; margin:auto;"
! colspan=2 style="background-color:#616366; font-size:200%; border:none; margin:0; padding:.3em; color:#FFD500; text-align:center;" | Event Pages
|-
! style="background-color:#616366; color:#FFD500; text-align:center;" | '''Event Archive'''
! style="background-color:#616366; color:#FFD500; text-align:center;" | '''Upcoming Events'''
|-
| rowspan = 5 style="width:25%; vertical-align:top; background-color:#EFEFEF;" | {{#tree:
*{"expanded":true}[[Americas CLA Summit]]
**[[Americas CLA Summit 2015]]
**[[Americas CLA Summit 2016]]
**[[Americas CLA Summit 2017]]
**[[Americas CLA Summit 2018]]
**[[Americas CLA Summit 2019]]
*{"expanded":true}[[European CLA Summit]]
**[[European CLA Summit 2018]]
**[[European CLA Summit 2019]]
*{"expanded":true}[[GDevCon]]
**[[GDevCon-1|GDevCon #1]]
**[[GDevCon-2|GDevCon #2]]
**[[GDevCon-3|GDevCon #3]]
**[[GDevCon-4|GDevCon #4]]
**[[GDevCon-5|GDevCon #5]]
*{"expanded":true}[[GDevCon ANZ]]
**[[GDevCon ANZ 1|GDevCon ANZ #1]]
**[[GDevCon ANZ 2|GDevCon ANZ #2]]
*{"expanded":true}[[GDevCon North America]]
**[[GDevCon North America 2021]]
**[[GDevCon North America 2022]]
**[[GDevCon North America 2023]]
**[[GDevCon North America 2024]]
*{"expanded":true}[[GLA Summit]]
**[[GLA Summit 2020]]
**[[GLA Summit 2021]]
**[[GLA Summit 2022]]
**[[GLA Summit 2024]]
*{"expanded":true}[[LUGE]]
**[[LUGE 2020]]
**[[LUGE 2021]]
**[[LUGE 2022]]
*{"expanded":true}[[NI Connect]]
**[[NI Connect 2021]]
**[[NI Connect 2022]]
**[[NI Connect 2023]]
**[[NI Connect 2024]]
*{"expanded":true}NIDays
**[[NIDays 2019]]
*{"expanded":true}[[NIWeek]]
**[[NIWeek 1995]]
**[[NIWeek 1996]]
**[[NIWeek 1997]]
**[[NIWeek 1998]]
**[[NIWeek 1999]]
**[[NIWeek 2000]]
**[[NIWeek 2001]]
**[[NIWeek 2002]]
**[[NIWeek 2003]]
**[[NIWeek 2004]]
**[[NIWeek 2005]]
**[[NIWeek 2006]]
**[[NIWeek 2007]]
**[[NIWeek 2008]]
**[[NIWeek 2009]]
**[[NIWeek 2010]]
**[[NIWeek 2011]]
**[[NIWeek 2012]]
**[[NIWeek 2013]]
**[[NIWeek 2014]]
**[[NIWeek 2015]]
**[[NIWeek 2016]]
**[[NIWeek 2017]]
**[[NIWeek 2018]]
**[[NIWeek 2019]]
*{"expanded":true}[[VIWeek]]
**[[VIWeek 2020]]
}}
| style="width:75%;background-color:#FFFFFF;vertical-align:top;" | <gallery class="center" heights=90px widths=90px style="text-align:center">
File:GDevConButton.png|link=GDevCon-5|[[GDevCon-5|GDevCon #5 (Stuttgart, 11-13 September 2024)]]
File:GDevCon-ANZButton.png|link=GDevCon ANZ 2|[[GDevCon ANZ 2|GDevCon ANZ #2 (27-28 May 2025)]]
</gallery>
|-
! style="background-color:#616366; color:#FFD500; text-align:center;" | '''Recurring Events'''
|-
| style="width:75%;background-color:#FFFFFF;vertical-align:top;" | <gallery class="center" heights=90px widths=90px style="text-align:center">
File:LVAoC.png|link=Advent of Code|[[Advent of Code|Advent of Code (December)]]
File:Summer_of_LabVIEW_logo.png|link=Summer of LabVIEW|[[Summer of LabVIEW|Summer of LabVIEW (June, July, August)]]
</gallery>
|-
| style="background-color:#616366; color:#FFD500; text-align:center;" | '''Past Events'''
|-
| style="width:75%;background-color:#FFFFFF;vertical-align:top;" | <gallery class="center" heights=90px widths=90px style="text-align:center">
File:GDevCon-NAButton.png|link=GDevCon North America 2024|[[GDevCon North America 2024|GDevCon North America 2024 (23-25 July 2024)]]
File:NIButton.png|link=NI Connect 2024|[[NI Connect 2024|NI Connect 2024 (Austin—20-22 May 2024)]]
File:GLASummitButton.png|link=GLA Summit 2024|[[GLA Summit 2024|GLA Summit 2024 (25-26 March 2024)]]
File:GDevCon-ANZButton.png|link=GDevCon ANZ 1|[[GDevCon ANZ 1|GDevCon ANZ #1 (24-25 October 2023)]]
File:GDevConButton.png|link=GDevCon-4|[[GDevCon-4|GDevCon #4 (Glasgow—20-21 September 2023)]]
File:GDevCon-NAButton.png|link=GDevCon North America 2023|[[GDevCon North America 2023|GDevCon North America 2023 (18-20 July 2023)]]
File:NIButton.png|link=NI Connect 2023|[[NI Connect 2023|NI Connect 2023 (Austin—23-24 May 2023)]]
File:NIButton.png|link=NI Connect 2022|[[NI Connect 2022|NI Connect 2022 (Munich— 9 November 2022)]]
File:GLASummitButton.png|link=GLA Summit 2022|[[GLA Summit 2022|GLA Summit 2022 (14-15 November 2022)]]
File:NIButton.png|link=NI Connect 2022|[[NI Connect 2022|NI Connect 2022 (Shanghai— 2023 TBD)]]
File:GDevConButton.png|link=GDevCon-3|[[GDevCon-3|GDevCon #3 (Amsterdam—8-9 September 2022)]]
File:GDevCon-NAButton.png|link=GDevCon North America 2022|[[GDevCon North America 2022|GDevCon North America 2022 (19-21 July 2022)]]
File:NIButton.png|link=NI Connect 2022|[[NI Connect 2022|NI Connect 2022 (Austin—24-25 May 2022)]]
File:LUGE.png|link=LUGE 2022|[[LUGE 2022|LUGE 2022 (??? 2022)]]
File:GLASummitButton.png|link=GLA Summit 2021|[[GLA Summit 2021|GLA Summit 2021 (15-16 November 2021)]]
File:GDevCon-NAButton.png|link=GDevCon North America 2021|[[GDevCon North America 2021|GDevCon North America 2021 (20-21 October 2021)]]
File:NIButton.png|link=NI Connect 2021|[[NI Connect 2021|NI Connect 2021 (27-28 July 2021)]]
File:LUGE.png|link=LUGE 2021|[[LUGE 2021|LUGE 2021 (??? 2021)]]
File:GLASummitButton.png|link=GLA Summit 2020|[[GLA Summit 2020|GLA Summit 2020 (9-10 November 2020)]]
File:VIWeekIcon.png|link=VIWeek 2020|[[VIWeek 2020|VIWeek 2020 (17-23 May 2020)]]
File:LUGE.png|link=LUGE 2020|[[LUGE 2020|LUGE 2020 (7 May 2020)]]
File:CLA-AButton.png|link=Americas CLA Summit 2019|[[Americas CLA Summit 2019|Americas CLA Summit 2019 (25-27 Sept 2019)]]
File:GDevConButton.png|link=GDevCon-2|[[GDevCon-2|GDevCon #2 (21-22 Aug 2019)]]
File:NIEagleButton.png|link=NIWeek 2019|[[NIWeek 2019|NIWeek 2019 (20-23 May 2019)]]
File:CLA-EButton.png|link=European CLA Summit 2019|[[European CLA Summit 2019|European CLA Summit 2019 (2-4 Apr 2019)]]
File:CLA-AButton.png|link=Americas CLA Summit 2018|[[Americas CLA Summit 2018]]
File:GDevConButton.png|link=GDevCon-1|[[GDevCon-1|GDevCon #1 (4-5 Sep 2018)]]
File:CLA-EButton.png|link=European CLA Summit 2018|[[European CLA Summit 2018]]
File:NIEagleButton.png|link=NIWeek 2018|[[NIWeek 2018|NIWeek 2018 (21-24 May 2018)]]
File:CLA-AButton.png|link=Americas CLA Summit 2017|[[Americas CLA Summit 2017]]
File:NIEagleButton.png|link=NIWeek 2017|[[NIWeek 2017|NIWeek 2017 (22-25 May 2017)]]
File:NIEagleButton.png|link=NIWeek 2016|[[NIWeek 2016|NIWeek 2016 (1-4 Aug 2016)]]
File:CLA-AButton.png|link=Americas CLA Summit 2016|[[Americas CLA Summit 2016]]
File:NIEagleButton.png|link=NIWeek 2015|[[NIWeek 2015|NIWeek 2015 (3-6 Aug 2015)]]
File:CLA-AButton.png|link=Americas CLA Summit 2015|[[Americas CLA Summit 2015|Americas CLA Summit 2015 (2-5 March 2015)]]
File:NIEagleButton.png|link=NIWeek 2014|[[NIWeek 2014|NIWeek 2014 (4-7 Aug 2014)]]
File:NIEagleButton.png|link=NIWeek 2013|[[NIWeek 2013|NIWeek 2013 (5-8 Aug 2013)]]
File:NIEagleButton.png|link=NIWeek 2012|[[NIWeek 2012|NIWeek 2012 (6-9 Aug 2012)]]
File:NIEagleButton.png|link=NIWeek 2011|[[NIWeek 2011|NIWeek 2011 (2-4 Aug 2011)]]
File:NIEagleButton.png|link=NIWeek 2010|[[NIWeek 2010|NIWeek 2010 (3-5 Aug 2010)]]
File:NIEagleButton.png|link=NIWeek 2009|[[NIWeek 2009|NIWeek 2009 (4-6 Aug 2009)]]
File:NIEagleButton.png|link=NIWeek 2008|[[NIWeek 2008|NIWeek 2008 (5-7 Aug 2008)]]
File:NIEagleButton.png|link=NIWeek 2007|[[NIWeek 2007|NIWeek 2007 (7-9 Aug 2007)]]
File:NIEagleButton.png|link=NIWeek 2006|[[NIWeek 2006|NIWeek 2006 (8-10 Aug 2006)]]
File:NIEagleButton.png|link=NIWeek 2005|[[NIWeek 2005|NIWeek 2005 (16-18 Aug 2005)]]
File:NIEagleButton.png|link=NIWeek 2004|[[NIWeek 2004|NIWeek 2004 (17-19 Aug 2004)]]
File:NIEagleButton.png|link=NIWeek 2003|[[NIWeek 2003|NIWeek 2003 (13-15 Aug 2003)]]
File:NIEagleButton.png|link=NIWeek 2002|[[NIWeek 2002|NIWeek 2002 (14-16 Aug 2002)]]
File:NIEagleButton.png|link=NIWeek 2001|[[NIWeek 2001|NIWeek 2001 (2001)]]
File:NIEagleButton.png|link=NIWeek 2000|[[NIWeek 2000|NIWeek 2000 (2000)]]
File:NIEagleButton.png|link=NIWeek 1999|[[NIWeek 1999|NIWeek 1999 (18-20 Aug 1999)]]
File:NIEagleButton.png|link=NIWeek 1998|[[NIWeek 1998|NIWeek 1998 (25-27 Aug 1998)]]
File:NIEagleButton.png|link=NIWeek 1997|[[NIWeek 1997|NIWeek 1997 (19-21 Aug 1997)]]
File:NIEagleButton.png|link=NIWeek 1996|[[NIWeek 1996|NIWeek 1996 (6-8 Aug 1996)]]
File:NIEagleButton.png|link=NIWeek 1995|[[NIWeek 1995|NIWeek 1995 (1995)]]
</gallery>
|}

[[Category:Events]]

Summer of LabVIEW

2024-12-03T23:22:09Z

Dnatt: initial SoL page

[https://summeroflabview.com/ Summer of LabVIEW] was started originally in 2022 by Derrick Bommarito and Darren Nattinger as a programming competition for the NI Sales and Support organization, building both excitement and prowess within NI for NI's own flagship software product.

In subsequent years it has become a free worldwide event open to all LabVIEW programmers. The challenges are presented throughout the months of June, July, and August every year.

To learn more, visit https://summeroflabview.com.

[[Category:Coding Challenge]]

File:Summer of LabVIEW logo.png

2024-12-03T22:52:16Z

Dnatt:

[[Category:Coding Challenge]]

File:Summer of LabVIEW logo.png

2024-12-03T22:51:36Z

Dnatt:

File:LVAoC.png

2024-12-03T22:45:43Z

Dnatt:

== Summary ==
LabVIEW Advent of Code logo

[[Category:Coding Challenge]]

File:LVAoC.png

2024-12-03T22:41:01Z

Dnatt: LabVIEW Advent of Code logo

== Summary ==
LabVIEW Advent of Code logo

Advent of Code

2024-12-03T22:14:24Z

Dnatt: Created new LVWiki article on Advent of Code

== Introduction ==
[https://adventofcode.com Advent of Code] is an Advent calendar of free daily programming puzzles during the month of December. The puzzles are geared toward a variety of skill sets and skill levels, typically starting off easy, and getting progressively more difficult each day. Anyone who solves the puzzles using LabVIEW can join the LabVIEW leaderboard and compete with fellow LabVIEW programmers.

== Getting Started ==
Follow these steps to join the LabVIEW leaderboard:
<ol>
<li>Go to https://adventofcode.com.</li>
<li>Select [Log In] in the top menu.</li>
<li>Identify yourself using one of the suggested services: [GitHub] [Google] [Twitter] [Reddit]</li>
<li>Select [Leaderboard] in the top menu.</li>
<li>Select [Private Leaderboard] in the description.</li>
<li>Enter the code for the LabVIEW leaderboard and select [Join] : 987334-ea1e3697</li>
<li>Verify that your username appears in the leaderboard.</li>
<li>To visit the leaderboard on a future visit to the Advent of Code website, select [Leaderboard] in the top menu.</li>
<li>Select [View] for the leaderboard with the name "Stefan Lemmens".</li>
</ol>

== Solving Advent of Code Puzzles ==
To solve the puzzles you can select [Calendar] in the top menu. A new puzzle will appear each day from December 1st to 25th. You can access a new puzzle every day starting at 11pm CST. 
Note that you can click Events in the top menu to access Advent of Code puzzles from previous years.

== Discord Server ==
There is a LabVIEW Advent of Code Discord server to discuss the problems and solutions. It's a nice way to learn from each other and see how the same problem can be solved in many different ways. You can use this link to access this server: https://discord.gg/AgKWURdGak 
If you join the LabVIEW AoC Discord server, please introduce yourself on the introductions channel.

== AoC++ ==
If you're feeling charitable, you can support Advent of Code financially by clicking [AoC++] in the top menu.

== Credits ==
Thanks to LabVIEW Champion Stefan Lemmens for creating the LabVIEW AoC Leaderboard, as well as providing most of the material seen on this page.

[[Category:Coding Challenge]]

Category:Coding Challenge

2024-12-03T21:48:59Z

Dnatt: Created new 'Coding Challenge' category

[[Category:Events]]

Editor Accelerators for LabVIEW Beginners

2024-11-16T02:18:51Z

Dnatt: A minimum list of the most useful keyboard shortcuts and mouse gestures for new LabVIEW programmers

The LabVIEW environment has hundreds of built-in gestures for accelerating editor operations. [[Keyboard shortcut|This page]] provides a complete list of these tools.

'''If you are new to LabVIEW''', the tables below list the keyboard shortcuts and mouse gestures for the '''most common''' editor operations you will perform on a daily basis. Note that shortcuts common to most applications (cut, copy, paste, save, etc.) are not listed.

== Keyboard Shortcuts ==
{| class="wikitable"
|-
! Shortcut !! Operation
|-
| Ctrl-Space || [[Quick Drop]] - An alternative to the palettes for quick, name-based object placement on the front panel and block diagram
|-
| Ctrl-E || Switch between the front panel and block diagram of a VI
|-
| Ctrl-H || Launch the Context Help window, which displays documentation about the current object under the mouse cursor
|-
| Ctrl-I || Show the Properties settings of the current VI
|-
| Ctrl-R || Run the current VI
|-
| Ctrl-Shift-Z || Redo the last undo (Ctrl-Z) operation
|-
| Shift-Arrow Key || Moves the selected object(s) 8 pixels in the arrow direction
|-
| Esc || While wiring, cancels the current wiring operation
|-
| 'Enter' on the numeric keypad || Commit current value in a string (different from the main 'Enter' key, which will add a new line to a string)
|}

== Mouse Gestures ==
{| class="wikitable"
|-
! Gesture !! Operation
|-
| Ctrl-Drag selected object(s) || Create a copy of selected object(s)
|-
| Ctrl-Drag in empty panel/diagram space || Add space
|-
| Ctrl-Alt-Drag in empty panel/diagram space || Remove space
|-
| Ctrl-Scroll || In LabVIEW 2023 Q3 and later, zoom in and out on the block diagram
|-
| Ctrl-Scroll in empty diagram space || In LabVIEW 2023 Q1 and earlier, scroll through the frames of a multi-frame structure
|-
| Ctrl-Shift-Scroll in empty diagram space || In LabVIEW 2023 Q3 and later, scroll through the frames of a multi-frame structure
|-
| Single-click a wire || Select the current wire segment
|-
| Double-click a wire || Select the current wire branch
|-
| Triple-click a wire || Select the entire current wire
|-
| Single-click while wiring || Tack down a wire junction where you clicked, and continue wiring
|-
| Double-click while wiring || In LabVIEW 2023 Q3 and later, create a control or indicator connected to that wire
|-
| Double-click while wiring || In LabVIEW 2023 Q1 and earlier, create a broken wire that ends where you double-clicked
|-
| Alt-Double-click while wiring || In LabVIEW 2023 Q3 and later, create a broken wire that ends where you double-clicked
|-
| Ctrl-Double-click while wiring || In LabVIEW 2023 Q3 and later, create a constant connected to that wire
|-
| Shift-click an object || Add the object to the current selection
|-
|-Shift-Drag selected object(s) || Move selected object(s) along a single axis
|-
| Double-click empty space || Create a free label
|-
| Double-click subVI || Open the front panel of the subVI
|-
| Drag VI onto diagram from project || Place the VI as a subVI on the diagram
|}

[[Category:Development Environment]]

LabVIEW Learning Materials

2024-10-01T22:07:15Z

Dnatt: Cleaned up bad links, added new good links, added video lengths and document types

{{see also|category:LabVIEW fundamentals}}

This page provides a recommended set of resources for LabVIEW programmers. The links are a collection of white papers, YouTube videos and formal learning content.

=LabVIEW Programming Basics =

==Introduction to the LabVIEW Environment==
* [https://www.youtube.com/watch?v=ZHNlKyYzrPE&list=PLB968815D7BB78F9C LabVIEW Overview] - ''(Playlist, 40 videos)'' Tutorials introducing the environment, data structures, wiring, visualization and basic hardware connectivity. Note that the links to several individual videos from this long playlist are included in relevant sections below.
* [https://www.youtube.com/watch?v=o3II4GUfyXw&list=PL4EGtL-9IHCGPRC9iBWV1qbrUy0f3Sjq4 How To... in LabVIEW] ''(Playlist, 13 videos)'' Masterclass on performing various beginner-level tasks in LabVIEW

==Data Types & Structures==
* [https://www.youtube.com/watch?v=dvShgNdY_GE Data Types Overview] ''(Video, 4:25)''
* [https://www.youtube.com/watch?v=_GlQ1riWjPc Introduction to arrays] ''(Video, 3:51)''
* [https://www.youtube.com/watch?v=dEsVDhrdhk4 Using shift registers to save data between loop iterations] ''(Video, 3:00)''
* [https://www.youtube.com/watch?v=I7FPlLzc7D0 Overview of For Loops] ''(Video, 7:30)''
* [https://www.youtube.com/watch?v=OZbaqCgyjdM All About Collection Data Types] ''(Video, 56:18)'' An in-depth introduction to Strings, Arrays, Sets, and Maps.

==User Interface Design==
* [https://www.youtube.com/watch?v=eGlvOiqYVxg Using event structures to capture user interactions] ''(Video, 8:29)''
* [https://www.youtube.com/watch?v=jWWJKUpoois Introduction to Panes for UI Organization] ''(Video, 3:54)''
* [https://www.youtube.com/watch?v=nCvMLB_kH4Q Programmatically changing UI controls using property nodes] ''(Video, 7:10)''
* [https://www.youtube.com/watch?v=rBM_kTpUfDk Creating resizable user interfaces] ''(Video, 3:46)''
* [https://www.youtube.com/watch?v=qvhGH0TlCqs Creating Custom Controls] ''(Video, 5:17)''
* [https://www.youtube.com/watch?v=0-B7p061la4 Creating Professional User Interfaces] ''(Video, 48:50)''

==Asynchronous Messaging==
* [https://www.youtube.com/watch?v=8DFf-9kcRcs How to use Queues in LabVIEW] ''(Video, 5:27)''
* [https://www.youtube.com/watch?v=9og3QbfgBu0 How to use Notifiers in LabVIEW] ''(Video, 5:27)''

==Advanced Execution Control==
*[https://www.youtube.com/watch?v=dG8MaqO9c2A Launching clones of a VI] ''(Video, 9:23)''
*[https://www.youtube.com/watch?v=tfZIJejBnXg Launching a dynamically dispatched VI programmatically] ''(Video, 6:32)''

==Object-Oriented Programming (OOP) in LabVIEW==
* [https://www.ni.com/docs/en-US/bundle/labview/page/labview-object-oriented-programming.html LabVIEW Object-Oriented Programming] ''(Product Documentation)''
* [https://www.ni.com/en/support/documentation/supplemental/06/labview-object-oriented-programming--the-decisions-behind-the-de.html Decisions behind the design of OOP in LabVIEW] ''(Whitepaper)''
* [https://www.youtube.com/watch?v=GRDoyn1mNAI Simple Design Patterns to Improve Code Quality] ''(Video, 51:09)''

==Debugging Tools==
* [https://www.ni.com/en/support/documentation/supplemental/12/debugging-techniques-in-labview.html Basic Debugging Tools in LabVIEW] ''(Product Documentation)''
* [https://www.youtube.com/watch?v=BEGFsFbJmBg Programming Patterns and Frameworks] ''(Video, 59:45)'' Debugging LabVIEW Programming Patterns and Frameworks
* [https://www.youtube.com/watch?v=7zS3Q_K71XY Large Project Development Techniques] ''(Video, 44:53)'' Debugging Large LabVIEW projects
* [https://www.youtube.com/watch?v=9LypMAOb21s Built in LabVIEW Debugging Tools] ''(Video, 31:37)'' Utilizing debugging tools that are part of LabVIEW
* [https://www.youtube.com/watch?v=dTqKZmFFyw8 Run-time Code Analysis in LabVIEW] ''(Video, 37:07)'' Utilizing run-time code analysis tools to debug LabVIEW applications
* [https://www.youtube.com/watch?v=HKcEYkksW_o Ludicrous Ways to Fix Broken LabVIEW Code] ''(Video, 52:45)''

==Build and Deployment==
* [https://www.ni.com/en/support/documentation/supplemental/19/introduction-to-the-labview-application-builder.html Introduction to the LabVIEW Application Builder] ''(Product Documentation)'' Building Executables (EXEs) and Installers with LabVIEW

=LabVIEW Software Patterns=
* [https://www.ni.com/en/support/documentation/supplemental/22/design-considerations-in-labview-.html Design Considerations in LabVIEW] ''(Whitepaper)'' An introduction to several concepts required for the successful design of medium-to-complex LabVIEW applications

==State Machines==
* [https://www.ni.com/en/support/documentation/supplemental/16/simple-state-machine-template-documentation.html Introduction to State Machines] ''(Product Documentation)''
* [https://www.youtube.com/watch?v=aT0obtY3PRk State Machines Tutorial] ''(Video, 5:33)''

==Producer/Consumer Architecture==
* [https://www.ni.com/en/support/documentation/supplemental/21/producer-consumer-architecture-in-labview0.html Introduction to Producer/Consumer] ''(Product Documentation)''

==Queued Message Handlers (QMH)==
* [https://www.youtube.com/watch?v=-xXJt7yUEis Queued State Machine Overview] ''(Video, 6:24)''
* [https://www.ni.com/en/support/documentation/supplemental/21/using-a-queued-message-handler-in-labview.html Introduction to Queued Message Handlers] ''(Product Documentation)''

==Event-Driven Programming==
* [https://www.ni.com/en-us/support/documentation/supplemental/06/event-driven-programming-in-labview.html Event Structures in LabVIEW] ''(Product Documentation)''

=Tooling and Development Processes=
==Configuration Management==
* [https://blog.sasworkshops.com/gitting-started-with-git Getting Started with git] ''(Blog Post)''
* [https://www.youtube.com/watch?v=iVRKQCDeDjc Git Setup for LabVIEW] ''(Video, 17:07)''
* [https://blog.sasworkshops.com/the-easiest-way-to-setup-lvcompare-and-lvmerge Configuring diff and merge in LabVIEW] ''(Blog Post)''
* [https://learngitbranching.js.org Git command line tutorial] ''(Interactive Webpage)''

==Static Code Analysis==
* [https://ni.adobeconnect.com/p4kis57esy9 Introduction to the VI Analyzer] ''(Video, 41:44)''

==Dynamic Code Analysis and Performance Benchmarking==
* [https://www.youtube.com/watch?v=dHvk9OlCaAY Introduction to Dynamic Code Analysis] ''(Video, 9:34)''
* [https://www.youtube.com/watch?v=24t-D7_BmjM Quick! Drop Your VI Execution Time!] ''(Video, 54:18)''

==Unit Testing==
* [https://www.youtube.com/watch?v=AFNbdF7ZU6s Unit Testing with JKI VI Tester] ''(Video, 71:09)''
* [https://www.youtube.com/watch?v=5l-YQsUYR9g Unit Testing with JKI Caraya] ''(Video, 19:44)''

=Software Design Patterns and Best Practices=
* [https://www.ni.com/en/support/documentation/supplemental/09/software-engineering-with-labview.html Software Engineering with LabVIEW] A collection of resources covering several aspects of software engineering and design with LabVIEW

==Error Handling==
* [https://www.ni.com/docs/en-US/bundle/labview/page/handling-errors.html Error Handling Introduction] ''(Product Documentation)''
* [https://www.youtube.com/watch?v=UlOFcmwrsBA What to Expect When You're Expecting an Error] ''(Video, 60:20)'' Best practices for error generation and propagation in LabVIEW

=Software Frameworks=

==DQMH==

* [https://dqmh.org/ DQMH Homepage] The official page for DQMH, the world's most popular 3rd-party framework for LabVIEW
* [https://documentation.dqmh.org/dqmh DQMH Documentation]
* [https://wiki.dqmh.org/ DQMH Wiki] Your one-stop shop for everything you ever wanted to know about DQMH
* [https://www.youtube.com/@DQMHconsortium DQMH YouTube channel]
* [https://forums.ni.com/t5/DQMH-Consortium-Toolkits/bd-p/7120 DQMH Developer Community]NI community hub dedicated to DQMH discussions, where developers share best practices, examples, and troubleshooting tips
* [https://www.youtube.com/watch?v=OIAyii97moY Introduction to DQMH] ''(Video, 51:15)'' An introduction to DQMH for beginners, focusing on key features and benefits of DQMH
* [https://dqmh.org/simplifying-your-hardware-abstraction-layer-hal-with-lvoop-and-dqmh-part-1 Hardware Abstraction Layers (HAL) and DQMH] ''(Blog Post)''
* [https://www.youtube.com/watch?v=IdqTCubXuPE DQMH Module Templates] ''(Video, 5:14)'' Creating reusable DQMH module templates to speed development
* [https://www.youtube.com/watch?v=zXJqB2cA2nU DQMH Generic Networking] ''(Video, 51:09)'' Introduction to the Generic Network (GenNet) template for implementing DQMH-based Real-Time (RT) applications

==Actor Framework==

* [https://labviewwiki.org/wiki/Actor_Framework Actor Framework Resources ] ''(LabVIEW Wiki page)'' Resource page for Actor Framework introduction and tutorial materials.
* [https://www.youtube.com/watch?v=gz_6FTE1__8 The State of the Art for Actor Framework] ''(Video, 62:32)''
* [https://forums.ni.com/t5/Actor-Framework/ct-p/7001 Actor Framework Community] A dedicated forum where LabVIEW developers discuss the Actor Framework, share use cases, and troubleshoot challenges.

==Workers==
* [https://www.youtube.com/watch?v=Xyy8HLBpvjU Introduction to Workers] ''(Video, 51:54)'' Introduction to the Workers framework for LabVIEW

==Messenger==
* [https://www.youtube.com/watch?v=IxgSBkHu1RM Introduction to Messenger] ''(Video, 57:03)'' Introduction to the Messenger framework for LabVIEW

=Hardware and Instrumentation Connectivity=

==DAQmx Basics==
* [https://www.youtube.com/watch?v=ofzbA3keOYE Taking a Measurement with DAQmx] ''(Video, 4:55)''

==Instrument Control==
* [https://www.youtube.com/watch?v=-UUAa9UKj4E Introduction to LabVIEW for Instrument Control] ''(Video, 8:26)''

==Determinism and Real-Time Execution==
* [https://www.youtube.com/watch?v=JhHJMFrAa4A Getting Started with CompactRIO] ''(Video, 8:11)''

=Community and Best Practices=

==LabVIEW Style Guidelines==
* [https://labviewwiki.org/wiki/Style_Guide LabVIEW Wiki Style Guide]
* [https://dqmh.org/content/styleguide DQMH Style Guide]

==LabVIEW Community and User Groups==
* [https://www.ni.com/en-us/events.html NI Events] NI Events Page
* [https://labviewwiki.org/wiki/Events LabVIEW Events] LabVIEW Wiki Events Page

=Formal Training=
Formal training on LabVIEW is available from several providers. Offerings differ based on prior LabVIEW experience level and the preferred delivery method. Common delivery methods include:

* In-person instructor-led
* Remote instructor-led (usually through a web conference)
* Online self-paced (usually through a combination of pre-recorded lecture videos and exercise solution videos)
* Self-paced with a manual

NI has a [https://www.ni.com/en/shop/services/education-services.html suite of courses] ranging from beginner to advanced, as well as several specialty topics such as LabVIEW Real-Time and LabVIEW Connectivity. LabVIEW training is also available through [http://www.sixclear.com/ Sixclear], [https://www.udemy.com/topic/labview Udemy], [https://www.linkedin.com/learning/topics/labview LinkedIn] and [https://dsautomation.com/labview-fundamentals-1 DSA].

Recommended training courses for those with no knowledge of LabVIEW are [https://www.ni.com/en/shop/services/education-services/customer-education-courses/labview-core-1-course-overview.html NI LabVIEW Core 1] and [https://www.ni.com/en/shop/services/education-services/customer-education-courses/labview-core-2-course-overview.html NI LabVIEW Core 2] courses. All introductory courses are geared to a user with little to no LabVIEW experience and teach the proficiencies outlined by the [http://sine.ni.com/nips/cds/view/p/lang/en/nid/14438 Certified LabVIEW Associate Developer (CLAD)] exam, as well as simple data acquisition (DAQ) and instrument control.

Common arguments justifying formal training revolve around the idea that the sum cost of developers' time is greater than the cost of training because:
* the LabVIEW graphical programming paradigm is appreciably different than traditional text-based programming
* costly mistakes commonly occur when moving from simple LabVIEW applications to more complex applications, especially when developing parallel loop applications (see the [https://www.ni.com/en/support/documentation/supplemental/22/design-considerations-in-labview-.html Design Considerations in LabVIEW] document for more guidance regarding this development transition.

The DQMH Consortium offers an official [https://dqmh.org/training DQMH training course].

NI offers an official [https://www.ni.com/en/shop/services/education-services/customer-education-courses/actor-oriented-design-in-labview-course-overview.html Actor Framework training course].

[[Category:LabVIEW fundamentals]]
[[Category:Getting started]]
[[Category:Tutorials]]
[[Category:Introduction]]

Talk:LabVIEW VI Analyzer Toolkit

2024-08-09T21:57:20Z

Dnatt:

As I discuss in https://bit.ly/vianalyzerintro , the terms "VI Analyzer" and "VI Analyzer Toolkit" mean slightly different things. I would suggest going back to the title of "VI Analyzer" for this page.
: Good point, thanks for the clarification. The move was made based on the content of the page, which only mentions ''VI Analyzer Toolkit'' and thus should carry the title. But now [[VI Analyzer]] redirects to [[{{PAGENAME}}]]. Considering that both ''VI Analyzer'' and ''{{PAGENAME}}'' have distinct meaning, both pages are necessary and should reference each other. I made changes to both pages to clarify the distinction and reference each other. Feel free to update or change the pages if there are any mistakes. --[[User:Logmanoriginal|Logmanoriginal]] ([[User talk:Logmanoriginal|talk]]) 21:52, 9 August 2024 (UTC)
Your changes look good to me, thanks!

2019-06-03T18:07:39Z

Dnatt:

The '''ProjectItem''' class in VI Server allows you to inspect and modify items that appear in the Project window, such as VIs, virtual folders, classes, libraries, etc.

If you have a reference to a ProjectItem, you can read the ''TypeString'' property of the item to identify what kind of item it is:

[[File:TypeString property.png]]

This is the same string you can use for the ''Type'' parameter of the ''Get All Descendents'' method of the ProjectItem class to get all children of a ProjectItem that match a specific type:

[[File:Get All Descendents method.png]]

The following table lists valid ''TypeString'' values and their descriptions. Update this table with new type strings as you discover them.

{| class="wikitable"
|-
! TypeString !! Description
|-
| Build || the Build Specifications node under every target
|-
| cRIO Chassis || RT CompactRIO Target
|-
| Dependencies || the Dependencies node under every target
|-
| Directives || Directives items created for VIs by FPGA IP Builder
|-
| DLL || the Shared Library (DLL) node under Build Specifications
|-
| Document || non-LabVIEW files, like images, text files, etc.
|-
| ECATEbusSlave || EtherCAT slave device
|-
| ECATEnetSlave || EtherCAT slave device
|-
| ECATMaster || EtherCAT master device
|-
| EXE || the Application (EXE) node under Build Specifications
|-
| Elemental IO || IO Resource under an FPGA target
|-
| FPGA Base Clock || Base clock under an FPGA target
|-
| FPGA Component Level IP || RIO DRAM
|-
| FPGA Derived Clock || Derived clock under an FPGA target
|-
| FPGA FIFO || FIFO node under an FPGA target
|-
| FPGA Memory Block || Memory node under an FPGA target
|-
| FPGA Target || FPGA target (R-series device, cRIO target, etc.)
|-
| Folder || A virtual folder or an auto-populating folder
|-
| HTTP WebResources Container || The Web Resources folder under a Web Service node
|-
| IP Builder Target || IP Builder node under an FPGA target
|-
| Installer || the Installer node under Build Specifications
|-
| LVClass || A LabVIEW class
|-
| Library || A LabVIEW project library
|-
| Localhost || In some projects with a Real-Time target, the 'My Computer' target will have a type of 'Localhost' instead of 'My Computer'.
|-
| LVStatechart || A LabVIEW StateChart Module library
|-
| Module Container || The Real-Time Scan Resources node under an RT Chassis
|-
| My Computer || The My Computer node under the root Project
|-
| Packed Library || A packed project library (PPL)
|-
| Project || The root project item at the top of the Project Explorer
|-
| RIO C Series Module || A CompactRIO module that appears under the FPGA Target node under an RT CompactRIO Target
|-
| RIO Subresource || A resource under a RIO module. For example, an SD Card node.
|-
| RT CompactRIO || An RT CompactRIO Target
|-
| RT Generic || A generic RT Target
|-
| RT PXI Chassis || An RT PXI Target
|-
| RT Single-Board RIO || An RT Single-Board RIO Target
|-
| Robotics Environment Simulator || Simulated robot device
|-
| sbRIO Chassis || An sbRIO Chassis that appears under an RT Single-Board RIO target
|-
| Source Distribution || the Source Distribution node under Build Specifications
|-
| Startup VIs Container || The Startup VIs folder under a Web Service node
|-
| TestItem || A .lvtest file from the Unit Test Framework
|-
| TestVectorItem || A .lvvect file from the Unit Test Framework
|-
| TouchPanel || A Touch Panel target
|-
| VI || A Virtual Instrument (VI)
|-
| Variable || A shared variable node under a library or a target
|-
| Web Service || A Web Service node
|-
| XControl || An XControl library
|-
| XNode || An XNode library
|-
| Zip File || the Zip File node under Build Specifications
|-
| .NET Interop Assembly || the .NET Interop Assembly node under Build Specifications
|-
| {69A947D5-514E-4E75-818E-69657C0547D8} || The Real-Time Application node under Build Specifications (under an RT Target)
|-
| {9C5E1E31-72F0-41E9-9B17-FFBE4626F549} || The IP Build node under Build Specifications (under an IP Builder target)
|-
| {E661DAE2-7517-431F-AC41-30807A3BDA38} || the Package node under Build Specifications
|-
| {F4C5E96F-7410-48A5-BB87-3559BC9B167F} || The Compilation node under Build Specifications (under an FPGA target)
|}

[[Category:VI Scripting]]

ProjectItem

2019-05-31T23:17:35Z

Dnatt:

ProjectItem

2019-05-31T20:55:51Z

Dnatt: Created page with "The '''ProjectItem''' class in VI Server allows you to inspect and modify items that appear in the Project window, such as VIs, virtual folders, classes, libraries, etc. If y..."

File:Get All Descendents method.png

2019-05-31T20:32:16Z

Dnatt:

The Get All Descendents method of the ProjectItem class

File:TypeString property.png

2019-05-31T20:30:04Z

Dnatt:

The TypeString property of the ProjectItem class in VI Server.