Вы находитесь на странице: 1из 30

INTELLIGENT SYTEM UNIT 1& 2

1. What is Intelligent System?


The Intelligent System may define as the surroundings are everything else that interacts with a system. The system may sometimes be further subdivided into subsystems which also interact with each other. This division into subsystems is not necessarily unique. (a) Low intelligence: Typically a simple system, it has to be told" everything and needs complete instructions, needs low-level control, the parameters are set, it is usually mechanical. (b) High intelligence: Typically a complex system, it is autonomous to a certain extent and needs few instructions, determines for itself what the goals are, demands high-level control, adaptive, makes decisions and choices, it is usually computerized. There is thus a continuum between these two extremes and most practical devices fall later category. Because of this broad definition, all control systems are intelligent to a certain extent and in this respect they are similar. However, the more intelligent systems are able to handle more complex situations and make more complex decisions. As computer hardware and software improve it becomes possible to engineer systems that are more intelligent under this definition. Some of the specific areas in which intelligent systems have been applied are the following: instrument landing system, automatic pilot, collision-avoidance system, antilock brake, smart air bag, intelligent road vehicles, planetary rovers, medical diagnoses, image processing, intelligent data analysis, financial risk analysis, temperature and flow control, process control, intelligent CAD, smart materials, smart manufacturing, intelligent buildings, internet search engines, machine translators. An intelligent system is a system that perceives its environment and takes actions that maximize its chances of success. John McCarthy, who coined the term in 1956, defines it as "the science and engineering of making intelligent machines." The field of intelligent research was founded at a conference on the campus of Dartmouth College in the summer of 1956. The attendees, including John McCarthy, Marvin Minsky, Allen Newell and Herbert Simon, became the leaders of intelligent research for many decades. They and their students wrote programs that were, to most people, simply astonishing: computers were solving word problems in algebra, proving logical theorems and speaking English. By the middle of the 1960s, research in the U.S. was heavily funded by the Department of Defense and laboratories had been established around the world. Intelligent founders were profoundly optimistic about the future of the new field: Herbert Simon predicted that "machines will be capable, within twenty years, of doing any work a man can do" and Marvin Minsky agreed, writing that "within a generation ... the problem of creating 'artificial intelligence' will substantially be solved"

The latest status of intelligent system may not required general computer to compute complex analysis. There will be dedicated systems which can take care all complex analysis and decision. Infact it may not in the size of general computer. Example: Humanoid Robots, Control in Nuclear power plant, Control in Satellites etc. If the intelligent system is used in industry like control and monitoring, then it may be in a form of network. To control the network, we will be require a dedicated software like LABVIEW, SCADA, DCS etc.. In this chapter we will be concentrating on the LABVIEW and it also called Virtual Instrumentation Software. For more than 20 years, NI LabVIEW has been used by millions of engineers and scientists to develop sophisticated test, measurement, and control applications. While LabVIEW provides a variety of features and tools ranging from interactive assistants to configurable user-defined interfaces, it is differentiated by its graphical, general-purpose programming language (known as G) along with an associated integrated compiler, a linker, and debugging tools.

2. A Brief History of the Pursuit of Higher-Level Programming


To better understand the major value propositions of LabVIEW graphical programming, it is helpful to review some background on the first higher-level programming language. At the dawn of the modern computer age in the mid-1950s, a small team at IBM decided to create a more practical alternative to programming the enormous IBM 704 mainframe (a supercomputer in its day) in low-level assembly language, the most modern language available at the time. The result was FORTRAN, a more human-readable programming language whose purpose was to speed up the development process. The engineering community was initially skeptical that this new method could outperform programs hand-crafted in assembly, but soon it was shown that FORTRANgenerated programs ran nearly as efficiently as those written in assembly. At the same time, FORTRAN reduced the number of programming statements necessary in a program by a factor of 20, which is why it is often considered the first higher-level programming language. Not surprisingly, FORTRAN quickly gained acceptance in the scientific community and remains influential. Fifty years later, there are still important lessons in this anecdote. First, for more than 50 years, engineers have sought easier and faster ways to solve problems through computer programming. Second, the programming languages chosen by engineers to translate their tasks have trended toward higher levels of abstraction. These lessons help explain the immense popularity and widespread adoption of G since its inception in 1986; G represents an extremely high-level programming language whose purpose is to increase the productivity of its users while executing at nearly the same speeds as lower-level languages like FORTRAN, C, and C++. LabVIEW: Graphical, Dataflow Programming LabVIEW is different from most other general-purpose programming languages in two major ways. First, G programming is performed by wiring together graphical icons on a diagram, which is then compiled directly to machine code so the computer processors

