CART

(0) items

LabVIEW for Everyone : Graphical Programming Made Easy and Fun,9780131856721
This item qualifies for
FREE SHIPPING!
FREE SHIPPING OVER $59!

Your order must be $59 or more, you must select US Postal Service Shipping as your shipping preference, and the "Group my items into as few shipments as possible" option when you place your order.

Bulk sales, PO's, Marketplace Items, eBooks, Apparel, and DVDs not included.

LabVIEW for Everyone : Graphical Programming Made Easy and Fun

by ;
Edition:
3rd
ISBN13:

9780131856721

ISBN10:
0131856723
Format:
Hardcover
Pub. Date:
7/27/2006
Publisher(s):
Prentice Hall

Questions About This Book?

Why should I rent this book?
Renting is easy, fast, and cheap! Renting from eCampus.com can save you hundreds of dollars compared to the cost of new or used books each semester. At the end of the semester, simply ship the book back to us with a free UPS shipping label! No need to worry about selling it back.
How do rental returns work?
Returning books is as easy as possible. As your rental due date approaches, we will email you several courtesy reminders. When you are ready to return, you can print a free UPS shipping label from our website at any time. Then, just return the book to your UPS driver or any staffed UPS location. You can even use the same box we shipped it in!
What version or edition is this?
This is the 3rd edition with a publication date of 7/27/2006.
What is included with this book?
  • The New copy of this book will include any supplemental materials advertised. Please check the title of the book to determine if it should include any CDs, lab manuals, study guides, etc.
  • The Rental copy of this book is not guaranteed to include any supplemental materials. You may receive a brand new copy, but typically, only the book itself.

Related Products


  • Internet Applications in Labview
    Internet Applications in Labview
  • LabVIEW for Everyone
    LabVIEW for Everyone





Summary

The #1 Step-by-Step Guide to LabVIEWNow Completely Updated for LabVIEW 8! Master LabVIEW 8 with the industryrs"s friendliest, most intuitive tutorial: LabVIEW for Everyone, Third Edition. Top LabVIEW experts Jeffrey Travis and Jim Kring teach LabVIEW the easy way: through carefully explained, step-by-step examples that give you reusable code for your own projects! This brand-new Third Edition has been fully revamped and expanded to reflect new features and techniques introduced in LabVIEW 8. Yours"ll find two new chapters, plus dozens of new topics, including Project Explorer, AutoTool, XML, event-driven programming, error handling, regular expressions, polymorphic VIs, timed structures, advanced reporting, and much more. Certified LabVIEW Developer (CLD) candidates will find callouts linking to key objectives on NIrs"s newest exam, making this book a more valuable study tool than ever. Not just what to do: why to do it! Use LabVIEW to build your own virtual workbench Master LabVIEWrs"s foundations: wiring, creating, editing, and debugging VIs; using controls and indicators; working with data structures; and much more Learn the "art" and best practices of effective LabVIEW development NEW: Streamline development with LabVIEW Express VIs NEW: Acquire data with NI-DAQmx and the LabVIEW DAQmx VIs NEW: Discover design patterns for error handling, control structures, state machines, queued messaging, and more NEW: Create sophisticated user interfaces with tree and tab controls, drag and drop, subpanels, and more Whatever your application, whatever your role, whether yours"ve used LabVIEW or not, LabVIEW for Everyone, Third Edition is the fastest, easiest way to get the results yours"re after!

Author Biography

Jeffrey Travis provides expert consulting and creates books, courses, and products for remote Internet controls and monitoring, virtual instrumentation, and Web applications through his company, Jeffrey Travis Studios. He has more than fifteen years of experience developing software, teaching, and consulting on LabVIEW and related technologies. He holds an M.S. in engineering from the University of Texas at Austin.

 

Jim Kring is president of James Kring, Inc., a leader in LabVIEW development, system integration consulting, and custom software design. He is founder of OpenG, a foundation promoting open-source LabVIEW tools, applications, frameworks, and documentation.

Table of Contents

