Initializing Arrays In Labview

LabVIEW is a graphical language that allows you to program using visual blocks instead of text. It supports many data types, including arrays, Boolean, numeric, and string. You can use arrays in LabVIEW to manipulate large sets of data.

In this article, we discuss initialising arrays in detail and understand how to use various LabVIEW array functions to manipulate data efficiently.

Table of Contents:

• Arrays in LabVIEW
• Array functions
• Initialising Arrays
• Auto-indexing
• Insert into Array LabVIEW
• Delete from array LabVIEW
• LabVIEW Array Constant
• LabVIEW Array Indicator
• Best practices for working with arrays
• Frequently Asked Questions

Arrays in LabVIEW:

In LabVIEW, an array consists of elements and dimensions. Elements represent the data of the Array, whereas dimensions represent the array’s size.

A LabVIEW array is a data structure that can hold elements of the same data type. In other words, an array can be a control or an indicator but not a mixture of the two. 

A LabVIEW array simplifies storing large data sets and seamlessly supports ID, 2D, and 3D arrays.

Array functions in LabVIEW:

LabVIEW offers many array functions to create and manipulate arrays. The functions are in the Array Palette under the Functions Palette in the LabVIEW environment.

Below are some of the LabVIEW Array functions:

• Build Array – This function builds arrays using multiple elements or arrays.
• Index Array – This function returns the element or subarray of the n-dimension array at the index.
• Array size – This function returns the number of elements in each array dimension.  
• Array Subset – It extracts a subset from the array based on the starting index and subset length.
• Array Max/Min – This function finds an array's maximum and minimum values.
• Reshape Array – This function changes the array dimensions.
• Sort array – It arranges elements in an array in ascending or descending order.

Examples

Array functions automatically resize the dimensions of the input array that you wire.

Let’s look at some examples of using array functions to manipulate data.

Case 1: If you perform wiring a one-dimensional array using an array function, the function shows a single index input. If you wire a two-dimensional array to the same function, it shows two index inputs — one for the row index and one for the column index.

In the above Figure, input to the index array function is a 1D array. By providing the index value in the output, you get the array element corresponding to the index value.

Case 2: When connecting a 2D array as input, the index array function automatically resizes to receive two index inputs.

The above figure provides the index array function with a two-dimensional array as input. The row index value is provided to the index array function. At the output, you will get a one-dimensional array and a row of the two-dimensional input array.

Case 3: The index array function returns the same if you need a single array element from a 2D array input.

The above figure gives a two-dimensional array as input to the Index Array function. In this case, the array function receives both row and column index values. The output is an element based on the row and column indices provided.

If you would like to Enrich your career and become a professional in LabVIEW, then visit Mindmajix - A Global online training platform: “LabVIEW Training” Course. This course will help you to achieve excellence in this domain.

Initializing Arrays in LabVIEW:

LabVIEW allows you to initialise arrays. When you initialise an array, you define the number of elements in each dimension. In addition, you will determine the contents of the elements. Note that an uninitialised array has a dimension but no element.

You can use the initialise array function to create an n-dimensional array where each element is initialised according to the element's value. The elements can be any scalar type.

You can use the positioning tool to resize the function and increase the dimension of the output array.

The above figure shows the inputs and output of the initialise array function. Element and dimension size are the inputs, and the initialised array is the output. Here, the dimensions can be a number.

Example

Working and manipulating arrays is an important part of LabVIEW development. You will use both 1D and 2D arrays in all your applications.

In the LabVIEW platform, you can initialise an array on the front panel using the control palette:

Below is the step-by-step procedure for the same.

• First, drag and drop the empty array on the front panel
• Next, you can find a Control or Indicator (Numeric, Boolean, String, etc) and drag it into the empty array.
• You can create an array of controls or indicators.
• Drag the mouse in the index display to the left and increase the dimension. The image below shows this.

Auto-indexing in LabVIEW:

Auto-indexing in LabVIEW enables the automatic processing of arrays in loops. It supports iterating through every element of an array. So, you don’t need to specify indices manually.

In other words, if you wire an array to a 'For/While' Loop input tunnel, you will process every element in that array with auto-indexing.

If you auto-index an array output tunnel, the output array gets a new element from every loop iteration. The wire connecting the output tunnel to the array indicator gets bolder when it changes to an array at the loop border.

• Enabling auto-indexing

By default, LabVIEW enables auto-indexing for all the arrays you wire to ‘For’ loops. It occurs for every output tunnel that you build.