can execute it. While represented graphically instead of with text, G contains the same programming concepts found in most traditional languages. For example, G includes all the standard constructs, such as data types, loops, event handling, variables, recursion, and object-oriented programming.

While Loop in G is intuitively represented by a graphical loop, which executes until a stop condition is met. The second main differentiator is that G code developed with LabVIEW executes according to the rules of data flow instead of the more traditional procedural approach (in other words, a sequential series of commands to be carried out) found in most textbased programming languages like C and C++. Dataflow languages like G (as well as Agilent VEE, Microsoft Visual Programming Language, and Apple Quartz Composer) promote data as the main concept behind any program. Dataflow execution is datadriven, or data-dependent. The flow of data between nodes in the program, not sequential lines of text, determines the execution order. This distinction may seem minor at first, but the impact is extraordinary because it renders the data paths between parts of the program to be the developers main focus. Nodes in a LabVIEW program (in other words, functions, structures such as loops, subroutines, and so on) have inputs, process data, and produce outputs. Once all of a given nodes inputs contain valid data, that node executes its logic, produces output data, and passes that data to the next node in the dataflow path. A node that receives data from another node can execute only after the other node completes execution.

3. Benefits of G Programming
Intuitive Graphical Programming, Interactive Debugging Tools, Automatic Parallelism and Performance, Combining G with Other Languages LabVIEW is a program development application, much like various commercial C or BASIC development systems, or National Instruments LabWindows. However, LabVIEW is different from those applications in one important respect. Other programming systems use text-based languages to create lines of code, while LabVIEW uses a graphical programming language, G, to create programs in block diagram form. You can use LabVIEW with little programming experience. LabVIEW uses terminology, icons, and ideas familiar to scientists and engineers and relies on graphical symbols rather than textual language to describe programming actions. LabVIEW has extensive libraries of functions and subroutines for most programming tasks. For Windows, Macintosh, and Sun, LabVIEW contains application specific libraries for data acquisition and VXI instrument control. LabVIEW also contains application-specific libraries for GPIB and serial instrument control, data analysis, data presentation, and data storage. LabVIEW includes conventional program development tools, so you can set breakpoints, animate program execution to see how data passes through the program, and single-step through the program to make debugging and program development easier. LabVIEW includes libraries of functions and development tools designed specifically for instrument control. For Windows, Macintosh, and Sun, LabVIEW also contains libraries of functions and development tools for data acquisition. LabVIEW programs are called virtual instruments (VIs) because their appearance and operation imitate actual instruments. However, they are analogous to functions from conventional language programs. VIs have both an interactive user interface and a source code equivalent, and accept parameters from higher-level VIs. The following are descriptions of these three VI features. VIs contain an interactive user interface, which is called the front panel, because it simulates the panel of a physical instrument. The front panel can contain knobs, push buttons, graphs, and other controls and indicators. You input data using a keyboard and mouse, and then view the results on the computer screen. VIs receive instructions from a block diagram, which you construct in G. The block diagram supplies a pictorial solution to a programming problem. The block diagram contains the source code for the VI. VIs use a hierarchical and modular structure. You can use them as top-level programs, or as subprograms within other programs or subprograms. A VI within another VI is called a subVI. The icon and connector pane of a VI work like a graphical parameter list so that other VIs can pass data to it as a subVI. With these features, LabVIEW promotes and adheres to the concept of modular programming. You divide an application into a series of tasks, which you can divide

again until a complicated application becomes a series of simple subtasks. You build a VI to accomplish each subtask and then combine those VIs on another block diagram to accomplish the larger task. Finally, your top-level VI contains a collection of subVIs that represent application functions. Because you can execute each subVI by itself, apart from the rest of the application, debugging is much easier. Furthermore, many low-level subVIs often perform tasks common to several applications, so that you can develop a specialized set of subVIs suited to applications you can construct.

