Einführung in LabVIEW

 
 
Hanser (Verlag)
  • erschienen am 7. Juli 2015
  • |
  • 596 Seiten
 
E-Book | PDF mit Wasserzeichen-DRM | Systemvoraussetzungen
978-3-446-44407-2 (ISBN)
 
LabVIEW ist ein grafisches Programmiersystem und findet in der Messtechnik, der Regelungstechnik und der Automatisierungstechnik seine Hauptanwendungsgebiete. Dieses Lehrbuch führt in das Programmieren mit LabVIEW ein. Es richtet sich an Studierende, bietet aber ebenso Ingenieuren einen guten Einstieg für die Weiterbildung. Auch interessierte Schüler können von dieser Einführung profitieren.
Außer den Grundlagen zum Programmieren mit LabVIEW erläutert das Lehrbuch mathematische Voraussetzungen wie die Fouriertransformation, die Filterung und die Behandlung von Differentialgleichungen. Es folgen Informationen zur Kommunikation mit LabVIEW sowie Kapitel zur professionellen Programmentwicklung und zur FPGA-Programmierung.
Die 6. Auflage wurde komplett durchgesehen und aktualisiert. Zudem sind weitere Themenbereiche wie Skripting und XNodes hinzugekommen.

Die Test- bzw. Studentenversion kann auf der Homepage von National Instruments heruntergeladen werden.


Auf der Website www.geho-LabVIEW.de
finden Sie alle Beispiele des Lehrbuchs sowie Lösungen zu allen Übungsaufgaben und eine Linkliste.
1., erweiterte Auflage
  • Deutsch
  • München
  • |
  • Deutschland
  • 1018
  • |
  • 1018 farbige Abbildungen
  • |
  • Komplett in Farbe
  • 51,82 MB