To apply auto-indexing, you can use the below procedure.

• • Right-click the tunnel 
  • Select ‘Enable indexing’ from the shortcut menu.
• Disabling auto-indexing

If you want to disable auto-indexing, right-click the tunnel. Another way is to go to the shortcut menu and select disable indexing. 

You can also disable auto-indexing if only the last value passes to the tunnel. You can use 'For’ loops to process array elements individually.

• How does auto-indexing work?

LabVIEW defines the count terminal to the array size if you apply auto-indexing to an array wired to a 'For' Loop input terminal. Therefore, you do not need to wire the count terminal.

Example:

The number of times the for loop runs is equal to the number of array elements. The image below shows this. The run arrow is generally broken if the 'For' Loop count terminal is not wired.

If you enable auto-indexing for two tunnels, the count changes to the smaller one out of the two. The image below depicts the same.

If you wire the count terminal as shown in the figure below, the count changes to the smaller of the two.

Related Article : LabVIEW Interview Questions

Insert into Array LabVIEW:

LabVIEW allows inserting an element in any row or column in 1D or 2D arrays. The key parameters used to insert elements into arrays are array, index, and element.

Use-case:

You insert elements into an array when adding data points in real-time. If you want to modify array elements based on needs, you insert elements into arrays.

How to add elements in arrays?

To add an element to a 1D array, follow the below procedure.

• Right-click the array on the front panel
• Then, choose Data Operations → Insert Element Before.

If you want to add a row or column to a 2D array, follow the procedure below.

• Right-click the array on the front panel
• Then, choose Data Operations → Insert Row Before/ Insert Column Before.

Alternatively, you can insert elements, columns, rows, and pages into arrays using the ‘Insert Into Array’ function.

Following is the step-by-step procedure to insert elements, rows, columns or pages in an array.

1. First, add an ‘Insert Into Array’ function on the block diagram.
2. Next, you can wire an array to the input of the ‘Insert into Array’ function. Here, the dimensions of the arrays don't need to be the same.
3. Resizing is done automatically by the function based on the Array's dimensions.
4. Identify the operation you want to perform from the Table below.
   
5. Complete the steps as mentioned in the Table.

Delete from array LabVIEW:

You can delete an element from a 1D array. Similarly, you can remove a subset from a two-dimensional array. 

How to delete elements from arrays?

The procedure below will help you delete an element in a 1-D array.

• Right-click the array element on the front panel 
• Select data operations → delete element.

Delete a row or column in a 2-D array using the following procedure.

• Right-click the array row/ column on the front panel
• Choose data operations → delete row or delete column.

You can also delete elements, columns, rows, and pages using the ‘delete from array’ function in arrays.

You can programmatically delete an element, row, column or page within an array. You can delete a row or a column from an array of 2D or more. Similarly, LabVIEW allows you to delete a page from an array of 3D or more.

Below is the step-by-step procedure to delete rows, columns, elements,  or pages in an array.

1. First, add the ‘Delete From Array’ function on the block diagram.
2. Next, you can Wire an array to the input of the ‘Delete From Array’ function. Here, the dimensions of the arrays are not significant.
3. Resizing is done by the function based on the dimensions of the Array.
4. Determine which operation you want to perform from the table below.
   
5. Complete the steps as mentioned in the Table.

LabVIEW Array Constant:

LabVIEW array constant is a predefined array that has fixed data. By passing array constants in an array, you can avoid modifying its elements in runtime.

You can use array constants to store constant data. Array constants are also helpful for passing data into a sub VI.

Use-case:

You can use array constants when:

• Initialising arrays with default values
• Working with a predefined set of values

How do you create an array constant?

In LabVIEW, You can create an array constant on the block diagram by merging an array with a constant. The constant can be a numeric, Boolean, path, string, or cluster.

You can create an array constant by copying or dragging an existing array on the front panel of the block diagram. You will create a constant of the same data type.

Alternatively, you can use the following step-by-step procedure to create an array constant in the block diagram.

1. Select an array constant from Functions → Programming → Arrays Palette
2. Add the array constant on the block diagram.
3. Now, the array shell appears on the block diagram.
4. This array shell will display an index on the left, an empty element on the right, and an optional label.
5. Now, you must place a constant in the array shell.
6. For example, you can place a numeric constant in the array shell.
7. The array shell automatically resizes to fit the object you have placed in it.
8. Once the object is placed in the array shell, you can define the data type of the array constant.