Front Panel
This tutorial explores the Front Panel and its relationship with the Block Diagram. Learn about the different types of Front Panel objects as well as how to find them on the Controls palette and place them on the Front Panel. Learn about the different types of Front Panel objects as well as how to find them on the Controls palette and place them on the Front Panel. This explores the Front Panel and its relationship with the Block Diagram. Learn about the different types of Front Panel objects as well as how to find them on the Controls palette and place them on the Front Panel. The front panel window is the user interface for the VI. The front panel has controls and indicators, which are the interactive input and output terminals, respectively, of the VI. Controls and indicators placed on the front panel are automatically placed on the block diagram. Refer to the Block Diagram tutorial for more information on block diagram terminals. Front Panel Window When you open a new or existing VI, the front panel window of the VI appears and functions as the graphical user interface or GUI of a VI. You can find the source code that runs the front panel on the block diagram. The front panel window contains a toolbar across the top and a Controls palette that you can access by right-clicking anywhere on the front panel. After opening the Controls palette, use it to place controls and indicators on the front panel. Note: Use the thumb tack to pin the Controls palette to the front panel and then select ViewChange Visible Categories. In the Change Visible Categories dialog box, click Select All and then OK to make all available controls and indicators visible on the front panel. Controls and Indicators Controls knobs, push buttons, dials, and other input devices are the interactive input terminals, while indicators graphs, LEDs, and other displays are the interactive output terminals of the VI. Controls simulate instrument input devices and supply data to the block diagram of the VI. Indicators simulate instrument output devices and display data the block diagram acquires or generates.

Every control and indicator has a data type associated with it. For example, the Delay (sec) horizontal slide is a numeric data type. Double-click the Delay (sec) control to make LabVIEW jump to the terminal location on the block diagram. Notice the color of the terminal. Orange terminals signify a data type called double (DBL), which is a type of numeric data.

The most commonly used data types are numeric, Boolean value, and string. Learn more about data types in the Data Types tutorial. Numeric Controls and Indicators The numeric data type can represent various types of numbers, such as integer or real. The two common numeric objects are the numeric control and the numeric indicator. Objects such as meters and dials also represent numeric data. Use the Controls palette to place a numeric control on the front panel and then use the increment and decrement buttons to adjust its values. Follow steps 1-3 to create a numeric control and change its value. 1. Right-click the front panel to open the Controls palette, and from the Numeric subpalette drag and drop a Numeric Control onto the front panel. 2. Label the control Input by double-clicking on the label and typing the word Input. 3. Now change the value of the control by clicking the increment or decrement button. Alternatively, you can double-click the number with either the Labeling tool or the Operating tool, enter a new number, and press the <Enter> key.

Boolean Controls and Indicators The Boolean data type represents data that has only two parts, such as TRUE and FALSE or ON and OFF. Use Boolean controls and indicators to enter and display Boolean values. Boolean objects simulate switches, push buttons, and LEDs. The vertical toggle switch and the round LED Boolean objects are shown below. You can find them in the Boolean subpalette in the Controls palette (see below).

String Controls and Indicators The string data type is a sequence of ASCII characters. Use string controls to receive text from the user, such as a password or user name, and use string indicators to display text to the user. The most common string objects are tables and text entry boxes as shown below. You can find string controls and indicators in the String and Path subpalette or the Lists and Tables subpalette.

Shortcut Menus and Property Dialog Boxes All LabVIEW objects have associated shortcut menus and property dialog boxes. As you create a VI, use the shortcut menu items and/or the properties dialog box to change the appearance and/or behavior of front panel and block diagram objects. To access the shortcut menu, right-click the object you want to modify. To access the Properties dialog box, select Properties from the shortcut menu. Follow steps 1 and 2 to create a string control and then use the Properties dialog box to add a scroll bar. Start with a blank VI. 1. From the String & Path subpalette, select a String Control and place it on the front panel. 2. Right-click the string indicator to open the shortcut menu and select Properties. 3 From the Properties dialog box, put a check in the Show vertical scroll bar checkbox and click OK. 4. The resulting string control has a scroll bar so the user can scroll up and down to view all of the text. This allows the use of a small string control to display a large amount of text.

Front Panel Window Toolbar Each window has a toolbar associated with it. Use the front panel window toolbar buttons to run and edit the VI. The following toolbar appears on the front panel window.

Click the Run button to run your VI. You do not need to compile your code; LabVIEW compiles it automatically. You can run a VI if the Run button appears as a solid white arrow, shown at left. The Run button appears broken when the VI you are creating or editing contains errors. If the Run button still appears broken after you finish wiring the block diagram, the VI is broken and cannot run. Click this button to display the Error List window, which lists all errors and warnings. Click Run Continuously to run the VI until you abort or pause execution. You also can click the button again to disable continuous running. While the VI runs, the Abort Execution button appears. Click this button to stop the VI immediately if there is no other way to stop the VI. If more than one running top-level VI uses the VI, the button is dimmed. Caution: The Abort Execution button stops the VI immediately before it finishes the current iteration. Aborting a VI that uses external resources, such as external hardware, might leave the resources in an unknown state by not resetting or releasing them properly. Design VIs with a stop button to avoid this problem. Click Pause to pause a running VI. When you click the Pause button, LabVIEW highlights on the block diagram the location where you paused execution, and the Pause button appears red. Click the Pause button again to continue running the VI. Select the Text Settings pull-down menu to change the font settings for the selected portions of your VI, including size, style, and color.