978-3-446-44407-2 (9783446444072)
http://dx.doi.org/10.3139/9783446444072
weitere Ausgaben werden ermittelt
Prof. Dipl.-Math. Wolfgang Georgi lehrt an der Hochschule Ravensburg-Weingarten.
Er ist Certified LabVIEW Associate Developer (CLAD). M.Eng. Philipp Hohl ist Lehrbeauftragter an der Hochschule Ravensburg-Weingarten.
1 - Vorwort zur sechsten Auflage [Seite 6]
2 - Inhalt [Seite 8]
3 - Teil I: Grundlagen des Programmierens in LabVIEW [Seite 18]
3.1 - 1 Was ist LabVIEW? [Seite 20]
3.1.1 - 1.1 Entwicklungsstufen [Seite 20]
3.1.2 - 1.2 Was will dieses Lehrbuch? [Seite 22]
3.1.3 - 1.3 Installation [Seite 22]
3.1.4 - 1.4 Einführendes Beispiel [Seite 22]
3.1.4.1 - 1.4.1 Programmierung von c = a + b [Seite 26]
3.1.4.2 - 1.4.2 Speicherung als Programm Add.vi [Seite 29]
3.1.4.3 - 1.4.3 Starten und Stoppen von Add.vi [Seite 29]
3.1.4.4 - 1.4.4 Fehlersuche in Add.vi (Debugging) [Seite 30]
3.1.5 - 1.5 Beispiel für eine Grafik in LabVIEW [Seite 31]
3.1.6 - 1.6 Grundlegende Konzepte von LabVIEW [Seite 32]
3.1.6.1 - 1.6.1 Frontpanel [Seite 32]
3.1.6.2 - 1.6.2 Blockdiagramm [Seite 32]
3.1.7 - 1.7 Rezepte [Seite 33]
3.1.8 - 1.8 Shortcuts [Seite 34]
3.2 - 2 Einstellungen, Paletten [Seite 36]
3.2.1 - 2.1 Einstellungen [Seite 36]
3.2.1.1 - 2.1.1 Einstellungen von LabVIEW [Seite 36]
3.2.1.2 - 2.1.2 Frontpanel [Seite 37]
3.2.1.3 - 2.1.3 Blockdiagramm [Seite 38]
3.2.1.4 - 2.1.4 Ausrichtungsgitter [Seite 40]
3.2.1.5 - 2.1.5 Wiederherstellungen [Seite 40]
3.2.2 - 2.2 Paletten [Seite 40]
3.2.2.1 - 2.2.1 Werkzeugpalette (Tools Palette) [Seite 41]
3.2.2.2 - 2.2.2 Eingabe-/Ausgabe-Elemente [Seite 42]
3.2.2.3 - 2.2.3 Funktionenpalette [Seite 45]
3.2.2.4 - 2.2.4 Palette konfigurieren [Seite 48]
3.3 - 3 Programmstrukturen [Seite 49]
3.3.1 - 3.1 Strukturiertes Programmieren [Seite 49]
3.3.2 - 3.2 Sequenz [Seite 51]
3.3.3 - 3.3 Case-Struktur [Seite 54]
3.3.4 - 3.4 Schleifen [Seite 58]
3.3.5 - 3.5 Guter Programmierstil [Seite 62]
3.4 - 4 Datentypen [Seite 64]
3.4.1 - 4.1 Numerische Datentypen [Seite 64]
3.4.1.1 - 4.1.1 Kontextmenü: 'Darstellung' [Seite 64]
3.4.1.2 - 4.1.2 Kontextmenü: 'Anzeigeformat.' [Seite 65]
3.4.2 - 4.2 Boolesche Datentypen [Seite 67]
3.4.3 - 4.3 String und Pfad [Seite 69]
3.4.4 - 4.4 Arrays [Seite 72]
3.4.4.1 - 4.4.1 Definition und Initialisierung eines 1-dimensionalen Arrays [Seite 72]
3.4.4.2 - 4.4.2 Definition und Initialisierung eines 2-dimensionalen Arrays [Seite 74]
3.4.4.3 - 4.4.3 Array erstellen [Seite 75]
3.4.4.4 - 4.4.4 Rechnen mit Arrays: Addition [Seite 76]
3.4.4.5 - 4.4.5 Rechnen mit Arrays: Multiplikation [Seite 77]
3.4.4.6 - 4.4.6 Steuerung von For-Schleifen mit Arrays [Seite 78]
3.4.4.7 - 4.4.7 Behandlung einzelner Arrayelemente [Seite 80]
3.4.5 - 4.5 Cluster [Seite 82]
3.4.5.1 - 4.5.1 Erzeugung eines Clusters [Seite 83]
3.4.5.2 - 4.5.2 Clusterwerte ändern [Seite 84]
3.4.5.3 - 4.5.3 Aufschlüsseln eines Clusters [Seite 86]
3.4.5.4 - 4.5.4 Umordnen der Elemente eines Clusters [Seite 87]
3.4.5.5 - 4.5.5 Cluster-Arrays [Seite 88]
3.4.6 - 4.6 Ring & Enum [Seite 89]
3.4.7 - 4.7 Datentyp FXP [Seite 91]
3.4.8 - 4.8 Datentyp Variant [Seite 93]
3.4.9 - 4.9 Guter Programmierstil [Seite 95]
3.5 - 5 Unterprogramme und Typdefinitionen [Seite 97]
3.5.1 - 5.1 Wozu Unterprogramme (SubVIs)? [Seite 97]
3.5.2 - 5.2 Erstellen von Unterprogrammen [Seite 98]
3.5.2.1 - 5.2.1 Einführendes Beispiel [Seite 98]
3.5.2.2 - 5.2.2 Weitere Hinweise für die Erstellung eines Unterprogramms [Seite 101]
3.5.2.3 - 5.2.3 Einstellungen für Programme und Unterprogramme [Seite 103]
3.5.2.4 - 5.2.4 Erstellen von Unterprogrammen mit internem Zustand [Seite 105]
3.5.2.5 - 5.2.5 Erstellen von polymorphen Unterprogrammen [Seite 106]
3.5.3 - 5.3 Aufruf von Unterprogrammen [Seite 109]
3.5.3.1 - 5.3.1 Statische Bindung [Seite 109]
3.5.3.2 - 5.3.2 Dynamische Bindung [Seite 110]
3.5.3.2.1 - 5.3.2.1 VI-Referenz öffnen und schließen [Seite 110]
3.5.3.2.2 - 5.3.2.2 Aufruf eines VI über seine Referenz [Seite 111]
3.5.3.2.3 - 5.3.2.3 Beispiel für den SubVI-Austausch während der Laufzeit [Seite 113]
3.5.3.2.4 - 5.3.2.4 Rekursiver Aufruf von Unterprogrammen [Seite 113]
3.5.3.2.5 - 5.3.2.5 Testen (Debugging) von ablaufinvarianten SubVIs [Seite 114]
3.5.4 - 5.4 Typdefinitionen [Seite 116]
3.5.4.1 - 5.4.1 Beispiel einer Typdefinition für Enum-Variablen [Seite 116]
3.5.4.2 - 5.4.2 Beispiel einer Typdefinition für Registerkarten [Seite 118]
3.5.5 - 5.5 Guter Programmierstil [Seite 119]
3.5.5.1 - 5.5.1 Vereinfachung durch Unterprogramme und Typdefinitionen [Seite 119]
3.5.5.2 - 5.5.2 Aussagekräftige Symbole (Icons) [Seite 121]
3.5.5.3 - 5.5.3 Anordnung häufig verwendeter Elemente [Seite 121]
3.5.5.4 - 5.5.4 Kommentierung der Elemente und Funktionen eines VI [Seite 121]
3.5.5.5 - 5.5.5 Detaillierte Hilfe [Seite 123]
3.6 - 6 Prozessvisualisierung [Seite 124]
3.6.1 - 6.1 OOP-Konzepte [Seite 124]
3.6.2 - 6.2 Eigenschafts- und Methodenknoten [Seite 124]
3.6.3 - 6.3 Grafische Ausgabe [Seite 128]
3.6.3.1 - 6.3.1 Chart (Signalverlaufsdiagramm) [Seite 128]
3.6.3.1.1 - 6.3.1.1 Darstellung einer Sinuskurve [Seite 128]
3.6.3.1.2 - 6.3.1.2 Darstellung von zwei oder mehr Kurven in einem Chart [Seite 130]
3.6.3.1.3 - 6.3.1.3 Legende zu einem Chart oder Graphen [Seite 131]
3.6.3.1.4 - 6.3.1.4 Skalierung der Ordinate in einem Chart [Seite 132]
3.6.3.2 - 6.3.2 Graph (Signalverlaufsgraph) [Seite 134]
3.6.3.2.1 - 6.3.2.1 Darstellung einer Sinuskurve [Seite 134]
3.6.3.2.2 - 6.3.2.2 Darstellung von zwei oder mehr Kurven in einem Graphen [Seite 135]
3.6.3.2.3 - 6.3.2.3 Skalierung der Abszisse in einem Graphen [Seite 137]
3.6.3.3 - 6.3.3 XY-Graph [Seite 139]
3.6.3.3.1 - 6.3.3.1 Darstellung einer Relation im XY-Graphen [Seite 140]
3.6.3.3.2 - 6.3.3.2 Darstellung mehrerer Relationen in einem XY-Graphen [Seite 141]
3.6.3.4 - 6.3.4 Signalverlauf [Seite 142]
3.6.4 - 6.4 Express-VIs, Programmierstil [Seite 147]
3.6.4.1 - 6.4.1 Express-VI zur Erzeugung von Kurven [Seite 147]
3.6.4.2 - 6.4.2 Express-VI zur Erstellung von Berichten [Seite 148]
3.7 - 7 Referenzen, Fehlerfunktionen [Seite 150]
3.7.1 - 7.1 Einführendes Beispiel [Seite 150]
3.7.1.1 - 7.1.1 Vertauschung von zwei Variablenwerten [Seite 150]
3.7.1.2 - 7.1.2 Referenzen auf Bedien- und Anzeigeelemente [Seite 151]
3.7.1.3 - 7.1.3 Lösung des Vertauschungsproblems [Seite 152]
3.7.2 - 7.2 Vererbung [Seite 153]
3.7.2.1 - 7.2.1 Eigenschaften der Basisklasse [Seite 155]
3.7.2.2 - 7.2.2 Eigenschaften von abgeleiteten Klassen [Seite 155]
3.7.3 - 7.3 Fehlerfunktionen [Seite 157]
3.7.3.1 - 7.3.1 Fehlermeldungen mit oder ohne Dialog [Seite 157]
3.7.3.2 - 7.3.2 Wo findet man wichtige Fehlerelemente und Fehlerfunktionen? [Seite 158]
3.7.3.3 - 7.3.3 Verschiedene Fehlerarten [Seite 159]
3.7.3.3.1 - 7.3.3.1 Standardfehlerleitung [Seite 159]
3.7.3.3.2 - 7.3.3.2 Funktionen ohne oder mit vereinfachter Fehlerleitung [Seite 159]
3.7.3.4 - 7.3.4 Ausgang aus While-Schleifen [Seite 161]
3.7.3.5 - 7.3.5 Erzwingung von sequenziellem Ablauf [Seite 162]
3.8 - 8 Datentransfer von und zur Festplatte [Seite 163]
3.8.1 - 8.1 Dateifunktionen [Seite 163]
3.8.1.1 - 8.1.1 Allgemeines zur Speicherung von Dateien [Seite 163]
3.8.1.2 - 8.1.2 Palette Dateifunktionen [Seite 165]
3.8.1.3 - 8.1.3 Einführendes Beispiel [Seite 166]
3.8.1.4 - 8.1.4 Modifiziertes Beispiel [Seite 167]
3.8.1.5 - 8.1.5 Beispiel: Anlegen einer Protokolldatei [Seite 168]
3.8.1.6 - 8.1.6 Überschreiben ohne Warnung [Seite 168]
3.8.2 - 8.2 Pfade [Seite 169]
3.8.2.1 - 8.2.1 Pfadkonstanten [Seite 169]
3.8.2.2 - 8.2.2 Pfadkonstante 'Standardverzeichnis' [Seite 170]
3.8.2.3 - 8.2.3 'Standardverzeichnis' ändern [Seite 171]
3.8.2.4 - 8.2.4 'Standarddatenverzeichnis' ändern [Seite 172]
3.8.2.5 - 8.2.5 Lesen und Schreiben anderer Datentypen [Seite 172]
3.8.2.6 - 8.2.6 Verketten von Schreib- und Lesefunktionen [Seite 173]
3.8.2.7 - 8.2.7 Tabellenkalkulation [Seite 174]
3.8.3 - 8.3 Pfade in einer EXE-Datei [Seite 174]
3.8.4 - 8.4 Fortgeschrittene Dateitypen [Seite 176]
3.8.4.1 - 8.4.1 LVM- , TDMS- und TDM-Dateien [Seite 177]
3.8.4.2 - 8.4.2 Diadem [Seite 180]
3.8.4.3 - 8.4.3 ZIP-Dateien [Seite 180]
3.8.4.4 - 8.4.4 Konfigurationsdateien [Seite 182]
3.9 - 9 LabVIEW-Kurzüberblick [Seite 186]
3.9.1 - 9.1 Aufbau des LabVIEW-Systems [Seite 186]
3.9.1.1 - 9.1.1 Programmierung in G [Seite 186]
3.9.1.1.1 - 9.1.1.1 Interpretieren oder kompilieren? [Seite 186]
3.9.1.1.2 - 9.1.1.2 Datenflussprogrammierung [Seite 188]
3.9.1.2 - 9.1.2 Hardware-Unterstützung [Seite 188]
3.9.1.3 - 9.1.3 Bibliotheken mathematischer und technischer Funktionen [Seite 189]
3.9.1.4 - 9.1.4 Benutzerschnittstelle [Seite 190]
3.9.1.5 - 9.1.5 Technologische Abstraktion [Seite 191]
3.9.1.6 - 9.1.6 Rechenmodelle [Seite 191]
3.9.2 - 9.2 Projekte [Seite 191]
3.9.3 - 9.3 Erstellung von EXE-Dateien [Seite 193]
3.9.3.1 - 9.3.1 Erstellung einer EXE-Datei [Seite 193]
3.9.3.2 - 9.3.2 EXE-Datei auf einem Rechner ohne LabVIEW-System [Seite 195]
3.9.4 - 9.4 Strukturen zur Programmentwicklung [Seite 198]
3.9.4.1 - 9.4.1 Deaktivierungsstrukturen [Seite 198]
3.9.4.2 - 9.4.2 Debug-Einstellung in der Projektverwaltung [Seite 200]
3.9.5 - 9.5 LabVIEW-Bibliotheken [Seite 201]
3.9.6 - 9.6 Umwandeln von LLB-Bibliotheken [Seite 203]
3.9.7 - 9.7 Einbindung von C-Funktionen unter Windows [Seite 205]
3.9.7.1 - 9.7.1 Reihe in C# [Seite 206]
3.9.7.2 - 9.7.2 Reihe in C++ [Seite 210]
3.9.7.3 - 9.7.3 Reihe mit MathScript [Seite 214]
3.9.8 - 9.8 Hilfen zu LabVIEW [Seite 214]
3.9.9 - 9.9 Schnelleinfügeleiste (Quickdrop) [Seite 216]
3.9.10 - 9.10 Der VI Package Manager [Seite 218]
3.9.10.1 - 9.10.1 Verwalten der LabVIEW-Entwicklungsumgebung [Seite 219]
3.9.10.2 - 9.10.2 Eigenes Paket erstellen [Seite 221]
4 - Teil II: Technische Anwendungen [Seite 222]
4.1 - 10 Fouriertransformation [Seite 223]
4.1.1 - 10.1 Zeit- und Frequenzbereich [Seite 223]
4.1.1.1 - 10.1.1 Die reelle Fouriertransformation [Seite 224]
4.1.1.2 - 10.1.2 Darstellung der Fourierkoeffizienten c_k in LabVIEW [Seite 227]
4.1.2 - 10.2 Diskrete Fouriertransformation [Seite 230]
4.1.2.1 - 10.2.1 Satz von Shannon [Seite 230]
4.1.2.2 - 10.2.2 Aliasing [Seite 232]
4.1.2.3 - 10.2.3 Frequenzauflösung [Seite 233]
4.2 - 11 Filterung [Seite 235]
4.2.1 - 11.1 Filtertypen [Seite 235]
4.2.1.1 - 11.1.1 Ideale und reale Filter [Seite 235]
4.2.1.2 - 11.1.2 Beispiel eines digitalen Filters [Seite 236]
4.2.2 - 11.2 LabVIEW-Filterfunktionen [Seite 239]
4.2.3 - 11.3 Filterung im Frequenzbereich [Seite 241]
4.2.3.1 - 11.3.1 Idee der Filterung im Frequenzbereich [Seite 241]
4.2.3.2 - 11.3.2 Die inverse Fouriertransformation in LabVIEW [Seite 241]
4.2.3.3 - 11.3.3 Beispiel eines Tiefpasses [Seite 242]
4.3 - 12 Differenzialgleichungen [Seite 244]
4.3.1 - 12.1 Lösen mit LabVIEW-ODE-Funktionen [Seite 244]
4.3.2 - 12.2 Lösen nach dem Analogrechnerprinzip [Seite 246]
4.3.2.1 - 12.2.1 Blockdiagramm-Darstellung [Seite 246]
4.3.2.2 - 12.2.2 Vereinfachungen [Seite 249]
4.3.3 - 12.3 Genauigkeit numerischer Verfahren [Seite 251]
4.4 - 13 Systeme von Differenzialgleichungen [Seite 254]
4.4.1 - 13.1 Systeme gewöhnlicher Differenzialgleichungen [Seite 254]
4.4.2 - 13.2 Gekoppeltes Feder-Masse-System [Seite 254]
4.4.2.1 - 13.2.1 Lösung mit eingebauter ODE-Funktion [Seite 255]
4.4.2.2 - 13.2.2 Lösung mit Blockdiagramm wie in MATLAB® [Seite 256]
4.4.3 - 13.3 Umwelt und Tourismus [Seite 258]
4.5 - 14 Parallelverarbeitung, Laufzeiten, Ereignisse [Seite 261]
4.5.1 - 14.1 Einführendes Beispiel [Seite 261]
4.5.2 - 14.2 Grundbegriffe der Parallelverarbeitung [Seite 263]
4.5.2.1 - 14.2.1 Multiprocessing, Multitasking, Multithreading [Seite 263]
4.5.2.2 - 14.2.2 Synchronisierung von Prozessen [Seite 264]
4.5.3 - 14.3 Parallelverarbeitung unter LabVIEW [Seite 265]
4.5.3.1 - 14.3.1 Erzeugen von Ressourcen für die Prozesskommunikation [Seite 266]
4.5.3.2 - 14.3.2 Freigabe von Ressourcen der Prozesskommunikation [Seite 268]
4.5.3.3 - 14.3.3 Zeitbegrenzung Ressource schont Prozessor [Seite 269]
4.5.4 - 14.4 Prozess-Synchronisierung ohne Datenaustausch [Seite 269]
4.5.4.1 - 14.4.1 Occurrences [Seite 269]
4.5.4.2 - 14.4.2 Semaphor [Seite 270]
4.5.4.3 - 14.4.3 Rendezvous [Seite 272]
4.5.5 - 14.5 Prozess-Synchronisierung mit Datenaustausch [Seite 273]
4.5.5.1 - 14.5.1 Melder-Operationen [Seite 273]
4.5.5.2 - 14.5.2 Queue-Operationen [Seite 274]
4.5.6 - 14.6 Globale Variablen [Seite 275]
4.5.7 - 14.7 Laufzeitprobleme und ihre Behandlung [Seite 276]
4.5.7.1 - 14.7.1 Laufzeitprobleme bei lokalen Variablen [Seite 276]
4.5.7.2 - 14.7.2 Laufzeitprobleme bei globalen Variablen [Seite 279]
4.5.8 - 14.8 Ereignisgesteuerte Programmierung [Seite 280]
4.5.8.1 - 14.8.1 Frontpanel-Ereignisse [Seite 280]
4.5.8.2 - 14.8.2 Wertänderungs-Ereignisse [Seite 285]
4.5.8.3 - 14.8.3 Gefilterte Ereignisse [Seite 286]
4.5.9 - 14.9 Zeitschleifen [Seite 288]
5 - Teil III: Kommunikation [Seite 290]
5.1 - 15 Serielle Eingabe/Ausgabe [Seite 291]
5.1.1 - 15.1 RS-232 [Seite 291]
5.1.2 - 15.2 Programmierung der RS-232 in LabVIEW [Seite 293]
5.1.3 - 15.3 Die USB-Schnittstelle [Seite 296]
5.1.4 - 15.4 Feld-Bus, CAN-Bus [Seite 300]
5.1.4.1 - 15.4.1 CAN-Protokoll [Seite 300]
5.1.4.2 - 15.4.2 CAN-Interface [Seite 302]
5.1.4.3 - 15.4.3 CANopen-Protokoll, ZILA-Sensor [Seite 303]
5.1.4.4 - 15.4.4 CAN-Bus mit Laptop und zwei Sensoren [Seite 305]
5.1.4.5 - 15.4.5 XNET-System von National Instruments [Seite 305]
5.1.5 - 15.5 Der byte-serielle GPIB-Bus [Seite 316]
5.2 - 16 Datenerfassungsgeräte [Seite 318]
5.2.1 - 16.1 Datenerfassungskarten/Datenerfassungsgeräte [Seite 318]
5.2.2 - 16.2 Allgemeines [Seite 319]
5.2.2.1 - 16.2.1 Treiber, MAX (Measurement and Automation Explorer) [Seite 319]
5.2.2.2 - 16.2.2 Physikalische und virtuelle Kanäle, Task [Seite 325]
5.2.2.3 - 16.2.3 Programmierung von Datenerfassungs-VIs, simulierte Geräte [Seite 326]
5.2.2.4 - 16.2.4 Programmierung von VIs zur Analogausgabe [Seite 331]
5.2.2.5 - 16.2.5 Programmierung von VIs zum Digital-I/O [Seite 332]
5.2.2.6 - 16.2.6 Programmierung mit Hilfe des DAQ-Assistenten [Seite 332]
5.2.2.7 - 16.2.7 Programmatische Task-Erstellung [Seite 334]
5.2.3 - 16.3 USB-Gerät NI USB-6251 [Seite 335]
5.2.3.1 - 16.3.1 Begriffe 'differenziell', 'RSE' und 'NRSE' [Seite 335]
5.2.3.2 - 16.3.2 Zwei Analogsignale mit der NI USB-6521 lesen [Seite 337]
5.2.3.3 - 16.3.3 Triggern mit NI USB-6521 [Seite 338]
5.2.3.4 - 16.3.4 Streaming mit NI USB-6521 [Seite 339]
5.2.4 - 16.4 Ältere Datenerfassungskarten/-geräte [Seite 346]
5.2.5 - 16.5 TEDS [Seite 346]
5.2.6 - 16.6 IVI-Gerät NI USB-513 [Seite 350]
6 - Teil IV: Fortgeschrittene Techniken [Seite 356]
6.1 - 17 Professionelle Programmentwicklung [Seite 357]
6.1.1 - 17.1 Sequenzstruktur [Seite 357]
6.1.2 - 17.2 Zustandsautomaten [Seite 358]
6.1.2.1 - 17.2.1 Notation für Zustandsautomaten [Seite 359]
6.1.2.2 - 17.2.2 Umsetzung Zustandsdiagramm - LabVIEW-Programm [Seite 360]
6.1.2.2.1 - 17.2.2.1 Strings für die Zustandsauswahl [Seite 361]
6.1.2.2.2 - 17.2.2.2 Enum für die Zustandsauswahl [Seite 363]
6.1.3 - 17.3 Münzautomat [Seite 364]
6.1.4 - 17.4 Münzautomat mit Queues und Ereignisstrukturen [Seite 373]
6.1.5 - 17.5 Programmierhilfen [Seite 377]
6.1.5.1 - 17.5.1 Arbeiten mit vorgefertigten Strukturen (Templates) [Seite 377]
6.1.5.2 - 17.5.2 Beurteilung Programmeffizienz und geeignete Werkzeuge dazu [Seite 377]
6.2 - 18 Objektorientierte Programmierung [Seite 381]
6.2.1 - 18.1 Warum objektorientiert? [Seite 381]
6.2.2 - 18.2 Erstes Beispiel zur objektorientierten Programmierung [Seite 384]
6.2.2.1 - 18.2.1 Bildung einer Klasse [Seite 384]
6.2.2.2 - 18.2.2 Private Eigenschaften der Klasse [Seite 385]
6.2.2.3 - 18.2.3 Methoden der Klasse [Seite 386]
6.2.3 - 18.3 Weitere Beispiele zur OOP [Seite 390]
6.2.3.1 - 18.3.1 Vererbung [Seite 390]
6.2.3.2 - 18.3.2 Polymorphie [Seite 394]
6.2.3.3 - 18.3.3 Modulaustausch [Seite 398]
6.2.4 - 18.4 Schutz einer Klassenbibliothek [Seite 406]
6.3 - 19 LabVIEW: Tabellenkalkulation, Datenbanken [Seite 409]
6.3.1 - 19.1 Schreib-/Lesebefehle zur Tabellenkalkulation [Seite 409]
6.3.2 - 19.2 Allgemeines über ActiveX [Seite 411]
6.3.2.1 - 19.2.1 ActiveX-Container in LabVIEW [Seite 412]
6.3.2.2 - 19.2.2 ActiveX in LabVIEW zur Steuerung von Anwendungen [Seite 414]
6.3.3 - 19.3 Beispiele zur Anwendung auf Excel [Seite 415]
6.3.3.1 - 19.3.1 Öffnen und Schließen von Excel [Seite 416]
6.3.3.2 - 19.3.2 Sichtbarmachen einer Excel-Tabelle [Seite 417]
6.3.3.3 - 19.3.3 Eintragen von Daten in eine Excel-Tabelle [Seite 419]
6.3.3.4 - 19.3.4 Geschwindigkeit der Datenspeicherung [Seite 421]
6.3.3.5 - 19.3.5 Erstellen von Makros zum Umwandeln einer Tabelle in eine Grafik [Seite 422]
6.3.3.6 - 19.3.6 Aufruf von Makros in LabVIEW mit Hilfe von ActiveX [Seite 425]
6.3.3.7 - 19.3.7 Erhöhung der Geschwindigkeit [Seite 426]
6.3.3.8 - 19.3.8 Schreiben mehrerer Dateien [Seite 429]
6.3.4 - 19.4 Microsoft-Datenbank Access [Seite 433]
6.3.4.1 - 19.4.1 Einführung [Seite 433]
6.3.4.2 - 19.4.2 Verbindung mit der Datenbank [Seite 434]
6.3.4.3 - 19.4.3 SQL [Seite 436]
6.3.4.4 - 19.4.4 Verwendung von SubVIs [Seite 437]
6.4 - 20 Internet, Server und Client [Seite 438]
6.4.1 - 20.1 Allgemeine Bemerkungen zum Internet [Seite 438]
6.4.1.1 - 20.1.1 Ethernet [Seite 438]
6.4.1.2 - 20.1.2 Ethernet-Karten, MAC- und IP-Adresse [Seite 439]
6.4.1.3 - 20.1.3 TCP/IP-Protokoll [Seite 439]
6.4.2 - 20.2 Einfaches LabVIEW-Beispiel: Ping [Seite 440]
6.4.3 - 20.3 Programmieren mit DataSocket [Seite 442]
6.4.4 - 20.4 Programmieren mit TCP/IP [Seite 444]
6.4.4.1 - 20.4.1 Server und Client [Seite 444]
6.4.4.2 - 20.4.2 Beispiel für die Übertragung von Sinusdaten über TCP/IP [Seite 445]
6.4.5 - 20.5 Webdienste [Seite 448]
6.4.5.1 - 20.5.1 Grundbegriffe [Seite 448]
6.4.5.2 - 20.5.2 Struktur der Webdienstkommunikation [Seite 449]
6.4.5.3 - 20.5.3 Erstes einfaches Beispiel [Seite 449]
6.4.5.4 - 20.5.4 Zweites einfaches Beispiel [Seite 454]
6.4.5.5 - 20.5.5 Drittes Beispiel [Seite 457]
6.4.5.6 - 20.5.6 Dreiecksberechnung [Seite 458]
6.4.5.7 - 20.5.7 Webserver im Internet [Seite 463]
6.4.5.7.1 - 20.5.7.1 Firmeninternes Netz [Seite 463]
6.4.5.7.2 - 20.5.7.2 Aufruf im Internet [Seite 464]
6.5 - 21 Compact RIO-System und FPGA [Seite 465]
6.5.1 - 21.1 Definition [Seite 465]
6.5.2 - 21.2 Installation [Seite 467]
6.5.2.1 - Schritt 1: Software-Installation auf dem PC [Seite 467]
6.5.2.2 - Schritt 2: Zusammenstellen der cRIO-Hardware [Seite 468]
6.5.2.3 - Schritt 3: Zuweisung einer IP-Adresse zum cRIO-System [Seite 468]
6.5.2.4 - Schritt 4: Installation weiterer Software auf dem cRIO-System [Seite 471]
6.5.2.5 - Schritt 5: Verbindung eines PC mit einem cRIO-System im Netz [Seite 471]
6.5.3 - 21.3 Programmierbeispiele für FPGA [Seite 472]
6.5.3.1 - 21.3.1 Beispiel zur Digitalausgabe [Seite 473]
6.5.3.2 - 21.3.2 Beispiel eines Zählers [Seite 478]
6.5.3.3 - 21.3.3 FPGA-Anwendung: Ermittlung eines Frequenzganges [Seite 480]
6.5.3.4 - 21.3.4 Umgebungsvariablen [Seite 490]
6.5.3.4.1 - 21.3.4.1 Projekt 'Shared_Einzeln' [Seite 491]
6.5.3.4.2 - 21.3.4.2 Projekt 'Shared_Netzwerk' [Seite 493]
6.5.3.4.3 - 21.3.4.3 Projekt 'Shared_cRIO' [Seite 496]
6.5.3.5 - 21.3.5 FPGA-Anwendungen auf dem cRIO-9014 ohne PC-Unterstützung [Seite 498]
6.5.3.5.1 - 21.3.5.1 Projekt 'RIO_MOD1_Switch' [Seite 498]
6.5.3.5.2 - 21.3.5.2 Projekt 'RIO_User1_Switch' [Seite 500]
6.5.3.5.3 - 21.3.5.3 Umstellung des cRIO-Systems von einem Standalone-Projekt zum nächsten [Seite 503]
6.6 - 22 XControls [Seite 505]
6.6.1 - 22.1 Unterschied zu einfachen Ctls [Seite 505]
6.6.2 - 22.2 Anzeige der Flugbahn eines Steines [Seite 505]
6.6.3 - 22.3 Erstellen eines XControls [Seite 507]
6.6.3.1 - 22.3.1 Allgemeines Rezept [Seite 507]
6.6.3.2 - 22.3.2 Beispiel XControl_Pfeil.xctl [Seite 509]
6.6.3.3 - 22.3.3 Eigenschaften in einem XControl [Seite 515]
6.6.3.4 - 22.3.4 Bedeutung der Rahmen [1] bis [4] im Fassaden-VI [Seite 518]
6.6.3.5 - 22.3.5 Weitere Verbesserungen [Seite 524]
6.6.4 - 22.4 XControl zur Erstellung von Symbolleisten [Seite 526]
6.6.4.1 - 22.4.1 Zustand der Symbolleiste [Seite 527]
6.6.4.2 - 22.4.2 Funktionen der Symbolleiste [Seite 528]
6.6.4.2.1 - 22.4.2.1 Symbole hinzufügen [Seite 528]
6.6.4.2.2 - 22.4.2.2 Alle Symbole löschen [Seite 529]
6.6.4.2.3 - 22.4.2.3 Rückmeldung des Symbols, das unter dem Mauszeiger liegt [Seite 529]
6.6.4.2.4 - 22.4.2.4 Anpassung des Erscheinungsbilds an eigene Bedürfnisse [Seite 533]
6.6.4.3 - 22.4.3 Leistungsmerkmal 'Status für Speichern umwandeln' [Seite 533]
6.7 - 23 LabVIEW VI-Skripte [Seite 535]
6.7.1 - 23.1 Was sind VI-Skripte [Seite 535]
6.7.2 - 23.2 Die VI-Skripte-Funktionen in der Palette anzeigen [Seite 535]
6.7.3 - 23.3 Die VI-Skripte-Funktionen [Seite 537]
6.7.3.1 - 23.3.1 Neues VI [Seite 537]
6.7.3.2 - 23.3.2 Neues VI-Objekt [Seite 538]
6.7.3.3 - 23.3.3 VI-Objektreferenz öffnen [Seite 540]
6.7.3.4 - 23.3.4 Abstand des neuen VI-Objekts vom Referenzobjekt [Seite 540]
6.7.3.5 - 23.3.5 GObjects suchen [Seite 542]
6.7.3.6 - 23.3.6 GObject-Beschriftung abfragen [Seite 543]
6.7.3.7 - 23.3.7 Klassenhierarchie mittels Klassennamen ermitteln [Seite 543]
6.7.3.8 - 23.3.8 Weiterführende Informationen [Seite 545]
6.7.4 - 23.4 Wo werden VI-Skripte eingesetzt? [Seite 546]
6.7.5 - 23.5 Modifizierung der Projektvorlage 'Leeres VI' [Seite 547]
6.7.6 - 23.6 Erstellen eines Quickdrop Plugins mit VI-Skripting [Seite 551]
6.8 - 24 XNodes [Seite 554]
6.8.1 - 24.1 Einführung [Seite 554]
6.8.2 - 24.2 Regelungstechnische Anwendung [Seite 555]
6.8.3 - 24.3 Aufbau eines XNodes [Seite 557]
6.8.4 - 24.4 Wie bildet man einen XNode? [Seite 557]
6.8.4.1 - 24.4.1 Vorbereitende Überlegungen [Seite 557]
6.8.4.2 - 24.4.2 Programmierung von NeueKuh.xnode [Seite 562]
6.8.4.2.1 - 24.4.2.1 Template-VI [Seite 562]
6.8.4.2.2 - 24.4.2.2 Ability-VIs [Seite 563]
6.8.5 - 24.5 Wie ändert man einen XNode? [Seite 572]
6.8.6 - 24.6 XNodes in der Funktionspalette speichern [Seite 572]
7 - Literatur [Seite 576]
8 - Index [Seite 578]