Related Article : Customizing Graphs And Charts In Labview 

LabVIEW Array Indicator:

You can use array indicators to display array contents on the front panel of your VI. This lets you view the array elements and monitor your program's output.

Interestingly, you can customise the appearance of array indicators, such as resizing or formatting them. It helps interpret the data during execution.

• How do you create array indicators?

You can build the LabVIEW front panel with controls and indicators. These are the VI's input and output terminals, respectively.

Controls can be knobs, push buttons, dials, or others. On the other side, Indicators are LEDs, graphs, and other displays.

Controls simulate input devices and supply data to the VI's block diagram. Indicators simulate output devices and display the data the block diagram acquires

The figure below shows that every control or indicator has a data type. The data types are numeric, Boolean, and string.

The numeric data type shown in Figure can be of various types, such as integer or real. The numeric control and indicator are the most commonly used numeric objects.

The Boolean data type represents data with only two parts, TRUE and FALSE or ON and OFF, as shown in Figure (b). You can use Boolean controls and indicators to enter and display Boolean values. Boolean objects simulate push buttons, switches, and LEDs.

Figure (c) shows the string data type, a sequence of ASCII characters. You can use string controls to receive text from a user, such as a password or user name, or indicators to display text to the user.

Best practices for working with arrays in LabVIEW:

Below is a list of some of the best practices you can apply to work efficiently with arrays in LabVIEW.

Let’s see them!

• Memory Optimization: Large arrays generally consume more memory. Therefore, avoiding using large arrays in applications is essential to prevent memory overflow issues.
• Accurate indexing: Be mindful when indexing array elements, especially with multi-dimensional arrays
• Using array constants: You can use array constants to initialise arrays, simplifying debugging and troubleshooting.
• Loop optimisation: You can leverage auto-indexing, which simplifies codes and improves performance when processing array elements.

Summary:

• We can use the initialise array function, Array literal, and indexing.
• The data type of the initial value must match with the desired data type of the array elements.
• Indexing helps to access and manipulate individual elements within an array. Auto-indexing enables loop optimisation.
• We must pre-allocate memory for large arrays while using loops
• We can use array indicators to display array elements in the front panel of VI.

Frequently Asked Questions

1. Why should I learn LabVIEW?

Ans: Here are the reasons why learning LabVIEW is crucial.

• LabVIEW is one of the most sought-after tools in various industries, including automation, manufacturing, robotics, and more.
• The graphical interface of LabVIEW helps to develop prototypes quickly.
• The LabVIEW user community is extensive. So, there are more possibilities to learn and grow.
• LabVIEW plays a key role in measurement and control, so learning it is a great advantage for working in such industries.

2. How does LabVIEW differ from PLC and SCADA?

Ans:  

• LabVIEW is a graphical language in which programming is done by wiring functional blocks together. PLC uses ladder logic, a traditional method.
• LabVIEW allows real-time control with additional RT modules, whereas PLC supports excellent real-time control. SCADA doesn’t offer real-time control.
• LabVIEW is a go-to tool for testing systems, prototyping, research and development, etc. PLA and SCADA are widely used in industry automation, machine control, monitoring, etc.

3. Which one is better- LabVIEW or Matlab?

Ans: You can employ LabVIEW for industry automation, control and monitoring, hardware interfacing, etc. On the other hand, you can use Matlab for data analysis, numerical computing, simulation, etc.

LabVIEW provides a visual interface to users for programming. Conversely, Matlab provides a command interface and demands coding knowledge. Hence, choosing between LabVIEW and Matlab depends on user needs and expertise in handling the tool.

4. How to become a competent LabVIEW developer?

Ans: 

• Gain a sound knowledge of the LabVIEW environment, data types, data flow, control structures, and more.
• Work on LabVIEW exercises and simple projects to strengthen your understanding.
• Engage with the LabVIEW user community to clear your doubts and polish your knowledge.
• Attend professional LabVIEW training programs. MindMajix offers job-oriented LabVIEW training for beginners and professionals.

Conclusion:

In short, initialising arrays in LabVIEW helps define the number of array elements and their contents. You can use array functions to manipulate arrays, including inserting, deleting, splitting, etc. Array constants and indicators are powerful tools for developing more dynamic applications.

Want to learn more about LabVIEW? Step into MindMajix's LabVIEW training. Attending this training will enhance your understanding of the LabVIEW environment and your expertise in managing large data sets and complex LabVIEW programming.