Tip: The <Enter> key on the numeric keypad ends a text entry, while the main <Enter> key adds a new line. To modify this behavior, select ToolsOptions, choose Environment from the Category list, and place a checkmark in the End text entry with Enter key option. It is important for a VI to have an intuitive and easy-to-read front panel. The front panel is essentially the gateway for all user input and output of a VI. Therefore it is essential that the programmer has good grasp of how to effectively program a front panel. ===============================================

Block Diagram
In this introduction to the Block Diagram, we examine the concept of this tool as well as the Block Diagrams relationship with the Front Panel. We also explore how to open the Block Diagram, how to find objects in the Functions palette and put them on the Block Diagram, and how to use different toolbar icons. In addition, we learn how to build a simple block diagram to illustrate the important concepts of creating graphical code in NI LabVIEW software. The block diagram contains the graphical source code of a LabVIEW program. The concept of the block diagram is to separate the graphical source code from the user interface in a logical and simple manner. Front panel objects appear as terminals on the block diagram. Terminals on the block diagram reflect the changes made to their corresponding front panel objects and vice versa.

Block Diagram Window


When you create or open a new VI, the front panel opens automatically. To bring up the block diagram, select WindowShow Block Diagram from the menu bar. Additionally, you can toggle between the block diagram and the front panel by pressing <Ctrl-E>.

Block Diagram Objects and Environment

Block diagram objects include terminals, subVIs, functions, constants, structures, and wires that transfer data among other block diagram objects. You can use LabVIEW tools to create, modify, and debug a VI. A tool is a special operating mode of the mouse cursor, so the operating mode of the cursor corresponds to the icon of the tool selected. LabVIEW chooses which tool to select based on the current location of the mouse. You can manually choose the tool you need by selecting it on the Tools palette (from the menu bar, select ViewTools Palette). Now you can choose your desired tool, which remains selected until you choose another tool from the Tools palette.

To place objects on the block diagram, simply drag and drop them from the Functions palette. The Functions palette automatically appears when you right-click anywhere on the block diagram workspace. It contains functions, constants, structures, and some subVIs.

Notice the two buttons on the top of the Functions palette. The Thumb Tack pins the Functions palette to the block diagram.

The Search button opens a search dialog box that you can use to search for functions by name. Click the Search button to launch the functions search engine. It takes a few moments to launch. You can use this tool to search for a function by name if you are having trouble finding it. Once you see the function you want, double -click on it and LabVIEW jumps to the place on the Functions palette where you can find that function. Note: Complete the following steps to change the subpalettes visible on the Functions palette: 1. Use the thumb tack to pin the Functions palette to the block diagram. 2. Notice the View button appears when you pin the Functions palette to the block diagram. 3. Select View and, from the shortcut menu, select Change Visible Categories. 4. In the Change Visible Categories dialog box, you can select the Palettes that you use the most or click Select All to include all Palettes. To change the appearance of the block diagram, select ToolsOptions from the menu bar. In the Options dialog box, select the Block Diagram category. Here you can customize the appearance of your block diagram. To save space on the block diagram, deselect Place front panel terminals as icons.

Terminals Terminals create the block diagram appearance of objects on the front panel. In addition, they are entry and exit ports that exchange information between the front

panel and block diagram. Analogous to parameters and constants in text-based programming languages, terminals come in two types: control or indicator terminals and node terminals. Control and indicator terminals belong to front panel controls and indicators. In the example above, data you enter in front panel controls a and b enter the block diagram through their respective control terminals a and b. The data then enter the Add and Subtract functions. When the Add and Subtract functions complete their calculations, they produce new data values. The data values flow to the indicator terminals, where they update the front panel indicators a+b and a-b.

Controls, Indicators, and Constants Controls, indicators, and constants operate as the inputs and outputs of the block diagram algorithm. Controls receive their values from the front panel and pass data to other block diagram objects. Indicators receive their values from block diagram logic and pass data from the block diagram to the front panel. Constants pass data to the object to which they are wired. Consider an algorithm for computing the area of a triangle. You might have the following front panel and corresponding block diagram. The constant Triangular Multiplier does not necessarily appear on the front panel window except possibly as documentation of the algorithm. It simply passes the value of .5 into the multiply function. Notice that the Base(cm) and Height(cm) block diagram terminals look different from the Area(cm^2) terminal. There are two distinguishing characteristics between a control and an indicator on the block diagram. The first is an arrow on the terminal that indicates the direction of data flow. The controls have arrows showing the data leaving the terminal, whereas the indicator has an arrow showing the data entering the terminal. The second distinguishing characteristic is the border around the terminal. Controls have a thick border and indicators have a thin border.

