The first program is to display the text “Hello graphical interactive parallel multicore world” in the Front Panel window.

Right click on the Block Diagram window and select String Constant from the Functions >> Programming >> String menu.

Drag and drop the String Constant onto the Block Diagram window as show in Figure 3.

Figure 3: String Constant

Type in “Hello graphical interactive parallel multicore world.” in the String Constant.

Figure 4: "Hello…world" String Constant

Right click in the Front Panel window and select a String Indicator from the Controls >> Modern >> String & Path menu.

Figure 5: Select String Indicator

Drop it into the Front Panel window.

Figure 6: String Indicator

Return to the programming window. Notice the string terminal corresponding to the string indicator in the Front Panel window. As you approach the string constant from the right, the wiring terminal is highlighted and the pointer turns to wire spooler.

Figure 7: Wiring the G Diagram

Click the “Hello graphical interactive parallel multicore world” terminal and then click on the String Indicator triangular terminal to wire the terminals.

Figure 8: Wired G Block Diagram

Save your program as Hello, World.vi. Return to the Front Panel window. Click the run button (➯). You have successfully completed and executed your first G program.

Figure 9: Hello, World G Program Executed

The next program converts degrees from Fahrenheit to Celsius using the formula

C=59(F−32)C=59(F−32) size 12{C= { {5} over {9} } \( F - "32" \) } {}.

In the Block Diagram window, select the subtract, multiply and divide from the Functions >> Mathematics >> Numeric menu

Figure 10: Numeric Operations

Wire the subtract, multiply and divide functions as shown in Figure 11.

Figure 11: Subtract, Multiply and Divide

Right click on the upper left terminal of the subtract function and select Create >> Control from the pop-up menu.

Figure 12: Create Control

Re-label x as Fahrenheit and wire the terminal as shown in Figure 13.

Figure 13: Fahrenheit Input Control

Right click on the lower left terminal of the subtract function and select Create >> Constant and type 32.0.

Figure 14: Fahrenheit Numeric Constant

Repeat the process to generate numeric constants for the multiply and divide function with 5.0 and 9.0 respectively.

Figure 15: Fahrenheit Numeric Constants

To complete the program, right click on the right terminal of the divide function and select Create >> Indicator. Re-label x/y as Celsius. The final diagram is shown in Figure 16.

Figure 16: Fahrenheit to Celsius G Diagram

Switch to the Front Panel window to run the program. Save the program as Celsius.vi. Try various Fahrenheit values to see the corresponding Celsius values. You have successfully finished a Fahrenheit to Celsius calculator.

Figure 17

Click on empty space and drag to select the entire diagram.

Figure 18: Select G Block Diagram

The selected diagram is highlighted as shown in Figure 19

Figure 19: Selected G Block Diagram

From the Edit menu select Create SubVI to create a G function. The resulting diagram is shown in Figure 20.

Figure 20: Creating a Function

From the File menu select Save All and save the Untitled function as Fahrenheit to Celsius.vi.

Figure 21: Diagram with Function

Open the Fahrenheit to Celsius.vi by double clicking on the icon. Right click on the icon editor (upper right corner) and select Edit Icon…

Figure 22: Edit Icon

This pops-up the Icon Editor. Edit the function’s icon.

Figure 23: Icon Editor

After editing the icon, the function’s icon is shown in the upper right corner of the Front Panel window. Save the function, plug in various input values and run the function. Save the function.

Figure 24: Edited Icon

Close the Fahrenheit to Celsius function and return to the Celsius Block Diagram windows. The Celsius diagram reflects the updated Fahrenheit to Celsius icon

Figure 25: Function Calling

This program determines if a year is a leap year or not. A leap year is divisible by 4 but not by 100, except when it is divisible by 400. A number x is divisible by a number y if the remainder of x/y is identical to zero, i.e. Rem(x/y)=0 is true therefore

where And, Or and Not are Boolean operators.

For example:

1900 is not a leap year because it is divisible by 100

1970 is not a leap year because it is not divisible by 4

1980 is a leap year because it is divisible by 4 but not by 100

2000 is a leap year because it is divisible by 400

Start a new G program and right click on the Block Diagram window. Go to the Functions >> Programming >> Numeric menu in the Block Diagram window.

Figure 26: Quotient & Remainder Function

Select three copies of the Quotient & Remainder function and three numeric constants. Type in 4, 100 and 400 for the numeric constants and wire these constants to the lower input terminal (corresponding to the dividend) of the Quotient & Remainder function.

Figure 27: Leap Year Numeric Constants

From the Functions >> Programming >> Comparison menu, select 2 copies of the Equal to Zero function and one copy of the Not Equal to Zero function.

Figure 28: Comparison Functions

Organize the comparison operations as show in the diagram.

Figure 29

From the Functions >> Programming >> Boolean menu select the AND and OR operators

Figure 30: Boolean Operators

Place the Boolean operators as shown in Figure 31.

Figure 31: Q&R, Comparison & Boolean Functions

From the Functions >> Programming >> Structures menu, click on the Case Structure.

Figure 32: Case Structure

Click and drag on the Block Diagram window to create the Case Structure.