About the Authors xxix
Preface xxxi
Acknowledgments xli
What in the World Is LabView?
3(18)
What Exactly Is LabView, and What Can It Do for Me?
3(7)
Dataflow and the Graphical Programming Language
5(1)
How Does LabView Work?
5(5)
Demonstration Examples
10(8)
NI Example Finder
10(1)
Examples on the CD
11(1)
Activity 1-1: Temperature System Demo
11(5)
Activity 1-2: Frequency Response Example
16(2)
Wrap It Up!
18(1)
Additional Activities
18(3)
Activity 1-3: More Neat Examples
18(3)
Virtual Instrumentation: Hooking Your Computer Up to the Real World
21(20)
Using LabView in the Real World
21(1)
The Evolution of LabView
22(2)
What Is Data Acquisition?
24(2)
What Is GPIB?
26(2)
Communication Using the Serial Port
28(1)
Real-World Applications: Why We Analyze
29(3)
A Little Bit About PXI and VXI
32(2)
Connectivity
34(3)
Internet Connectivity
34(1)
Networking
34(2)
ActiveX and .NET
36(1)
Shared Libraries, DLLs, and CINs
36(1)
Other Communication Mechanisms
37(1)
LabView Add-on Toolkits
37(1)
LabView Real-Time, FPGA, PDA, and Embedded
38(1)
Wrap It Up!
39(2)
The LabView Environment
41(60)
Front Panels
41(2)
Controls and Indicators
41(2)
Block Diagrams
43(4)
Nodes
45(1)
Wires
45(1)
Dataflow Programming---Going with the Flow
46(1)
LabView Projects
47(6)
Project Explorer Window
47(1)
Project Explorer Toolbars
48(1)
Adding Items to Your Project
48(2)
Project Folders
50(1)
Removing Items from a Project
50(1)
Building Applications, Installers, DLLs, Source Distributions, and Zip Files
51(1)
More Project Features
52(1)
SubVIs, the Icon, and the Connector
53(1)
Activity 3-1: Getting Started
54(9)
Alignment Grid
63(1)
Pull-Down Menus
64(5)
Floating Palettes
69(11)
Controls and Functions Palettes
69(8)
Customizing the Palettes
77(1)
Tools Palette
78(2)
Automatic Tool Selection
80(1)
The Toolbar
80(3)
Pop-Up Menus
83(5)
Pop-Up Menu Features to Keep in Mind
84(1)
Pop-Up Features Described
85(3)
Help!
88(2)
The Context Help Window
88(2)
Online Help
90(1)
Express VIs
90(2)
Displaying SubVIs as Expandable Nodes
92(2)
A Word About SubVIs
94(1)
Activity 3-2: Front Panel and Block Diagram Basics
94(5)
Wrap It Up!
99(2)
LabView Foundations
101(46)
Creating VIs: It's Your Turn Now!
101(12)
Placing Items on the Front Panel
101(1)
Labeling Items
102(4)
Changing Font, Style, Size, and Color of Text
106(1)
Placing Items on the Block Diagram
106(1)
Editing Techniques
106(7)
Activity 4-1: Editing Practice
113(3)
Basic Controls and Indicators and the Fun Stuff They Do
116(14)
Numeric Controls and Indicators
117(7)
Booleans
124(3)
Strings
127(2)
Paths
129(1)
Decorations
129(1)
Custom Controls and Indicators
129(1)
Summary of Basic Controls and Indicators
129(1)
Wiring Up
130(6)
Automatic Wire Routing
131(1)
Automatic Wiring
131(1)
Wiring Complicated Objects
132(1)
Bad Wires
133(1)
Wiring Tips
134(1)
Wire Stretching
135(1)
Selecting and Deleting Wires
135(1)
Moving Wires
135(1)
Wiring to Off-Screen Areas
136(1)
Adding Constants, Controls, and Indicators Automatically
136(1)
Running Your VI
136(4)
Activity 4-2: Building a Thermometer
137(3)
Useful Tips
140(4)
Keyboard Shortcuts
140(1)
Examples
140(1)
Changing Tools
141(1)
Changing the Direction of a Wire
141(1)
Canceling a Wiring Operation
141(1)
Removing the Last Tack Point
141(1)
Inserting an Object into Existing Wires
141(1)
Moving an Object Precisely
142(1)
Incrementing Digital Controls More Quickly
142(1)
Entering Items in a Ring Control
142(1)
Cloning an Object
142(1)
Moving an Object in Only One Direction
142(1)
Matching the Color
143(1)
Replacing Objects
143(1)
Making Space
143(1)
Configuring Your Preferences
143(1)
Wrap It Up!
144(1)
Additional Activities
145(2)
Activity 4-3: Comparison Practice
145(1)
Activity 4-4: Very Simple Calculator
145(2)
Yet More Foundations
147(38)
Loading and Saving VIs
147(7)
Save Options
148(2)
Revert
150(1)
LLBs
150(3)
Save and Load Dialogs
153(1)
Filter Rings
153(1)
Debugging Techniques
154(6)
Fixing a Broken VI
154(1)
Warnings
155(1)
Most Common Mistakes
155(1)
Single-Stepping Through a VI
156(1)
Execution Highlighting
156(2)
Setting Breakpoints
158(1)
Suspending Execution
158(1)
Using the Probe
159(1)
Activity 5-1: Debugging Challenge
160(3)
Creating SubVIs
163(10)
Creating a SubVI from a VI
164(8)
Creating SubVIs from a Block Diagram Selection
172(1)
SubVI Help: Recommended, Required, and Optional Inputs
172(1)
Relink to SubVI: Changing Connector Panes of SubVIs
172(1)
Documenting Your Work
173(4)
Creating Descriptions and Tips for Individual Objects
174(1)
Documenting VIs in the VI Properties
175(2)
A Little About Printing
177(1)
Activity 5-2: Creating SubVIs---Practice Makes Perfect
178(3)
Wrap It Up!
181(1)
Additional Activities
182(3)
Activity 5-3: Find the Average
182(1)
Activity 5-4: Divide by Zero (Who Says You Can't?)
183(2)
Controlling Program Execution with Structures
185(60)
Two Loops
185(10)
The For Loop
185(1)
The While Loop
186(1)
Placing Objects Inside Structures
187(3)
Activity 6-1: Counting the Loops
190(5)
Shift Registers
195(9)
Activity 6-2: Shift Register Example
197(2)
Why You Need Shift Registers
199(1)
Initializing Shift Registers
200(1)
The Feedback Node
201(2)
Converting Tunnels to Shift Registers (and Vice Versa)
203(1)
The Case Structure
204(3)
Wiring Inputs and Outputs
206(1)
Adding Cases
206(1)
Dialogs
207(9)
Activity 6-3: Square Roots
213(2)
The Select Function
215(1)
The Sequence Structure---Flat or Stacked
216(4)
Stacked Sequence Structures and Sequence Locals Are Evil
217(3)
Timing
220(4)
Activity 6-4: Matching Numbers
221(2)
Express Timing Functions
223(1)
The Timed Structures
224(4)
The Timed Loop
225(1)
The Timed Sequence
226(1)
The Timed Structure VIs
226(2)
The Formula Node
228(5)
Activity 6-5: Formula Fun
231(2)
The Expression Node
233(1)
The While Loop + Case Structure Combination
234(5)
The Main Loop
234(1)
Handling Multiple Work Items in a While Loop
235(4)
Adding Efficiency: Wait on Front Panel Activity
239(1)
Wrap It Up!
239(2)
Additional Activities
241(4)
Activity 6-6: Equations
241(1)
Activity 6-7: Calculator
241(1)
Activity 6-8: Combination For/While Loop Challenge
242(1)
Activity 6-9: Dialog Display
243(2)
LabView's Composite Data: Arrays and Clusters
245(56)
What Are Arrays?
245(1)
Creating Array Controls and Indicators
246(3)
Array Scrollbars
248(1)
Using Auto-Indexing
249(2)
Using Auto-Indexing to Set the For Loop Count
251(1)
Two-Dimensional Arrays
251(2)
Creating Two-Dimensional Arrays
252(1)
Activity 7-1: Building Arrays with Auto-Indexing
253(2)
Functions for Manipulating Arrays
255(5)
Activity 7-2: Array Acrobatics
260(2)
Polymorphism
262(2)
Activity 7-3: Polymorphism
264(2)
Compound Arithmetic
266(4)
A Word About Boolean Arithmetic
269(1)
All About Clusters
270(12)
Creating Cluster Controls and Indicators
271(1)
Cluster Order
272(1)
Using Clusters to Pass Data to and from SubVIs
273(1)
Replacing a Cluster Element
274(1)
Unbundling Your Clusters
275(1)
Activity 7-4: Cluster Practice
276(2)
Bundling and Unbundling by Name
278(2)
Activity 7-5: More Fun with Clusters
280(2)
Interchangeable Arrays and Clusters
282(2)
Comparison Function Modes for Arrays and Clusters
283(1)
Error Clusters and Error-Handling Functions
284(12)
Error Cluster Datatype
285(1)
Propagating Errors: Error Dataflow
286(1)
Generating and Reacting to Errors in SubVIs
287(4)
Handling Errors in SubVIs
291(1)
Generating Errors in SubVIs
291(1)
Giving Up: Displaying Error Messages to the User
292(1)
Extra Tips for Error Handling
293(3)
Wrap It Up!
296(2)
Additional Activities
298(3)
Activity 7-6: Reversing the Order Challenge
298(1)
Activity 7-7: Taking a Subset
298(1)
Activity 7-8: Dice! Challenge
298(1)
Activity 7-9: Multiplying Array Elements
299(2)
LabView's Exciting Visual Displays: Charts and Graphs
301(78)
Waveform Charts
301(8)
Chart Update Modes
301(2)
Single-Plot Charts
303(1)
Wiring a Multiple-Plot Chart
304(1)
Single-Plot Versus Multi-Plot Data Types: A Trick for Remembering
305(1)
Show the Digital Display?
306(1)
The X Scrollbar
306(1)
Clearing the Chart
306(1)
Stacked and Overlaid Plots
307(1)
Multiple Y Scales
308(1)
Chart History Length
309(1)
Activity 8-1: Temperature Monitor
309(5)
Graphs
314(4)
Single-Plot Waveform Graphs
314(2)
Multiple-Plot Waveform Graphs
316(2)
Activity 8-2: Graphing a Sine on a Waveform Graph
318(4)
XY Graphs
322(5)
Showing Optional Planes in an XY Graph
325(2)
Chart and Graph Components
327(7)
Playing with the Scales
328(4)
The Plot Legend
332(2)
Activity 8-3: Using an XY Graph to Plot a Circle
334(7)
Using the Graph Palette
336(1)
Graph Cursors
337(2)
Graph Annotations
339(2)
Activity 8-4: Temperature Analysis
341(3)
Intensity Charts and Graphs---Color as a Third Dimension
344(8)
Activity 8-5: The Intensity Graph
346(2)
3D Graphs
348(4)
Time Stamps, Waveforms, and Dynamic Data
352(18)
Time Stamp
352(4)
Waveforms
356(3)
Waveform Functions
359(4)
Activity 8-6: Generate and Plot a Waveform
363(2)
Digital Data
365(2)
Digital Waveform Graphs
367(1)
Dynamic Data
367(3)
Mixed Signal Graphs
370(4)
Exporting Images of Charts and Graphs
374(1)
Wrap It Up!
375(1)
Additional Activities
376(3)
Activity 8-7: Temperature Limit
376(1)
Activity 8-8: Max/Min Temperature Limit
376(1)
Activity 8-9: Plotting Random Arrays
377(2)
Exploring Strings and File I/O
379(40)
More About Strings
379(6)
Choose Your Own Display Type
379(3)
Single Line Strings
382(1)
Updating While You Type
383(1)
The Scrollbar
383(1)
Tables
383(1)
Listboxes
384(1)
Using String Functions
385(5)
Activity 9-1: String Construction
390(1)
Parsing Functions
391(8)
Match Pattern and Regular Expressions
393(6)
Activity 9-2: More String Parsing
399(1)
File Input/Output
400(15)
How They Work
401(1)
Express Writing and Reading of Measurement Files
401(2)
Writing and Reading Spreadsheet Files
403(2)
Activity 9-3: Writing to a Spreadsheet File
405(2)
Activity 9-4: Reading from the Spreadsheet File
407(1)
More Writing and Reading of Files
408(2)
Activity 9-5: Reading a Text File
410(2)
Activity 9-6: Writing and Reading Binary Files
412(3)
Wrap It Up!
415(1)
Additional Activities
416(3)
Activity 9-7: Temperatures and Time Stamps
416(1)
Activity 9-8: Spreadsheet Exercise
416(3)
Signal Measurement and Generation: Data Acquisition
419(46)
DAQ and Other Data Acquisition Acronyms
419(2)
How to Connect Your Computer to the Real World
421(2)
Signals 101
423(24)
Timing Is Everything
423(1)
Signal Classification
423(11)
Signal Conditioning
434(2)
Finding a Common Ground
436(3)
Measuring Differences
439(5)
Sampling, Aliasing, and Mr. Nyquist
444(2)
In Conclusion
446(1)
Selecting and Configuring DAQ Measurement Hardware
447(15)
Choosing Your Hardware
447(2)
Activity 10-2: Measurement System Analysis
449(1)
Installing DAQ Device Driver Software
450(1)
Measurement & Automation Explorer (MAX)
451(2)
NI-DAQmx
453(2)
Configuring NI-DAQmx Devices in MAX
455(3)
Configuring Data Acquisition
458(4)
Wrap It Up!
462(1)
Solutions to Activities
463(2)
Data Acquisition in LabView
465(58)
Understanding Analog and Digital I/O
465(18)
Using the DAQ Assistant
465(4)
Activity 11-1: Analog Input
469(3)
Analog I/O Terms and Definitions
472(6)
Digital I/O Terms and Definitions
478(5)
NI-DAQmx Tasks
483(18)
Creating NI-DAQmx Tasks in MAX
484(1)
Referencing MAX DAQmx Tasks in LabView
485(3)
Generating Code from MAX DAQmx Tasks
488(2)
Using NI-DAQmx Tasks in LabView
490(11)
Advanced Data Acquisition
501(19)
DAQmx Timing and DAQmx Trigger
501(5)
Multichannel Acquisition
506(2)
Continuous Data Acquisition
508(1)
Activity 11-7: Continuous Acquisition
508(4)
Streaming Data to a File
512(1)
Activity 11-8: Streaming Data to File
513(2)
Counting Frequency and Events
515(5)
Wrap It Up!
520(3)
Instrument Control in LabView
523(30)
Instrumentation Acronyms
523(1)
Connecting Your Computer to Instruments
524(6)
Using a GPIB Controller
524(2)
Getting Ready for Serial Communications
526(3)
Ethernet-Enabled Instruments
529(1)
SCPI, the Language of Instruments
530(1)
VISA: Your Passport to Instrument Communication
531(2)
VISA Resource Strings
531(1)
Configuring Your VISA Resources in MAX
532(1)
Instrument Control in LabView
533(18)
Using the Instrument I/O Assistant
534(1)
Instrument Drivers
535(2)
Find Instrument Drivers from LabView
537(2)
VISA Functions
539(3)
Advanced VISA Functions
542(2)
Bus/Interface Specific VISA Functions
544(1)
VISA GPIB Versus Traditional GPIB Functions
544(1)
VISA Serial Functions
545(2)
VISA USB Functions
547(1)
Create Your Own Instrument Driver: The Instrument Driver Wizard
548(3)
Wrap It Up!
551(2)
Advanced LabView Structures and Functions
553(120)
Local, Global, and Shared Variables
553(19)
Local Variables
554(5)
Activity 13-1: Using Local Variables
559(3)
Activity 13-2: Fun with Locals
562(1)
Activity 13-3: More Fun with Locals
563(1)
Global Variables
564(7)
Shared Variables
571(1)
Property Nodes
572(11)
Another Example
578(3)
Activity 13-4: Using Property Nodes with Charts
581(2)
Invoke Nodes
583(3)
Activity 13-5: Using Invoke Nodes to Export an Image from a Graph
584(2)
Event-Driven Programming: The Event Structure
586(18)
The Timeout Event
587(1)
Editing Events Handled by Event Structure Cases
588(2)
Using the Event Structure
590(2)
Event Smorgasbord
592(1)
Activity 13-6: Playing with Events
592(2)
Stopping While Loops That Contain Event Structures
594(3)
Activity 13-7: Using the Event Structure to Read Data Value Changes
597(4)
Advanced Concepts: Event Data Node and Event Filter Nodes
601(1)
Advanced Concepts: Notify Events Versus Filter Events
602(1)
Advanced Concepts: Dynamic Events and User Events
603(1)
Type Definitions
604(6)
Activity 13-8: Creating a Typedef
606(4)
The State Machine and Queued Message Handler
610(11)
The Standard State Machine
611(2)
Activity 13-9: Using the Standard State Machine
613(5)
The Queued Message Handler
618(3)
Messaging and Synchronization
621(23)
Queues
621(7)
Notifiers
628(5)
Semaphores: Locking and Unlocking Shared Resources
633(4)
Rendezvous
637(4)
Occurrences
641(3)
First Call?
644(1)
Structures for Disabling Code
644(3)
The Diagram Disable Structure
645(1)
The Conditional Disable Structure
646(1)
Halting VI and Application Execution
647(1)
Cool GUI Stuff: Look What I Can Do!
648(22)
System Controls and Colors
648(2)
Drag and Drop
650(3)
Tree Control
653(3)
Activity 13-11: Capturing Mouse Events on a Tree Control
656(2)
Tab Control
658(4)
Subpanels
662(1)
Splitter Bars
663(2)
Scrollbars
665(1)
Graphics and Sound
666(4)
Wrap It Up!
670(3)
Advanced LabView Data Concepts
673(48)
A Word About Polymorphic VIs
673(3)
Advanced File I/O: Text Files, Binary Files, and Configuration Files
676(11)
Opening and Closing File References
676(1)
Advanced File Functions
677(2)
End of File
679(2)
Activity 14-1: Reading a Text File
681(1)
Activity 14-2: Writing and Reading Binary Files
682(5)
Configuration (INI) Files
687(7)
Opening and Closing Configuration Files
688(1)
Writing and Reading Key Values
689(1)
Activity 14-3: Storing Data in a Configuration File
690(3)
Additional Configuration File Operations
693(1)
Calling Code from Other Languages
694(9)
Using the Call Library Function Node to Call DLLs
696(1)
Activity 14-4: Calling a DLL in LabView
697(6)
Fitting Square Pegs into Round Holes: Advanced Conversions and Typecasting
703(7)
You Can Be Anything: Variants
710(8)
Using Variants: Creating Generic Software Components
715(2)
ActiveX and the Variant Data Type
717(1)
Wrap It Up!
718(1)
Additional Activities
718(3)
Activity 14-5: Read Text File by Page
718(3)
Advanced LabView Features
721(78)
Exploring Your Options: The LabView Options Dialog
721(3)
Configuring Your VI
724(16)
SubVI Node Setup Options (Are Evil)
724(1)
Activity 15-1: Using SubVIs
725(3)
VI Properties Options
728(5)
Reentrant Execution
733(3)
Keyboard Navigation
736(4)
The VI Server
740(35)
Enabling Remote Access to the VI Server
743(2)
Properties and Methods, ``By Reference''
745(1)
Deja Vu: Property Nodes and Invoke Nodes
746(1)
Application References
747(3)
VI References
750(11)
Control References
761(13)
Activity 15-9: Building an Emergency Abort Utility
774(1)
Final Thoughts on VI Server
775(1)
Radices and Units
775(6)
Radices
776(1)
Units
777(4)
Automatically Creating a SubVI from a Section of the Block Diagram
781(4)
A Few More Utilities in LabView
785(11)
Custom Probes
785(5)
The VI Hierarchy Window
790(2)
Searching for Objects in the Virtual Haystack
792(1)
Replacing Search Result Items
792(2)
Find VIs on Disk
794(1)
More Tools
794(2)
Wrap It Up!
796(3)
Connectivity in LabView
799(54)
Your VIs on the Web: The LabView Web Server
799(7)
Configuring LabView's Built-in Web Server
799(2)
Publishing to HTML with LabView's Web Server
801(5)
Emailing Data from LabView
806(1)
Remote Panels
807(1)
Self-Describing Data: XML
808(5)
Sharing Data over the Network: Shared Variables
813(10)
Shared Variables in LabView Projects
813(5)
Binding Controls and Indicators to Shared Variables
818(1)
Programmatically Accessing Shared Variables Using DataSocket
819(4)
Talking to Other Programs and Objects
823(13)
.NET and ActiveX
823(9)
AppleEvents
832(1)
Pipes
833(3)
Talking to Other Computers: Network VIs
836(5)
TCP/IP
836(4)
UDP
840(1)
Databases
841(1)
Report Generation
842(9)
Express Report
843(1)
Easy Text Report
844(1)
Advanced Report Generation
845(6)
Wrap It Up!
851(2)
The Art of LabView Programming
853(38)
Why Worry About the Graphical Interface Appearance?
853(2)
Arranging, Decorating, Resizing, Grouping, and Locking
855(2)
Vive I'art: Importing Pictures
857(4)
Custom Controls and Indicators
861(6)
Adding Online Help
867(3)
Pointers and Recommendations for a ``Wow!'' Graphical Interface
870(5)
How Do You Do That in LabView?
875(6)
Memory, Performance, and All That
881(4)
Curing Amnesia and Slothfulness
881(3)
The Declaration of (Platform) Independence
884(1)
Programming with Style
885(3)
Modularize and Test Your VIs
886(1)
Document as You Go Along
886(1)
One More Time: Dataflow!
887(1)
Wrap It Up!
888(1)
Concluding Remarks
888(3)
Appendix A CD Contents 891(2)
Appendix B Add-on Toolkits for LabView 893(4)
Appendix C Open Source Tools for LabView: OpenG 897(4)
Appendix D LabView Object-Oriented Programming 901(20)
Appendix E Resources for LabView 921(4)
Appendix F LabView Certification Exams 925(6)
Glossary 931(28)
Index 959

Excerpts

Preface Preface LabVIEW is a graphical programming language that has been widely adopted throughout industry, academia, and research labs as the standard for data acquisition and instrument control software. LabVIEW is a powerful and flexible instrumentation and analysis software system that is multiplatform--you can run LabVIEW on Windows, Mac OS X, and Linux. You can also run LabVIEW on PDAs (PalmOS, PocketPC, or Windows CE devices), on real-time platforms, and even embed LabVIEW programs into FPGA chips and 32-bit microprocessors. Creating your own LabVIEW program, or virtual instrument (VI), is simple. LabVIEW's intuitive user interface makes writing and using programs exciting and fun! LabVIEW departs from the sequential nature of traditional programming languages and features an easy-to-use graphical programming environment, including all of the tools necessary for data acquisition (DAQ), data analysis, and presentation of results. With its graphical programming language, sometimes called "G," you program using a graphical block diagram that compiles into machine code. Ideal for a countless number of science and engineering applications, LabVIEW helps you solve many types of problems in only a fraction of the time and hassle it would take to write "conventional" code. Beyond the Lab LabVIEW has found its way into such a broad spectrum of virtual instrumentation applications that it is hard to know where to begin. As its name implies, it began in the laboratory and still remains very popular in many kinds of laboratories--from major research and development laboratories around the world (such as Lawrence Livermore, Argonne, Batelle, Sandia, Jet Propulsion Laboratory, White Sands, and Oak Ridge in the United States, and CERN in Europe), to R&D laboratories in many industries, and to teaching laboratories in universities all over the world, especially in the disciplines of electrical and mechanical engineering and physics. The spread of LabVIEW beyond the laboratory has gone in many directions--up (aboard the space shuttle), down (aboard U.S. Navy submarines), and around the world (from oil wells in the North Sea to factories in New Zealand). And with the latest Internet capabilities, LabVIEW applications are being deployed not only physically in many places, but virtually across networked applications. More and more people are creating web-based control or monitoring of their LabVIEW applications to allow remote access and instant information about what's happening in their lab. Virtual instrumentation systems are known for their low cost, both in hardware and development time, and their great flexibility. The Expanding World of Virtual Instrumentation Perhaps the best way to describe the expansion (or perhaps explosion) of LabVIEW applications is to generalize it. There are niches in many industries where measurements of some kind are required--most often of temperature, whether it be in an oven, a refrigerator, a greenhouse, a clean room, or a vat of soup. Beyond temperature, users measure pressure, force, displacement, strain, pH, and so on, ad infinitum. Personal computers are used virtually everywhere. LabVIEW is the catalyst that links the PC with measuring things, not only because it makes it easy, but also because it brings along the ability to analyze what you have measured and display it and communicate it halfway around the world if you so choose. After measuring and analyzing something, the next logical step often is to change (control) something based upon the results. For example, measure temperature and then turn on either a furnace or a chiller. Again, LabVIEW makes this easy to do; monitoring and control have become LabVIEW strengths. Sometimes it is direct monitoring and control, or it may be through communicating with a programmable logi


Please wait while the item is added to your cart...