You can create controls and indicators from either the block diagram or the front panel. This tutorial demonstrates this in a later section. Block Diagram Nodes Nodes are objects on the block diagram that have inputs and/or outputs and perform operations when a VI runs. They are analogous to statements, operators, functions, and subroutines in text-based programming languages. Nodes can be functions, subVIs, or structures. Structures are process control elements, such as case structures, for loops, or while loops, which are covered in a later tutorial. The image below shows some examples of block diagram nodes.

Functions Functions are the fundamental operating elements of LabVIEW. Functions do not have front panel windows or block diagram windows, but they do have input and output terminals for passing data in and out similarly to controls and indicators. You can tell if a block diagram object is a function by the pale yellow background on its icon. The

Functions palette has functions arranged in groups based on the type of function they perform. Look in the Numeric subpalette for functions that perform numeric operations.

There are many different types of functions. Remember that a function has a pale yellow background like the functions shown below.

Data flow
LabVIEW follows a dataflow model for running VIs. A block diagram node executes when it receives all required inputs. When a node executes, it produces output data and passes the data to the next node in the dataflow path. The movement of data through the nodes determines the execution order of the VIs and functions on the block diagram. In text-based programming languages, you store and access data with functions through the use of variables. In the NI LabVIEW graphical programming language, wires implicitly handle all of the data storage and access that are associated with variables in text-based languages. Think of wires as a path for data to flow. Data comes into block diagram objects through a wire and can leave only through a wire. In the figure below, wires connect the control and indicator terminals to the Add and Subtract functions. As you can see, each wire has a single data source or starting point. However, you can branch off one wire and wire it to many VIs and functions. By branching off the main wire, you can send data to multiple destinations. Note that wires are different colors, styles, and thicknesses. Color, style, and thickness change depending on the type of data the wire is transmitting.

Broken wires (wires that are not connected properly) prevent your VI from running. A broken wire appears as a dashed black line with a red X in the middle, as shown below.

Broken wires occur for a variety of reasons such as wiring two objects with different or incompatible data types. For example, you cannot wire an array output to a numeric input. The data in the wire is an array and the input is expecting a single numeric, so the data types are not compatible. When connecting block diagram objects with wires, you must connect a wire to one input and at least one output. For example, you cannot wire two indicators together. The figure below shows the most common wire types. Notice the different colors and thicknesses of the wires indicating the different data types. Wire Type Numeric Boolean String Scalar 1D Array 2D Array Color Orange (floatingpoint), Blue (integer) Green Pink

6. Sub VI
One of the keys to creating LabVIEW applications is understanding and using the hierarchical nature of the VI. After you create a VI, you can use it as a subVI in the block diagram of a higher-level VI. Therefore, a subVI is analogous to a subroutine in C. Just as there is no limit to the number of subroutines you can use in a C program, there is no limit to the number of subVIs you can use in a LabVIEW program. You can also call a subVI inside another subVI. When creating an application, you start at the top-level VI and define the inputs and outputs for the application. Then, you construct subVIs to perform the necessary operations on the data as it flows through the block

diagram. If a block diagram has a large number of icons, group them into a lower-level VI to maintain the simplicity of the block diagram. This modular approach makes applications easy to debug, understand, and maintain. When you create a subVI and use it, you see an icon within your block diagram that represents the subVI. You can customize this icon, which is the same icon in the upper right corner of the subVI front panel and block diagram. You can create a subVI just like a VI and then use it as a subVI, or you can create a subVI from code already within another VI. Creating a SubVI from an Existing VI You can simplify the block diagram of a VI by converting sections of the block diagram into subVIs. 1. Create a new VI and construct the following block diagram.

2. Select the section of the block diagram you want to convert.

3. From the Tools menu, select EditCreate SubVI.

The selected section of the block diagram is replaced with an icon for the subVI. LabVIEW creates controls and indicators for the new subVI, automatically configures the connector pane based on the number of control and indicator terminals you selected, and wires the subVI to the existing wires.

The new subVI uses a default pattern for the connector pane and a default icon.

4. LOOPS
LabVIEW has four structures: the While Loop, the For Loop, the Case structure, and the Sequence structure. A while loop is a control flow statement you use to execute a block of the subdiagram code repeatedly until a given Boolean condition is met. First, you execute the code within the subdiagram, and then the conditional terminal is evaluated. Unlike a for loop, a while loop does not have a set iteration count; thus, a while loop executes indefinitely if the condition never occurs.