Figure 33: Creating a Case Structure

The True diagram option is indicated at the top of the case structure.

Figure 34: Created Case Structure

Drop a string constant and type “Is a Leap Year”.

Figure 35: True Case Editing

Click on the down arrowhead next to the True label and select the False option.

Figure 36: Selecting the False Case

Drop another string constant and type “Is not a Leap Year”.

Figure 37: False Case Editing

Go to the Front Panel window and place a numeric input and an output string. Re-label the numeric input to Year and the output string to Message.

Figure 38: Leap Year GUI

Right click on Year and select Representation >> I32 from the numeric pop-up menu.

Figure 39: 32-Bit Integer Numeric

Arrange the Year and Message terminals in the Block Diagram window as shown in the figure.

Figure 40: Unwired Leap Year Diagram

Wire the OR operator is to the “?” in the case structure and the string constant “Is not a Leap Year” is wired to Message.

Figure 41: Leap Year False Case

Select the True option and Wire the “Is a Leap Year” string constant to the output terminal of the Case Structure.

Figure 42: Leap Year True Case

Save the program as Leap Year.vi, enter Year values and run the program to determine whether the value of Year is that of a leap year or not.

Figure 43: Leap Year Program

Right click on the Front Panel window and select Array from the Controls >> Modern >> Arrays, Matrix & Cluster menu, and drop an array onto the Front Panel window. The array structure consists of an index or element offset (left portion of the structure) and the array elements (right portion of the structure). When the array structure is placed on the Front Panel window, the data type of the array is undefined as indicated by the grayed out portion of the array.

Figure 44: Arrays

To define the array data type, drag and drop a data type onto the array structure. For instance, to create an input array of numbers, place Numeric Control into the array structure.

Figure 45: Creating a Numeric Array

At this point, the numeric array is an Empty or Null array because no elements of the array have been defined. This is indicated by the grayed out numeric control within the array structure.

Figure 46: Empty Numeric Array

Define elements of an input array by selecting the offset and entering its value. For instance, at offset = 4, enter the value 0.0. This defines Numeric Input Array as {0, 0, 0, 0, 0}.

Figure 47: Defining Numeric Array Elements

An output array is created similarly to an input array with the exception that an output data type needs to be dropped into the array structure.

Figure 48: Creating Output Numeric Arrays

This program converts an array of Fahrenheit values to Celsius. Create numeric input and output arrays and label them Fahrenheit and Celsius respectively. In the Fahrenheit array enter the values 0, 20, 40, 60, 80, 100, 120, 140, 160, 180 and 200 at offsets 0 through 10 as shown in Figure 49.

Figure 49: Numeric Input and Output Arrays

Right click in the Block Diagram window, navigate to Programming >> Structures and click on For Loop.

Figure 50: For Loop Structure

Click and drag to create the For Loop as shown in Figure 51 and Figure 52.

Figure 51: Creating For Loops

Figure 52: For Loop

Right click inside the For Loop and select Select a VI… from the pop-up menu. Find the Fahrenheit to Celsius.vi and click OK. Drop the function inside the For Loop.

Figure 53: Function in Diagram

To complete the program, wire the Fahrenheit input array to the input terminal of the Fahrenheit to Celsius function and wire the output terminal of the Fahrenheit to Celsius function to the Celsius output array.

Figure 54: Wired Function in Diagram

This program uses the For Loop to select each element in the Fahrenheit input array, converts that value to Celsius and saves the results in the Celsius output array. Save the program as Fahrenheit to Celsius For Loop.vi and run the program.

Figure 55: Fahrenheit to Celsius Arrays

The Celsius output array contains: Celsius = {-17.7778, -6.6667, 4.44444, 15.5556, 26.6667, 37.7778, 48.8889, 60, 71.1111, 82.2222, 93.3333}

The next program will generate Fahrenheit values and convert them to Celsius until a condition is met to stop the iterations in a While Loop. In the Block Diagram window, select the While Loop structure by clicking on it from the Functions >> Programming >> Structures menu.

Click and drag to create the While Loop structure.

Figure 56: While Loop Structure

Figure 57: Creating a While Loop

Figure 58: While Loop

In the Front Panel window, create two numeric output arrays. Label them Fahrenheit and Celsius.

Figure 59: Numeric Output Arrays

Re-arrange the diagram as in Figure 60.

Figure 60: While Loop Diagram

From the Functions menu, select Multiply function and a couple of numeric constants. Type in 20.0 and 300.0 for the numeric constants. Select the Fahrenheit to Celsius.vi and drop it inside the While Loop. Re-arrange the diagram to look like Figure 61.

Figure 61: Generating Fahrenheit Values

From the Functions >> Programming >> Comparison menu select the Greater or Equal operator.

Figure 62: Greater or Equal Function

Wire the While Loop components as shown in Figure 63.

Figure 63: Generating Fahrenheit Values & Stop Condition

Wire the output of the Multiply operation to the Fahrenheit and the output of the Fahrenheit to Celsius function to the Celsius numeric output arrays. The connections between the While Loop and the Fahrenheit and Celsius arrays are broken (see Figure 64).

Figure 64: Broken Wires