Dateiformat: PDF
Kopierschutz: Wasserzeichen-DRM (Digital Rights Management)

Systemvoraussetzungen:

Computer (Windows; MacOS X; Linux): Verwenden Sie zum Lesen die kostenlose Software Adobe Reader, Adobe Digital Editions oder einen anderen PDF-Viewer Ihrer Wahl (siehe E-Book Hilfe).

Tablet/Smartphone (Android; iOS): Installieren Sie die kostenlose App Adobe Digital Editions oder eine andere Lese-App für E-Books (siehe E-Book Hilfe).

E-Book-Reader: Bookeen, Kobo, Pocketbook, Sony, Tolino u.v.a.m. (nur bedingt: Kindle)

Das Dateiformat PDF zeigt auf jeder Hardware eine Buchseite stets identisch an. Daher ist eine PDF auch für ein komplexes Layout geeignet, wie es bei Lehr- und Fachbüchern verwendet wird (Bilder, Tabellen, Spalten, Fußnoten). Bei kleinen Displays von E-Readern oder Smartphones sind PDF leider eher nervig, weil zu viel Scrollen notwendig ist. Mit Wasserzeichen-DRM wird hier ein "weicher" Kopierschutz verwendet. Daher ist technisch zwar alles möglich - sogar eine unzulässige Weitergabe. Aber an sichtbaren und unsichtbaren Stellen wird der Käufer des E-Books als Wasserzeichen hinterlegt, sodass im Falle eines Missbrauchs die Spur zurückverfolgt werden kann.

Weitere Informationen finden Sie in unserer E-Book Hilfe.


Download (sofort verfügbar)

31,99 €
inkl. 7% MwSt.
Download / Einzel-Lizenz
PDF mit Wasserzeichen-DRM
siehe Systemvoraussetzungen
E-Book bestellen