A for loop is a control flow statement you use to execute a block of the subdiagram code a set number of times, but a while loop stops executing the subdiagram only if the value at the conditional terminal exists.

Building a While Loop 1. Open a new VI. You can open a blank VI by selecting FileNew VI

2. If the Functions palette is not visible, right-click any blank space on the block diagram to display a temporary version of the palette. Click the thumbtack in the upper left corner of the Functions palette to pin the palette so it is no longer temporary. 3. Select the while loop from the Structures palette under the Functions palette. 4. Use the cursor to drag a selection rectangle around the section of the block diagram you want to repeat.

5. When you release the mouse button, a while loop boundary encloses the section you have selected. 6. Place a Stop button on the front panel. You can find this under Controls PaletteBooleanStop. 7. Add the Stop button from the block diagram to the while loop by dragging and dropping it inside the while loop.

8. The conditional terminal, shown below, defines when the loop stops. There are two settings for the conditional terminal: Continue if True and Stop if True. When set to Continue if True, the while loop runs only if a Boolean value of true is sent to the terminal. If the conditional terminal is set to Stop if True, and a Boolean value of true is sent to the conditional terminal, the loop halts execution. Stop if True

Continue if True

9. To switch the conditional terminal between Continue if True and Stop if True, rightclick on the conditional terminal and check the corresponding setting. 10. Wire the Stop button to the conditional terminal so that you can control the execution of the while loop. When the Stop button is pressed, a true value is passed to the conditional terminal causing the while loop to stop execution. You can wire any Boolean data to the conditional terminal to control the execution of a while loop.

11. The iteration terminal is an output terminal that contains the number of completed iterations. The iteration count always starts at zero. During the first iteration, the iteration terminal returns 0.

12. You have just created a simple while loop that generates random numbers and displays them until the Stop button is pressed. Building a For Loop 1. Open a new VI. You can open a blank VI by selecting FileNew VI. 2. If the Functions palette is not visible, right-click any blank space on the block diagram to display a temporary version of the Functions palette. Click the thumbtack in the upper left corner of the Functions palette to pin the palette so it is no longer temporary. 3. Select the for loop from the Structures palette under the Functions palette.

4. You also can place a while loop on the block diagram. Right-click the border of the while loop and select Replace with For Loop from the shortcut menu to change a while loop to a for loop.

5. A for loop contains a count terminal. The count terminal dictates how many times the subdiagram is executed. 6. Right-click on the count terminal and Create Constant to link the count terminal with a numeric value.

7. By inserting 100 into the numeric constant, the for loop executes 100 times before stopping.

8. The iteration terminal, shown as follows, is an output terminal that contains the number of completed iterations. The example below would update an indicator on the front panel with the current iteration number.

5. Arrays and Clusters


An array, which consists of elements and dimensions, is either a control or an indicator it cannot contain a mixture of controls and indicators. Elements are the data or values contained in the array. A dimension is the length, height, or depth of an array. Arrays are very helpful when you are working with a collection of similar data and when you want to store a history of repetitive computations. Array elements are ordered. Each element in an array has a corresponding index value, and you can use the array index to access a specific element in that array. In NI LabVIEW software, the array index is zero-based. This means that if a one-dimensional (1D) array contains n elements, the index range is from 0 to n 1, where index 0 points to the first element in the array and index n 1 points to the last element in the array. Clusters group data elements of mixed types. An example of a cluster is the LabVIEW error cluster, which combines a Boolean value, a numeric value, and a string. A cluster is similar to a record or a struct in text-based programming languages. Similar to arrays, a cluster is either a control or an indicator and cannot contain a mixture of controls and indicators. The difference between clusters and arrays is that a particular cluster has a fixed size, where a particular array can vary in size. Also, a cluster can contain mixed data types, but an array can contain only one data type. Creating Array Controls and Indicators To create an array in LabVIEW, you must place an array shell on the front panel and then place an element, such as a numeric, Boolean, or waveform control or indicator, inside the array shell. 1. 2. Create a new VI. Right-click on the front panel to display the Controls palette.

3. On the Controls palette, navigate to ModernArray, Matrix, & Cluster and drag the Array shell onto the front panel. 4. On the Controls palette, navigate to ModernNumeric and drag and drop a numeric indicator inside the Array shell. 5. Place your mouse over the array and drag the right side of the array to expand it and display multiple elements.

The previous steps walked you through creating a 1D array. A 2D array stores elements in a grid or matrix. Each element in a 2D array has two corresponding index values, a row index and a column index. Again, as with a 1D array, the row and column indices of a 2D array are zero-based. To create a 2D array, you must first create a 1D array and then add a dimension to it. Return to the 1D array you created earlier. 1. On the front panel, right-click the index display and select Add Dimension from the shortcut menu.