To repair the broken connections, roll over the mouse pointer to the Loop Tunnel.

Figure 65: Loop Tunnel

Right click on the Loop Tunnel and select Enable Indexing from the pop-up menu.

Figure 66: Enable Loop Indexing

This enables values to accumulate and store the results into an array.

Repeat for the Celsius array.

Figure 67: Broken Wire Repaired

Each iteration of the While Loop in this program generates an i × 20 Fahrenheit value and converts it to Celsius. The While Loop stops iterating when the generated Fahrenheit value is greater than or equal to 300. The resulting arrays are stored in the Fahrenheit and Celsius numeric output arrays.

Save the program as Fahrenheit to Celsius While Loop.vi and run it. The program generates the following results:

Figure 68: Fahrenheit to Celsius While Loop

Fahrenheit = {0, 20, 40, 60, 80, 100, 120, 140, 160, 180, 200, 240, 260, 280, 300}

Celsius = {-17.7778, -6.6667, 4.44444, 15.5556, 26.6667, 37.7778, 48.8889, 60, 71.1111, 82.2222, 93.3333, 104.444, 115.556, 126.667, 137.778, 148.889}

Figure 69: Fahrenheit and Celsius Arrays

Using the previous G program example, we will now visualize the results by adding a graph to the Front Panel windows. Right click on the Front Panel window. Select XY Graph from the Controls >> Modern >> Graph menu.

Figure 70: XY Graph Selection

Drop the XY Graph in the Front Panel window. Double click on the x and y axis labels and rename Time to Fahrenheit and Amplitude to Celsius.

Figure 71: XY Graph in Front Panel window

The Block Diagram window contains the XY Graph terminal.

Figure 72: XY Graph Terminal in Diagram

Select Bundle from the Functions >> Programming >> Cluster, Class & Variant menu

Figure 73: Bundle Operator

Drop it on the diagram as shown in Figure 74.

Figure 74: Bundle for XY Graph

Wire the Fahrenheit and Celsius results to the input Bundle terminals and the output Bundle terminal to the XY Graph.

Save the program and run it. The resulting graph is shown in the figure below.

Figure 75: Wired XY Graph

Figure 76: XY Graph Result

This G program shows how G allows programmers to develop interactive programs. Create the following G program and wire it as shown in the figure below.

Figure 77: Creating Interactive Programs

In the Front Panel window, from the Functions >> Modern >> Numeric select the vertical pointer slide. From the Functions >> Modern >> Graph select Waveform Chart.

Figure 78: Vertical Pointer Slide and Waveform Chart

(a) (b)

Re-label the vertical pointer slide as Amplitude and the waveform chart as Sine Wave. Re-arrange to GUI to look like the figure below.

Figure 79: Slide & Waveform Chart in Front Panel window

Right click on Sine Wave and select Properties from the pop-up menu.

Figure 80: Selecting Chart Properties

Select the Scales tab and change Maximum to 1023. Sine Wave will display 1024 samples.

Figure 81: X-Axis Maximum

Click on the down arrow located to the right of Time (X-Axis) and select Amplitude (Y-Axis).

Figure 82: Selecting Y-Axis

De-select Autoscale and change the Minimum and Maximum values to -10 and 10. Click OK.

Figure 83: De-Selecting Autoscale

In the Block Diagram window, re-arrange the Amplitude and Sine Wave terminals and finish the program as shown in Figure 84.

Figure 84: Interactive Sine Wave Diagram

Scroll the mouse pointer over the Loop Control…

Figure 85: Loop Condition

And right click on the Loop Control and from the pop-up menu select Create Control.

Figure 86: Create Loop Control

A stop terminal is created…

Figure 87: Interactive G Program

With the corresponding stop Boolean input control. Save the G program as Interactivity.vi.

Figure 88: Interactive Program

Run the G program.

Figure 89: Interactive Program

While the program is running, change the Amplitude and watch the graph update to reflect the interactive changes.

Figure 90: Interactive Program

To end the G program, simply click on the stop button.

Congratulations. You have successfully completed and executed your first interactive G program.

Figure 91: Interactive Program

Save a copy of Interactivity.vi as Parallel Programming.vi. Select the while loop as shown in Figure 92.

Figure 92: Select Diagram for Parallel Programming

From the menu select Edit >> Copy.

Figure 93: Copy Selected Diagram

Create a copy of the while loop and its contents by selecting Edit >> Paste. Organize the diagram as shown in the figure below.

Figure 94: Paste Diagram

Go the Front Panel window and organize the input and output controls as shown in the figure below.

Figure 95: Parallel G Program

Congratulations!!! You have just completed your first parallel interactive program using G. Save the program, run it and interact with it. To end this program click on stop and stop 2.

Figure 96: Parallel Interactive G Program

Save a copy of Parallel Programming.vi as Multicore Programming.vi. If you have a multicore computer, CONGRATULATIONS!!! You have just completed your first multicore G program.

Figure 97: Interactive Multicore G Program

This program shows the polymorphic properties of G. Create the G program shown below.

Notice that the Subtract and Multiply operations allow arrays to be wired in the G program.

Figure 98: Polymorphic G Diagram