2. Place your mouse over the array and drag the corner of the array to expand it and display multiple rows and columns.

Up to this point, the numeric elements of the arrays you have created have been dimmed zeros. A dimmed array element indicates that the element is uninitialized. To

initialize an element, click inside the element and replace the dimmed 0 with a number of your choice. You can initialize elements to whatever value you choose. They do not have to be the same values as those shown above.

Creating Clusters 1. 2. Create a new VI. Right-click on the front panel to display the Controls palette.

3. On the Controls palette, navigate to ModernArray, Matrix, & Cluster and drag the Cluster shell onto the front panel.

4.

Resize the Cluster shell so that it is big enough to contain multiple elements.

5. On the Controls palette, navigate to ModernNumeric and drag and drop a numeric control inside the Cluster shell. 6. On the Controls palette, navigate to ModernString & Path and drag and drop a String Control inside the Cluster shell.

7. On the Controls palette, navigate to ModernBoolean and drag and drop a Vertical Toggle Switch inside the Cluster shell. 8. Your cluster should now look similar to the one shown below.

You can now wire the numeric, string, and Boolean controls throughout the block diagram with one wire rather than three separate wires.

6. Graphs and charts


Graphs and charts differ in the way they display and update data. VIs with graphs usually collect the data in an array and then plot the data to the graph, which is similar to a spreadsheet that first stores the data then generates a plot of it. In contrast, a chart appends new data points to those already in the display to create a history. On a chart, you can see the current reading or measurement in context with data previously acquired. Waveform Graphs and ChartsDisplay data typically acquired at a constant rate. XY GraphsDisplay data acquired at a non-constant rate and data for multivalued functions. Intensity Graphs and ChartsDisplay 3D data on a 2D plot by using color to display the values of the third dimension. Digital Waveform GraphsDisplay data as pulses or groups of digital lines. 2D GraphsDisplay 2D data on a 2D front panel plot. 3D GraphsDisplay 3D data on a 3D front panel plot. A graph indicator consists of a two-dimensional display of one or more data arrays called plots. LabVIEW has three types of graphs: XY graphs, waveform graphs, and intensity graphs (see the Additional Topics section at the end of this chapter for information on intensity graphs). The difference between a graph and a chart is that a graph plots data as a block, whereas a chart plots data point by point or array by array. Waveform Graphs The waveform graph displays one or more plots of evenly sampled measurements. The waveform graph plots only single-valued functions, as in y = f(x), with points evenly distributed along the x-axis, such as acquired time-varying waveforms. The following front panel shows an example of a waveform graph.

7. Formula Node
The Formula Node is a resizable box that you can use to enter formulas directly into a block diagram. You place the Formula Node on the block diagram by selecting it from FunctionStructures. This feature is useful when an equation has many variables or is otherwise complicated. For example, consider the equation:
y = x2 + x + 1.

If you implement this equation using regular LabVIEW arithmetic functions, the block diagram looks like the one in the following illustration.

You can implement the same equation using a Formula Node, as shown in the following illustration.

With the Formula Node, you can directly enter a complicated formula, or formulas, in lieu of creating block diagram subsections. You enter formulas with the Labeling tool. You create the input and output terminals of the Formula Node by popping up on the border of the node and choosing Add Input (Add Output). Type the variable name in the box. Variables are case sensitive. You enter the formula or formulas inside the box. Each formula statement must end with a semicolon (;).

String
A string is a collection of ASCII characters. You can use strings for more than simple text messages. In instrument control, you can pass numeric data as character strings and then convert these strings to numbers. Storing numeric data to disk can also involve strings. Use of the String functions are to concatenate two or more strings, extract a subset of strings from a string, convert data into strings, and format a string for use in a word processing or spreadsheet application. Some of string functions are explained below. Build Text Concatenates an input string. If the input is not a string, this Express VI converts the input into a string based on the configuration of the Express VI. String Length Returns in length the number of characters (bytes) in string. The connector pane displays the default data types for this polymorphic function. To Lower Case Converts all alphabetic characters in string to lowercase characters. Evaluates all numbers in string as ASCII codes for characters. This function does not affect nonalphabetic characters. To Upper Case Converts all alphabetic characters in string to uppercase characters. Evaluates all numbers in string as ASCII codes for characters. This function does not affect nonalphabetic characters.

File I/O
Use the File I/O functions to read data from or write data to files in three formatstext, binary, and datalog. You also can read and write data using the Read LabVIEW Measurement File Express VI and the Write LabVIEW Measurement File Express VI. These Express VIs read data from and write data to a LabVIEW measurement data file (.lvm). You also can create, modify, and read a configuration file using the configuration file VIs.

Build Path Creates a new path by appending a name (or relative path) to an existing path. Read File Reads data from an open file specified by refnum and returns it in data. Reading begins at the current file mark or a location in the file specified by pos mode and pos offset. How the data is read depends on the format of the specified file. refnum is the file refnum associated with the file you want to read. If you want to read more than one element at a time, wire the count parameter and use pos mode, pos offset, and offset to track the location of the file mark. If refnum refers to a datalog file, the function reads the data as records from the file and returns an array of record data in data. Write File Writes data to an open file specified by refnum. Writing begins at a location specified by pos mode and pos offset for byte stream files and at the end of the file for datalog files. data, header, and the format of the specified file determine the amount of data written. refnum is the file refnum associated with the file to which you want to write. If refnum specifies a byte stream file, this function writes to a location specified by pos mode and pos offset in the file. If the top-level data type of data is of variable length, such as a string or array, the function can write a header to the file that specifies the size of the data. LabVIEW sets the file mark to the byte following the last byte written. If refnum specifies a datalog file, this function writes data as records to the file. You only can append data to datalog files, so the function always begins writing at the end of the datalog file. Therefore, LabVIEW sets the file mark to the record following the last record written. You do not need to wire the convert eol, header, pos mode, or pos offset parameters for datalog files.

Dynamic Link Library


A dynamic link library (DLL) is a collection of small programs, any of which can be called when needed by a larger program that is running in the computer. The small program that lets the larger program communicate with a specific device such as a printer or scanner is often packaged as a DLL program (usually referred to as a DLL file). DLL files that support specific device operation are known as device drivers. The advantage of DLL files is that, because they don't get loaded into random access memory (RAM) together with the main program, space is saved in RAM. When and if a DLL file is needed, then it is loaded and run. For example, as long as a user of Microsoft Word is editing a document, the printer DLL file does not need to be loaded into RAM. If the user decides to print the document, then the Word application causes the printer DLL file to be loaded and run. A DLL file is often given a ".dll" file name suffix. DLL files are dynamically linked with the program that uses them during program execution rather than being compiled with the main program. The set of such files (or the DLL) is somewhat comparable to the library routines provided with programming languages such as C and C++.

If the DLL is a C/C++ DLL: 1. Find the header file (*.h) or function prototype definitions. 2. Identify the function(s) you wish to call. Notice whether the parameters for the function contain primitive data type parameters such as int, char, double, etc or whether they contain complex data types such as structs, arrays or vectors. 3. If the function does not contain any complex data types and you have a header file (*.h), a great tool in LabVIEW can help you easily import the DLL (and it will create an entire library for the DLL). You can find this option in ToolsImportShared Library (.dll)... Continue with the wizard. 4. If the function does not contain any complex data types and you do not have a header file (*.h), first ensure that you are dealing with a C/C++ DLL as most programming environments will generate a header file along with the DLL. If you are in fact dealing with a C/C++ DLL, find the documentation for the function as you will need to identify the parameters for the function you wish to call inside of the DLL. Once you have identified the parameters, use the Call Library Function Node function in LabVIEW to manually call the function. 5. If the function(s) you wish to call contains complex data types, you need to manually use a Call Library Function Node function in LabVIEW to directly call the DLL, defining the prototype within the configuration dialog (if the DLL has been compiled with a Type Library, parameter data and return types will be defined automatically). Note that if your complex data type is a struct with more than primitive data types (int, double, char), it is easiest to create a wrapper DLL from a C-based language. Since C/C++ constructs do not always directly correlate to LabVIEW data types, a wrapper DLL can appropriately extract the contents of the complex structure and translate them to primitive terms. For instance, if you have a struct in C which contains a char * (a string or character array), you can create a wrapper function which LabVIEW will call that takes in a char * type directly, puts that into a structure, and then in turn calls the DLL. Note that if you have the DLL source code, you can directly modify the DLL so that it takes in a char * instead of the struct. Note: There is a very helpful example in the Labview Example finder that explains how to handle several different data types to be used with the Call Library Function Node. The example is named Call DLL.vi. Refer to this example when dealing with complex data types such as arrays or structs. To Find this example go to the LabVIEW Example Finder (HelpFind Examples) and select the Directory Structure radio button. In the directories list, select dll and then data passing then Call Native Code.llb. The Call DLL.vi example is under that directory. To view the example for a data type, select the data type in the Data Type list. Then click the Open Example VI for Current Data Type button. This will open a new VI showing the use of the Call Library Function Node.