Computergestütztes Messsystem Datenerfassung Unter Verwendung Von NI-USB-Modulen Und Bereitstellung Einer Grafischen Oberfläche Mittels C#

BACHELORARBEIT
Computergestütztes Messsystem
Datenerfassung unter Verwendung von NI-USB-Modulen und
Bereitstellung einer grafischen Oberfläche mittels C#
durchgeführt am Bachelorstudiengang
Informationstechnik und System-Management
Fachhochschule Salzburg GmbH
vorgelegt von
Tobias Kazmierczak, Fatih Keskin, Andreas Plötzeneder
Studiengangsleiter: FH-Prof. DI.Dr. Gerhard Jöchtl

Betreuer: Peter Ott
Salzburg, Januar 2010

Eidesstattliche Erklärung
Ich/Wir versichere(n) an Eides statt, dass ich/wir die vorliegende Bachelorarbeit ohne fremde
Hilfe und ohne Benutzung anderer als der angegebenen Quellen und Hilfsmittel angefertigt
und alle aus ungedruckten Quellen, gedruckter Literatur oder aus dem Internet im Wortlaut
oder im wesentlichen Inhalt übernommenen Formulierungen und Konzepte gemäß den
Richtlinien wissenschaftlicher Arbeiten zitiert, bzw. mit genauer Quellenangabe kenntlich
gemacht habe(n). Diese Arbeit wurde in gleicher oder ähnlicher Form weder im In- noch im
Ausland in irgendeiner Form als Prüfungsarbeit vorgelegt und stimmt mit der durch die
BegutachterInnen beurteilten Arbeit überein.
Ort, Datum Name und Unterschrift der/s Studierenden

Kurzzusammenfassung
Diese Bachelorarbeit befasst sich mit einem Laptopmesssystem, welches mit Hilfe von
National Instruments USB-Modulen Daten erfassen, diese mathematisch analysieren als auch
in mehreren Formaten in einen Report zusammenfassen kann. Dieses Laptopmesssystem,
welches mit C#.NET entwickelt wurde, unterscheidet sich von einem Standardoszilloskop.
Nicht zuletzt aufgrund ihrer mathematischen Funktionen, sondern auch wegen der einfachen
Weiterverarbeitungsschnittstellen zu anderen Programmen. So kann dieses Laptopmesssystem
Daten unter anderem in das CSV Format exportieren, welches mittels MatLab einfach
weiterzuverarbeiten ist.
Abstract
This Bachelor these deals with a Laptop-measurement-system, which acquires data from
National Instruments USB-modules. The Application can analyse data and create reports in
various formats. It is developed in C#.NET differs from a classic Oscilloscope. Not only
because of the mathematical functions, but also because of the interface, which can transport
data to other Applications. It can export data in the CSV Format, which can be continued to
use in MatLab.
Inhaltsverzeichnis
1 Einleitung ........................................................................................................................... 6
1.1 Vorgehensweise ........................................................................................................... 6
1.1.1 Phase 0: Initialisierung ......................................................................................... 7
1.1.2 Phase 1: Problemanalyse ...................................................................................... 7
1.1.3 Phase 2: Entwurf................................................................................................... 8
1.1.4 Phase 3: Implementierung .................................................................................. 10
1.1.5 Phase 4: System- und Abnahmetests .................................................................. 12
1.1.6 Phase 5: Nutzung, Wartung, Betrieb, Schulung ................................................. 13
1.2 Dokumentation........................................................................................................... 13
1.2.1 Dokumentationswerkzeug .................................................................................. 13
1.2.2 Erstellung von Help-Files ................................................................................... 14
2 DAQmx Schnittstelle........................................................................................................ 15
2.1 Leistungen und Eigenschaften des DAQmx .............................................................. 15
2.1.1 Analogmodule .................................................................................................... 15
2.1.2 Digitalmodule ..................................................................................................... 16
2.2 Die Programmierschnittstelle von National Instruments ........................................... 16
2.3 Auslesen von Geräteeigenschaften ............................................................................ 17
2.4 Auslesen von analogen Signalen ............................................................................... 18
2.4.1 Initialisieren des Geräts ...................................................................................... 19
2.4.2 Kontinuierliche Signalerfassung ........................................................................ 21
2.5 Auslesen von digitalen Signalen ................................................................................ 22
2.5.1 Initialisieren des Geräts ...................................................................................... 23
2.5.2 Einmalige Signalerfassung ................................................................................. 23
2.6 Paralleles Auslesen mehrerer Signale ........................................................................ 24
2.7 Erstellung einer Klasse .............................................................................................. 24
3 Graphical User Interface................................................................................................... 25
3.1 Struktur der Graphical User Interface ........................................................................ 25
3.2 Grundlegendes Benutzeroberflächenschema ............................................................. 25
3.2.1 Menü ................................................................................................................... 25
3.2.2 Darstellungsfenster ............................................................................................. 26
3.2.3 Einstellung für die Abtastrate: ............................................................................ 27
3.2.4 History Capacity ................................................................................................. 27
3.3 Datenübernahme ........................................................................................................ 27
3.4 Signaleigenschaften ................................................................................................... 28
3.4.1 Struktur ............................................................................................................... 30
3.5 Digitale Messung ....................................................................................................... 31
3.6 Externe Steuerelemente ............................................................................................. 31
3.6.1 Warum ein eigenes Steuerelement? .................................................................... 32
3.7 Berechnungen ............................................................................................................ 32
3.8 Screenshots erstellen .................................................................................................. 32
4 Signalberechnungsfunktionen .......................................................................................... 33
4.1 Warum Signalanalyse und -manipulation? ................................................................ 33
4.2 Einfache Berechnungsfunktionen .............................................................................. 33
4.2.1 Invertierung des Signals ..................................................................................... 33
4.2.2 Minimal- und Maximalwert eines Signals.......................................................... 33
4.2.3 Amplitudenmessung eines Signals ..................................................................... 35
4.2.4 Addition, Subtraktion und Multiplikation zweier Signale.................................. 35
4.2.5 Effektivwertberechnung ..................................................................................... 35
4.3 Frequenzmessung....................................................................................................... 36
4.3.1 Messung auf Basis von Nulldurchgängen .......................................................... 36
4.3.2 Messung durch Fouriertransformation ............................................................... 36
4.3.3 Frequenzmessung durch FFT ............................................................................. 38
5 Reporting .......................................................................................................................... 40
5.1 Implementierung ........................................................................................................ 40
5.2 Singleton - Konzept ................................................................................................... 40
5.3 Interne Datenspeicherung .......................................................................................... 40
5.4 Hinzufügen einer neuen Messung.............................................................................. 41
5.5 Endgültige Speicherung ............................................................................................. 42
5.6 Formate ...................................................................................................................... 43
5.6.1 HTML ................................................................................................................. 43
5.6.2 PDF ..................................................................................................................... 44
5.6.3 XML ................................................................................................................... 45
5.6.4 CSV .................................................................................................................... 45
6 Zusammenfassung und Ausblick ...................................................................................... 47
7 Literaturangaben ............................................................................................................... 48
Literaturverzeichnis .................................................................................................................. 48
8 Anhang ............................................................................................................................. 50
8.1 Abbildungsverzeichnis............................................................................................... 50
8.2 Quellcode ................................................................................................................... 50
Einleitung – Andreas Plötzeneder Seite 6
1 Einleitung
Das Thema dieser Bachelorarbeit befasst sich mit der Erfassung, Bearbeitung und visuellen
Darstellung von diskreten und kontinuierlichen Signalen am Computer. Als Grundlage dienen
hierfür die Funktionen eines Oszilloskops. Um die grundlegenden Anforderungen zu
bearbeiten und gleichzeitig eine praxistaugliche Software zu entwickeln, wird eine
Applikation mit ähnlicher Funktionalität wie der eines Oszilloskops entwickelt.
Nicht alle Modi eines digitalen Oszilloskops (siehe Abbildung 1) sind mit einfachen
Messkarten realisierbar, aber die neu entwickelte Software soll durch spezielle Funktionen am
PC, wie beispielsweise eine Fouriertransformationsfunktion oder ein Reportingtool für den
Anwender attraktiv werden.
Die Realisierung der Steuerung der Software ähnlicher der eines Oszilloskops wäre zwar
möglich, aber in einer Software nicht zweckmäßig: Es wäre beispielsweise widersinnig, die
Einstellung der Maximalspannung mittels Drehknöpfen umzusetzen, weil der PC eine
Tastatur zur Verfügung stellt, mit welcher genaue Werte eingegeben werden können.
Abbildung 1: Hardware Oszilloskop [1]
1.1 Vorgehensweise
„Wenn man mit einer komplexen Aufgabe konfrontiert ist, versucht man, den Lösungsprozeß
systematisch zu gliedern, d.h. ein Vorgehensmodell zu definieren. Ein solches
Vorgehensmodell regelt den Ablauf des Lösungsprozesses. Es unterteilt ihn in überschaubare
Abschnitte und soll dadurch eine schrittweise Planung, Durchführung, Entscheidung und
Kontrolle ermöglichen.“ [2]
Abbildung 2: Vorgehensmodell eines Softwareentwicklungsprozesses1
Betrachtet man einen Softwareentwicklungsprozess sehr abstrakt, so kann dieser in mehrere

Phasen (siehe Abbildung 2) unterteilt werden [3].
1.1.1 Phase 0: Initialisierung

In dieser Phase wird der Auftrag erteilt. Die oben bereits diskutierte Fragestellung wird
erarbeitet und eine grobe Struktur der zu bearbeitenden Probleme aufgestellt.
1.1.2 Phase 1: Problemanalyse

Das Ziel dieser Phase ist ein Pflichtenheft, das heißt, eine Beschreibung von genauen
Erfolgsvorgaben und die Erstellung eines Zeitplans mit sogenannten Meilensteinen. Das sind
1
Quelle: http://winfor.uni-wuppertal.de/fileadmin/wolff/Downloads/Grundstudium/EWI/Phasenmodelle.pdf
Vorgaben, wann und durch wen bestimmte Komponenten des Projekts abgeschlossen sein
müssen. Zu diesen Komponenten gehören neben Software-Teilen auch Projektmanagement-
Aufgaben, wie etwa die Einhaltung des Phasenmodells.
Bei der Problemanalyse werden zusätzlich zur technischen Funktionalität, eine sinnvolle
Strukturierung des Programms und eine umsetzungsfreundliche Einteilung in Komponenten
als wichtige Faktoren erachtet. Weiter wird ein System zur Verifikation der Funktionen (Unit-
Tests, Gesamttests), sinnvolle Dokumentierung, und ein konsequentes, softwareunterstütztes
Vorgehen bei der Teamarbeit beschlossen.
Die genannten Punkte und etwaige Besonderheiten werden in den jeweiligen Abschnitten
genauer erläutert.
Folgende technische Funktionalität sollte die Software ausführen können:
• Messen von analogen und digitalen Signalen
• Darstellen der gemessenen Werte
• Berechnungsfunktionen
• Reporting-Tool
Zur Entwicklung wurde C# .NET 3.5 verwendet. Diese Wahl wurde aufgrund der
einzigartigen Kompatibilität mit den Treibern der NI USB Modulen getroffen.
1.1.3 Phase 2: Entwurf

Die Anforderungen legten eine Unterteilung in folgende vier Teile nahe:
• Datenerfassung
• Graphical User Interface (GUI)
• Berechnung
• Reporting
Es wurden bei dem Entwurf zwei verschiedene Kommunikationsmodelle diskutiert, wie in
Abbildung 4 ersichtlich ist.
GUI Datenerfassung
Reporting Berechnung
GUI
Datenerfassung Berechnung Reporting
Abbildung 3: Kommunikationsmodelle
Im oberen Fall (Abbildung 4) fordert die GUI die Daten bei der Datenerfassung an, diese
werden zur Berechnung gesendet und kommen dann wieder bei der GUI an. Hierbei käme
jedoch das "Stille Post Prinzip" zum Tragen. Durch das Senden von Informationen über
Umwege kann es zu Fehlern kommen, die unter Umständen fatale Konsequenzen haben.
Um dies zu verhindern, wurde das zweite Konzept verwendet, das einen etwas höheren
Informationsoverhead hat. Bei diesem Modell nimmt die GUI die zentrale Stelle ein, von
dieser werden sämtliche Daten versendet und empfangen. Dies macht Sinn, da die GUI auch
die "Endstelle" für Informationen und die "Anfangsstelle" für Entscheidungen widerspiegelt.
Will ein Benutzer beispielsweise Daten von einem gewünschten Gerät erfassen und diese
dann mittels FFT betrachten, so geschieht, wie man auch in Abbildung 5 erkennen kann,
folgendes:
1. Die GUI fordert die Datenerfassung auf, die Daten zu liefern.
2. Die GUI nimmt die Daten von der Datenerfassung entgegen
3. Sie sendet selbige an die Berechnung
4. Die Berechnung liefert Daten an die GUI zurück

5. Die GUI zeigt die Daten an
Abbildung 4:: Verwendetes Kommunikationsmodell
In jedem dieser Operationen ist die GUI Klasse im Spiel. Dies garantiert eine bessere
Kontrolle und verhindert
verhindert Datenmanipulation beim Versand über etwaige Drittklassen.
Weiter bietet es dem Entwickler
Entwickler die Möglichkeit beim Debugging, einzelne Komponenten
separat zu betrachten. Derartige Komponententests ermöglichen eine schnelle und effiziente
Fehlersuche und Fehlerlokalisierung [4].
[4]
1.1.4 Phase 3: Implementierung

Die genaue Umsetzung
Umsetzung der einzelnen Komponenten wird
wird in den nachfolgenden Kapiteln 2, 3
und 4 erläutert. An dieser Stelle soll auf zwei Hilfsmittel eingegangen werden, die während
der Realisierungsphase verwendet wurden.
Codeverwaltung mittels Subversion

Subversion
bversion (SVN)
(SVN) ist eine Versionkontrollsoftware,
Versionkontrollsoftware, welche von CollabNet im Jahr 1999
veröffentlicht wurde. Es wird dazu verwendet um Versionen von Dateien verschiedenster Art,
wie z.B. Quellcode, Webseiten, Veröffentlichungen oder auch Dokumentationen zu verwalten
[5].
Ein Alternativprodukt stellt CVS (Concurrent Versions System) dar,, wobei SVN der Vorzug
gegeben wurde, weil es mittels eines Plugins in Visual Studio eingebunden werden kann...
kann...
Mittlerweile bietet Google in einem Projekt "Google Code" bereits kostenfreies Subversion
Hosting für Opensourceprojekte an [6].
Folgende Eigenschaften von Subversion sind für das Projekt relevant:
• Das Verschieben, Umbenennen, Kopieren, Löschen von Dateien wird protokolliert.
• Jede Änderung enthält eine Versionsnummer.
• SVN erzeugt keine Fehler durch Überschreiben. (Zwei Personen bearbeiten eine Datei
=> Möglichkeit des Zusammenfügens)
Für Subversion gibt es mittlerweile eine Vielzahl an Clients. In unserem Projekt haben wir
uns für TortoiseSVN [7] und VisualSVN [8] entschieden. Ersteres kann über den Explorer
angesprochen werden. Wohingegen VisualSVN bietet die Möglichkeit in Microsoft Visual
Studio verwendet zu werden.
Hardware mittels TeamViewer

Als einer der letzten Schritte nach dem Zusammenfügen der Softwarekomponenten, ist wie
dem Phasenplan (siehe Kapitel 1.1) zu entnehmen ist, ein Gesamttest durchzuführen. Mehrere
Entwickler können dies jedoch nicht von verschiedenen Standorten machen, wenn nur eine
Hardware zur Verfügung steht. Hier muss auf eine Remote-Control-Software zurückgegriffen
werden.
Hierzu gibt es eine Vielzahl von Tools wie z.B. das bekannte VNC. Dieses hat jedoch den
Nachteil, dass man eine öffentlich sichtbare IP Adresse benötigt, um auf den VNC Server
zuzugreifen zu können.
Die Firma TeamViewer GmbH bietet eine Remote-Control-Software, die ohne öffentliche IP
Adresse auskommt. Mithilfe der gleichnamigen Software (TeamViewer), kann auf ein System
in einem Netzwerk hinter einem Router zugegriffen werden.
In der Software TeamViewer muss lediglich eine ID und ein Kennwort auf dem Server
gelesen (siehe Abbildung 7), und diese wiederrum auf dem Client eingegeben werden.
Abbildung 5: TeamViewer Applikation
Ist man nun eingeloggt (Abbildung 6) so kann man wie auf dem lokalen PC arbeiten.
Abbildung 6: TeamViewer - entfernter Desktop
1.1.5 Phase 4: System- und Abnahmetests

Abschliessend werden mit dem Kunden Abnahmetests durchgeführt. Hierbei wird nicht nur
überprüft ob das System fehlerfrei ist, sondern auch ob es im Kundenumfeld funktioniert,
bzw. ob es Probleme bei der Arbeit des Kunden mit der Software gibt
Frei nach Rupert Schützbach (Schriftsteller): "So ehrlich kann ein Mensch gar nicht sein, dass
er sich nicht selbst belügt… [9]" wurde entschieden, UnitTests zu entwickeln. Mit diesem
Grundprinzip wird dem Problem entgegen getreten, Fehler nicht objektiv zu erkennen. So
entwickelt beispielsweise GUI Programmierer die Testumgebung für das Reporting usw.
Erst nach Abschluss der einzelnen Unittests werden diese in das Gesamtsystem integriert.
Wie in Abbildung 7 ersichtlich ist, stellt die GUI das zentrale, steuernde Element dar, in die
sämtliche Units integriert werden.
Nach der erfolgten Integration wird das System als Ganzes getestet. Die nun auftretenden
Fehler sollten gering sein, sodass ein zerlegen des Gesamtsystems in die einzelnen
Komponenten nicht nötig ist.
Unittest Integration in GUI Datenerfassung
Abbildung 7: Testablauf
1.1.6 Phase 5: Nutzung, Wartung, Betrieb, Schulung

In dieser Phase wird die Software dem Auftraggeber / Projektleiter gut dokumentiert
übergeben. Dieser erhält somit sämtliche Dokumentationen des Sourcecode aber auch jener
der GUI Bedienung. Diese Dokumentation (siehe Kapitel 1.2) wurde während der
Programmierung erstellt.
1.2 Dokumentation
Eine ausführliche und aktuelle Dokumentation stellt in der heutigen Softwareentwicklung
einen oft vernachlässigten aber sehr wichtigen Bestandteil dar. Hierzu bieten verschiedene
Hersteller Tools an, um den Entwickler zu unterstützen.
1.2.1 Dokumentationswerkzeug
Sandcastle ist ein Dokumentationswerkzeug von Microsoft, welches automatisch auf Basis
der C# XML Dokumentation und der .NET Assemblies eine Sourcecode- erzeugt, weswegen
eine Verwendung naheliegend ist.
Das Sandcastle Paket umfasst eine Vielzahl von Building-Tools, welche zum Generieren von
Hilfedateien und HTML-Hilfen dienen. Man kann die Sandcastle-Tools über die
Kommandozeile ansteuern, allerdings haben sich mittlerweile mehrere grafische Tools (siehe
Kapitel 1.2.2) etabliert, die diesen Aufwand ersparen.
1.2.2 Erstellung von Help-Files

Die populärsten Tools hierzu sind der SandCastle HelpFileBuilder und DocProject. Beide
Tools sind OpenSource und somit ist der SourceCode frei verfügbar.
Im Gegensatz zum SandCastle HelpFileBuilder lässt sich DocProject in Visual Studio
integrieren. Weiter unterstützt es das Einbinden von Bildern und enthält einen WYSIWG-
XML-Designer. Somit eignet sich docProjekt ideal zum Erstellen komplexer Hilfedateien.
Es ist jedoch nicht das vorwiegende Interesse komplexe Hilfedateien zu erstellen. Benötigt
wird eine einfache, klar strukturierte Hilfe und Dokumentation der Programme, weswegen die
Wahl auf den SandCastle HelpFileBuilder fiel [10]. Die Software kann HTML Help 1.x
(.CHM Dateien) HTML Help 2.x (HxS Dateien) und Webseiten erstellen.
DAQmx Schnittstelle – Tobias Kazmierczak Seite 15
2 DAQmx Schnittstelle
Die Datenerfassung des Programms stellt eine Schnittstelle dar, die von dem Graphical User
Interface2 Anweisungen zum Durchführen von Messungen bekommt. Um die Hardware zu
benutzen, müssen die von National Instruments3 bereitgestellten Treiber installiert werden.
Hinweis: Der verwendete Quelltext wurde für die Erklärungen vereinfacht und ist in dieser
Form nicht lauffähig. Codeteile mit Befehlen für den Zugriff auf den NI DAQmx müssen
beispielsweise zur Fehlerbehandlung mit einem try-catch Block umfasst werden. Der
vollständige und lauffähige Quellcode findet sich im Anhang.
2.1 Leistungen und Eigenschaften des DAQmx

Bei der Entwicklung des Programms wurde ein NI CompactDAQ Chassis verwendet, das acht
Slots bereitstellt. Es kann sowohl digitale als auch analoge Eingangs- und Ausgangsmodule
aufnehmen und wird via USB 2.0 an den Computer angeschlossen. Die Module sind Plug-
and-Play fähig und werden ohne Neustart vom Programm erkannt [11].
2.1.1 Analogmodule
Die Analogeingangsmodule von NI werden mit „NI 92xx“ gekennzeichnet. Diese bieten eine
maximale Abtastrate von 500kSamples/s bei einer Auflösung von maximal 24-Bit [12].
Die theoretischen Möglichkeiten einer Messung sollen am Beispiel des Moduls NI 9233
erklärt werden:
• Maximale Spannung: +/- 5V. Darauf ergibt sich ein Eingangs-Spannungsbereich von
10V.
• Auflösung: 24-Bit. Dies entspricht 2^24, also 16777216 Werten. Das bedeutet, dass
der Spannungsbereich mit einer Genauigkeit von 0,596 µVolt erfasst werden kann
(siehe Formel 1).
ܷ௠௜௡ =
∆ܷ
2௡
Formel 1: Berechnung der Genauigkeit bei n-Bit
Wobei ∆U den Spannungsreich festlegt und n die Anzahl der Bit.
• Abtastrate: 50kS/s. Pro Sekunde können 50000 Messwerte ausgelesen werden. Laut
des Abtasttheorems von Shannon könnte theoretisch ein Signal bis 25kHz korrekt
2
dt. grafische Benutzerschnittstelle, im folgenden GUI abgekürzt
3
nachfolgend mit NI abgekürzt
abgetastet werden. Bei Prototypen des Programms trat allerdings ein Problem auf, das
in Abbildung
bildung 8 genauer veranschaulicht ist und nachfolgend näher erklärt wird:
wird
Abbildung
bildung 8:: Sinusabtastung
Wenn an den Punkten A und C abgetastet wird, dann ergibt die Messung kein Signal (rote
Linie), wenn die Punkte B und D abgetastet werden, ist zumindest der grobe Signalverlauf
erkennbar (grüne Linie). Bei
Bei ungünstiger Lage der Abtastpunkte wird also im schlechtesten
Fall kein Signal abgetastet. Praktisch können mit dem Modul nur Signale bis zu einer
Frequenz von 13,5 kHz abgetastet werden. Die Leistungsfähigkeit der Abtastung ist außerdem
durch die Anzahl der Kanäle auf dem Modul begrenzt
begr [12].
2.1.2 Digitalmodule
Die Digitalmodule haben die Bezeichnung „NI NI 94xx“
94xx und verfügen
erfügen je nach Modul über bis zu
32 Kanäle. Im Vergleich zu den Analogmodulen wird hier die Abtastung nicht in Samples pro
Sekunde angegeben, sondern in Sekunden zwischen den Abtastungen. Beim Modul NI 9435
ist zum Beispiel "3ms" angegeben, was bedeutet, dass pro Sekunde 333 Werte ermittelt
werden können. Das schnellste Modul,
Modul, das NI ist der Produktpalette 2009 anb
anbietet,
ietet, ist das NI
9423. Es erreicht eine Abtastung von 1 Million Werten pro Sekunde
Seku [13]
[13].
2.2 Die Programmierschnittstelle von National Instruments

National Instruments hat mit dem TDM (Technical Data Management) ein flexibles
Date
Datenmodell
ell entwickelt, welches in allen NI Tools und als DLL zur Verfügung steht. Die
.NET Klassenbibliothek
Klassenbibliothek ist besonders für TDM Streaming (TDMS) optimiert und kam in
diesem Projekt zum Einsatz. Abbildung 9: TDM Datenmodell zeigt die Struktur des TDM-
Datenmodells [14].
Abbildung 9: TDM Datenmodell [14]
Die Vorteile von TDMS zeigen sich an verschiedenen Stellen in diesem Softwareprojekt und
werden in diesem Kapitel noch ausführlicher beschrieben. Zusammengefasst werden
Messdaten von mehreren Modulen in einem Datentyp gespeichert. Dabei lassen sich, wie in
Abbildung 9 dargestellt, weitere zusätzliche Informationen über das Signal abrufen. Als
Beispiel sei ein fortlaufender Zeitstempel der Messdaten, beginnend bei 0 Sekunden am
Anfang der Messung, genannt [14].
2.3 Auslesen von Geräteeigenschaften

Für das korrekte Auslesen von Messwerten aus den verschiedenen Modulen müssen bereits
vor der Initialisierung bestimmte Informationen über das Gerät bekannt sein. Es ist nicht
ausreichend, von Benennung der Module (92xx für Analog und 94xx für Digital) auf ihre
Eigenschaften zu schließen. Vielmehr tritt hier der Vorteil der .NET API von NI zum
Vorschein. Über entsprechende Befehle lassen sich relevante Informationen über ein
eingestecktes Modul abrufen. Hierbei wird über die Channel, bzw. Portlänge (Code 1, Zeile 1,
9) ermittelt, ob ein Gerät ein analoges oder digitales Signal verarbeitet. Für die noch zur
Initialisierung notwendigen Eigenschaften eines Moduls werden in einer Methode, getInfo()
benannt, folgende Informationen als String-Array zurückgegeben (Codelisting 1).
1 if (DaqSystem.Local.LoadDevice(device).AIPhysicalChannels.Length != 0)
2 i = new string[5] {
3 "ai",
4 DaqSystem.Local.LoadDevice(device).AIVoltageRanges[0].ToString(),
5 DaqSystem.Local.LoadDevice(device).AIVoltageRanges[1].ToString(),
6 DaqSystem.Local.LoadDevice(device).AIMinimumRate.ToString(),
7 DaqSystem.Local.LoadDevice(device).AIMaximumSingleChannelRate.ToString(),
8 };
9 else if (DaqSystem.Local.LoadDevice(device).DIPorts.Length != 0)
10 i = new string[2] {
11 "di",
12 DaqSystem.Local.LoadDevice(device).DILines.Length.ToString(),
13 };
Codelisting 1: Modulinformationen ausgeben
Das zurückgegebene String-Array enthält als erstes Element die Art des Moduls.
Werden Informationen über ein Analogmodul zurückgegeben, enthält das Array fünf
Elemente. Mit einem falsch konfigurierten Wertebereich für die Spannung lässt sich das
Auslesen von Daten nicht starten. Deswegen wird in Zeile 4 und 5 die Unter- bzw.
Obergrenze des Spannungsbereiches ausgelesen. Bei einer ungültigen Angabe der Abtastrate
werden Messwerte falsch wiedergegeben. Bei dem Unterschreiten der Abtastrate (Codelisting
1, Zeile 6) wird der Puffer nicht vollständig gefüllt. Aus diesen Gründen müssen vor der
Initialisierung des Moduls diese Informationen bereitstehen und werden deswegen in einer
Methode bereitgestellt.
Für das Auslesen von digitalen Modulen werden keine weiteren Parameter benötigt. Die
Rückgabe der Bitlänge eines Ports (Zeile 9) wird für die Darstellung im der GUI benötigt,
weil dort je nach verwendetem Port eine variable Anzahl von simulierten LEDs
(Leuchtdioden) angezeigt werden.
2.4 Auslesen von analogen Signalen

Bei dem Erfassen von analogen Messdaten kann zwischen drei verschiedenen Methoden
gewählt werden [15]:
• ModeFiniteSamples: Einmaliges Auslesen einer festgelegten Anzahl von Werten.
• ModeContinuousSamples: Ständiges Auslesen von Messwerten in einen Puffer bis der

Task (enthält Informationen über eine Messung und ihre Aktivität) gestoppt wird.
Sobald der Puffer voll ist, wird ein Event ausgelöst, das die Messdaten verarbeitet und
den Puffer leert.
• ModeHardwareTimedSinglePoint: Ständiges Auslesen von Messwerten ohne Puffer

mittels Hardware Timing. Dieses garantiert, dass unabhängig von softwarebedingten
Schwankungen in bestimmten Zeitabständen Messungen durchgeführt werden.
Für das Programm wurde der „ModeContinuosSamples“ gewählt. Die kontinuierliche
Datenfassung war ein wichtiges Kriterium, damit man ähnlich wie mit einem Oszilloskop
messen kann. Der softwaregesteuerte gepufferte Lesevorgang der Werte wurde dem Hardware
Timing vorgezogen, da es eine größere Flexibilität bietet, bei dem Programm wichtig ist.
2.4.1 Initialisieren des Geräts

Für jeden Messvorgang am DAQmx muss ein Task (Code 2, Zeile 1) erzeugt werden, zu dem
dann ein oder mehrere Kanäle hinzugefügt werden können. Die Methode zum Hinzufügen
einer analogen Spannungsmessung heißt CreateVoltageChannel (Code 2, Zeile 2) und wird im
Folgenden genauer erklärt:
1 Task t = new Task();
2 t.AIChannels.CreateVoltageChannel(
3 device, "",
4 (AITerminalConfiguration)(-1),
5 Convert.ToInt32(i[1]),
6 Convert.ToInt32(i[2]),
7 AIVoltageUnits.Volts);
Codelisting 2: Analogen Input initialisieren
Als erstes Argument wird der Name des Geräts übergeben, von dem Messdaten zu lesen sind.
Bei der Initialisierung wird aus einem physischen Kanal ein virtueller erstellt. Der Name für
diesen wird als zweites Argument übergeben. Wird es leer gelassen, entspricht der virtuelle
Name dem physischen. Er wird benötigt, um Einstellungen zu ändern oder Funktionen
aufzurufen [16].
Die AITerminalConfiguration legt die Art der Messung im Bezug auf geerdete und erdfreie
Signalquellen fest. Auf jedem Modul ist ein Schaltplan aufgedruckt, wie die Signalquellen bei
einer Messung zu erden sind. Jedoch kann man je nach Gerät noch manuell zwischen
folgenden Modi wählt werden [16]:
• Reference Single-Ended
• Non-Reference Single-Ended
• Differential
• Pseudodifferential
Durch die Übergabe des Parameters "-1" wird die Standardeinstellung verwendet. Bei
erdfreien Signalquellen ist darauf zu achten, dass der Gleichspannungsbereich den
Messbereich nicht überschreitet. Dabei wird der Pegel des Signals im Bezug auf die Masse
des Messaufbaus bezogen [16]. Dabei ist besonders bei Verwendung von
Instrumentenverstärkern zu achten. Bei geerdeten Signalen kann es bei sogenannten
Masseschleifen zu Störungen im 50 Hz-Bereich kommen, wenn der Signalpegel bei geerdeten
Signalquellen nicht hoch genug ist. Bei Messungen ist generell zu beachten: Sind zwei
Signalgeneratoren über den Masseanschluss verbunden, kann es immer noch zu
Unterschieden von 10 bis 200mV bei einer Messung kommen [16].
In Zeile 5 und 6 des Codelistings 2 wird der Wertebereich für die Messung übergeben. Die
Variable i wurde mit Informationen aus der Funktion getInfo() gefüllt (siehe Kapitel 2.3
"Auslesen von Geräteeigenschaften"). Es wir also der gesamte Messbereich verwendet. Bei
Messungen, bei denen nur ein bestimmter Spannungsbereich zu erwarten ist, kann man hier
einen kleineren Wertebereich festlegen, um genauere Ergebnisse zu erzielen (siehe Formel 2:
Abzubildender Wertebereich“). Die gesamte Auflösung des Geräts wird dann nur im
definierten Bereich genutzt.
Mit dem letzten Argument lässt sich die Einheit festlegen, in der das Messergebnis
zurückgegeben werden soll. Neben der Einheit Volt lassen sich auch benutzerdefinierte
Skalen festlegen. Wird zum Beispiel ein Thermoelement angeschlossen, kann direkt in Grad
Celsius umgerechnet werden. Da aber die Klasse nur eine reine Ausgabe von Messdaten
erfordert, wurde diese Möglichkeit nicht genutzt.
Um Messwerte zu erhalten, muss vor dem Starten des Tasks ein Taktgenerator konfiguriert
werden. Diese Anweisung gilt für alle Geräte und kann nicht auf einzelne Geräte angewendet
werden. Die Parameter für diese Funktion werden im Folgenden näher erklärt:
t.Timing.ConfigureSampleClock("", rate,
SampleClockActiveEdge.Rising,
SampleQuantityMode.ContinuousSamples, 1000);
Codelisting 3: Sample Clock initialisieren
Der erste Parameter gibt eine Quelle für den Taktgeber an. Das kann zum Beispiel ein Gerät
mit der Adresse /dev/clock1 sein. Wird die Variable auf einen leeren Wert gesetzt, wird der
interne Taktgenerator verwendet.
Als nächster Parameter wird die Abtastrate in Werte pro Sekunden übergeben. Überschreitet
dieser die vom Modul maximal mögliche Tastfrequenz, wird kein Fehler ausgegeben, sondern
einfach mit dieser abgetastet. Deswegen werden nicht erfasste Werte einfach mit dem letzten
Abtastwert gefüllt, um das Ergebnis mit Modulen, die eine höhere Abtastung unterstützen,
vergleichbar zu machen [16].
Bei der Initialisierung ist zu beachten, dass die übergebenen Einstellungen nicht überprüft
werden, bis der Task gestartet wird oder folgende Funktion zur Verifikation der Parameter
aufgerufen wird:
myTask.Control(TaskAction.Verify);
Codelisting 4: Überprüfen des Tasks
Wenn der Task nicht lauffähig ist, wird eine CNiDAQmxExecption geworfen, die Auskunft
über den aufgetretenen Fehler gibt. So wird verhindert, dass ein Task gestartet wird, der nicht
lauffähig ist. Deswegen muss diese von einem try-catch Block umgeben werden.
2.4.2 Kontinuierliche Signalerfassung

Um kontinuierlich Abtastwerte zu erfassen, verwendet die .NET Library von NI Ereignisse
(Events). Im Folgenden wird der notwendige Quellcode erläutert.
Mit der Methode AnalogMultiChannelReader kann der Datenstrom (Stream), den ein Gerät
dem Task zur Verfügung stellt, ausgelesen werden. Das "Multi" im Namen weißt darauf hin,
das im Vergleich zum AnalogSingleChannelReader der Datenstrom mehrere Kanäle in einem
Task verarbeiteten kann. (Codelisting 5, Zeile 1)
Die Methode für das Auslesen von Daten wird asynchron aufgerufen. Das bedeutet, dass eine
Operation abhängig von der zuvor ausgeführten gestartet wird. Mit dem Code in Zeile 2 wird
die Methode für den Callback vorbereitet.
Programm
Task starten
Pufferfüllstand
Callback wird ausgelöst: Daten werden verarbeitet
Abbildung 10: Asynchrones Auslesen von Daten
Mit der Übergabe der Anzahl der zu lesenden Samples, des Callbacks und dem
entsprechenden Task wird die Datenerfassung begonnen (siehe Zeile 4). Der referenzierte
Task dient zur Unterscheidung von anderen asynchronen Aufrufen und erlaubt es, weitere
Informationen zu dem Task hinzuzufügen. Welche Daten erfasst werden sollen, wurde bereits
in Zeile 2 mit der Übergabe des Datenstroms festgelegt.
1 analogInReader = new AnalogMultiChannelReader(myTask.Stream);
2 analogCallback = new AsyncCallback(AnalogInCallback);
3 analogInReader.BeginReadWaveform(1000, analogCallback, myTask);
Codelisting 5: Vorbereitung zur Datenerfassung
Bei jeder weiteren Datenerfassung wird die in Codelisting 6 aufgeführte Methode aufgerufen.
Zunächst wird überprüft, ob runningTask den Task referenziert, der vom Callback aufgerufen
wird. Sollte die Variable zwischenzeitlich durch einen Stop Button auf NULL gesetzt worden
sein, werden keine Werte mehr erfasst (siehe Zeile 2).
Der Code in Zeile 3 gibt die Daten in einen NI spezifischen Datentyp zurück, der nicht nur die
Abtastwerte enthält, sondern auch weitere nützliche Informationen (siehe TDMS, Kapitel
2.2.). Da die Methode aufgerufen wird, wenn der definierte Puffer (Codelisting 5, Zeile 4)
voll ist, werden 1000 Samples zurückgegeben. Diese werden folglich der GUI zur weiteren
Verarbeitung übergeben. In Zeile 5 wird der Befehl zum Füllen des Puffers gegeben, der bei
dem nächsten Callback verarbeitet wird.
1 private void AnalogInCallback(IAsyncResult ar) {
2 if (runningTask == ar.AsyncState) {
3 data = analogInReader.EndReadWaveform(ar);
4 sendDataToWfPlot(data, plots);
5 analogInReader.BeginMemoryOptimizedReadWaveform(1000, analogCallback,
6 myTask, data);
7 }
8 }
Codelisting 6: Callbackgesteuerte Datenerfassung
Damit der Benutzer die Abtastrate intuitiv wahrnehmen kann, wird festgelegt, jeweils 1000
Samples pro Callback aus dem Puffer zu holen. Bei hoher Abtastrate wird das Anzeigefenster
sehr häufig aktualisiert, bei niedriger seltener. In Tabelle 1 werden die linearen
Zusammenhänge zwischen Parametern und Anzeigeergebnissen aufgeführt:
Abtastrate Puffergröße Anzeigekapazität # der Puffer Anzeigezeit Aktualisierungen
in S/s in N in S in N in s pro s
2000 1000 2000 2 1 2
2000 1000 10000 10 5 2
10000 1000 1000 1 0,1 10
10000 1000 10000 10 1 10
Tabelle 1: Zusammenhänge zwischen Parametern und Anzeigeergebnissen
Soll das Signal einmalig ausgegeben werden, wenn der Puffer voll ist, verwendet man
SampleQuantityMode.FiniteSamples in Zeile 10 (siehe Codelisting 2).
2.5 Auslesen von digitalen Signalen

Beim Auslesen digitaler Signale erhält man keine Spannungswerte in einer festgelegten
Auflösung, sondern es wird eine bestimmte Anzahl (n) von Anschlüssen ausgelesen, die
entweder LOW oder HIGH sein können. Je nach der Größe von n lässt sich ein bestimmter
Wertebereich abbilden. In Formel 2 steht mmax für die Anzahl der unterschiedlichen Werte.
݉௠௔௫ = 2௠
Formel 2: Abzubildender Wertebereich
Für das kontinuierliche Auslesen von digitalen Signalen wird eine externe Clock benötigt.
Um die Bedienung des Programms zu vereinfachen, wurde beim Auslesen von digitalen
Signalen darauf verzichtet. Technisch wird das kontinuierliche Einlesen von Daten mit einem
Timer realisiert, der in Abständen von minimal 50ms den aktuellen Signalwert abfragt.
2.5.1 Initialisieren des Geräts

Die Initialisierung bei digitalen Modulen funktioniert im Bezug auf die ersten zwei Parameter
gleich wie bei der für analoge (siehe Kapitel 2.4.1.).
Bei der Angabe des dritten Parameters (Codelisting 7, Zeile 3) gibt die Dokumentation zwei
Möglichkeiten vor:
• OneChannelForEachLine: Dabei lässt sich jeder digitale Anschluss separat auslesen.
• OneChannelForAllLines: Alle digitalen Anschlüsse eines Modules werden als ein

Kanal zurückgegeben.
1 Task t = new Task();
2 t.DIChannels.CreateChannel(device, "",
3 ChannelLineGrouping.OneChannelForAllLines);
Codelisting 7: Task starten und Modul initialisieren
Für das Programm wurde die Variante "OneChannelForAllLines" gewählt, da sich der Wert
(0 bzw. 1) der einzelnen Anschlüsse durch Umrechnung von Dezimalwert in Binärwert
bestimmen lässt. Eine nähere Erklärung wird im nächsten Kapitel gegeben.
2.5.2 Einmalige Signalerfassung

Löst der Timer das Auslesen des Signalwerts aus, wird der Task gestartet (siehe Codelisting
8, Zeile 1) und ein Datenstromleser für mehrere Kanäle erzeugt (siehe Kapitel 2.4. „Analoge
Signalerfassung“, Zeile 2)
In Zeile 3 wird ein Array mit Integer Werten erzeugt. Die Länge des Arrays entspricht der
Anzahl der Modulen, von denen ein digitales Signal erfasst wird.
t.Start();
DigitalMultiChannelReader reader = new DigitalMultiChannelReader(t.Stream);
s = reader.ReadSingleSamplePortUInt32();
t.Stop();
return s;
Codelisting 8: Auslesen von Digitalen Werten
Enthält die Variable (s) die Werte: s = { 3, 5 }, kann man folgende Schlüsse ziehen:
• Der erste Port hat den dezimalen Wert 3 -> Binär liegt 0011 an
• Der zweite Port hat den dezimalen Wert 5 -> Binär liegt 0101 an
2.6 Paralleles Auslesen mehrerer Signale

Um mehrere Signale gleichzeitig auslesen zu können, müssen mehrere Kanäle initialisiert
werden (siehe 2.4.1. "Initialisieren des Geräts"). Da der Initialisierungsmethode eine Liste von
Deviceadressen übergeben wird, muss mittels einer Schleife jedes Element bearbeitet werden
(siehe Codelisting 9).
foreach (string device in devices) {
t.DIChannels.CreateChannel(device, "",
ChannelLineGrouping.OneChannelForAllLines);
}
Codelisting 9: Auslesen mehrerer Module
Mit Hilfe eines MultiChannelReaders sind jetzt sämtliche Messwerte der zum Task
hinzugefügten Geräte verfügbar.
2.7 Erstellung einer Klasse

Um die Komponenten der Software unabhängig voneinander entwickeln und testen zu können
(siehe Kapitel 1.1.3.), wurde der Zugriff auf das Gerät in einer Klasse gekapselt.
Folgendes Beispiel in Codelisting 10 zeigt, wie die Klasse in einer Fremdklasse aufgerufen
werden kann.
niDAQdriver d = new niDAQdriver();
List<string> read = new List<string>();
Task myTask = d.initDevice(read, SamplingRate);
Codelisting 10: Initialiseren von Geräten mittels der Klasse niDriver.cs
Die Definition der Klasse wurde im Interface niDriver.cs festgelegt, wo die Eigenschaften der
Funktion dokumentiert sind. Zum Simulieren der Hardware, ohne das Gerät an den Computer
angeschlossen zu haben, wurde speziell die Klasse niDAQsim.cs entwickelt. Diese simuliert
der GUI, auf einen DAQmx zugreifen zu können. Die Klasse niDAQdriver.cs implementiert
die erforderlichen Funktionen, die für einen Zugriff auf ein angeschlossenes DAQmx
notwendig sind.
Grafical User Interface – Fatih Keskin Seite 25
3 Graphical User Interface

Um das Programm zu bedienen ist ein Graphical User Interface4 notwendig, mit welcher der
Benutzer mit der Software interagieren kann.
3.1 Struktur der Graphical User Interface

Die GUI soll Daten, welche von der Schnittstelle empfangenen werden, grafisch verarbeiten
und darstellen. Weitere Anforderungen stellen folgende Punkte dar: Farbe, Linienstärke,
Sichtbarkeit und Skalierung zu ändern. Des Weiteren soll auch die Möglichkeit bestehen,
Berechnungen mit den vorhandenen Signalen zu durchführen.
3.2 Grundlegendes Benutzeroberflächenschema

Im Folgenden werden die Bestandteile der GUI (siehe Abbildung 11) ausführlich erklärt.
Abbildung 11: Grundgerüst
3.2.1 Menü
Das Menü beinhaltet vier Untermenüs:
• Datei:
Beenden: Unter diesem Menüpunkt kann man das Programm schließen.
4
dt. grafische Benutzerschnittstelle, im folgenden GUI genannt
• Bearbeiten
Screenshot: Hier kann man auswählen, von welchem WaveFormPlot ein
Screenshot erstellt werden soll.
Signal/Berechnungen/FFT: Je nachdem welches Fenster ausgewählt wird, werden
die dargestellten Signale als Bild mit einem beliebigen Dateinamen gespeichert.
• Messung: Bei diesem Menüpunkt handelt es sich um das Reporting.

Analog/Digital
o Messung hinzufügen: Um ein Report generieren zu können, müssen Messwerte
vorhanden sein. Diese Messwerte werden über diesen Menüpunkt an die
Reportklasse weitergegeben. Die Messwerte die weitergegeben werden sollen,
hängen von dem ausgewählten Signal ab.
o Report löschen: Wenn man beim Hinzufügen von Messwerten falsche Messwerte
hinzugefügt hat, dann kann man den Report leeren, sodass man die Möglichkeit
hat einen neuen Report ohne der bisher erfassten Werte zu erstellen.
o Report erstellen: Wenn nun die Messwerte vollständig hinzugefügt sind, kann ein
Report generiert werden.
• Über/Info: Hier wird ein kleines Fenster eingeblendet, in dem eine Information über das
Programm steht.
3.2.2 Darstellungsfenster
Die Darstellungsfenster werden in drei Teile unterteilt.
Signalfenster
In diesem Fenster (auch als WaveFormGraph bezeichnet) werden die Messwerte grafisch
dargestellt.
Dieses Fenster kann bis zu vier Signale darstellen. Die dargestellten Signale können
unterschiedliche Eigenschaften haben, welche man über das selbst entwickelte
Steuerelement bedienen kann. Näheres folgt im Punkt Signaleigenschaften (siehe
Abschnitt 3.4).
Berechnungsfenster
Ein weiteres Feature von dem Programm ist, dass man mit den vorhandenen Messwerten
Berechnungen durchführen kann. Jedes zu einem Channel zugeordnete Signal kann auf
drei verschiedenen Arten berechnet werden.
• Addition: Die Messwerte fließen positiv in die Berechnung ein.

• Subtraktion: Für die Differenzbildung von Signalen ist es notwendig, Signale zu

subtrahieren. Bei dieser Methode fließen die Messwerte invertiert in die
Berechnung ein.
• Multiplikation: Die Signalformen werden miteinander multipliziert.

FFT Fenster
Hier wird das Frequenzspektrum des ausgewählten Signals aufgetragen. Die Daten
werden als Rückgabewert von der Methode getFFT() bekommen. Die Y-Achse geht
deswegen von 0 bis N/2, weil sich die Werte in der Mitte spiegeln. Die zweite Hälfte der
Daten bringt keine zusätzliche Information. Deswegen wird sie nicht dargestellt.
3.2.3 Einstellung für die Abtastrate:

Wie in Abschnitt 2.1.1 erläutert, muss die Abtastrate erhöht werden um die Messwerte
darstellen zu können, wenn das zu messende Signal hochfrequent ist.
3.2.4 History Capacity

Wenn man ein hochfrequentes Signal misst, dann möchte man statt mehrerer Perioden nur
eine Periode des Signals beobachten. Hier ist es nützlich, die Zeitachse zu skalieren. Die
History Capacity gibt an, wie viele Messwerte im Augenblick dargestellt werden. Es kann
auch umgekehrt der Fall sein, dass man z. B. mehrere Perioden von einem Signal anschauen
möchte.
3.3 Datenübernahme
Die Daten werden über einen Event an das Steuerelement über die Methoden PlotYAppend
oder PlotWaveformAppend übergeben. Falls vor der Übergabe die Daten invertiert werden
sollen, werden diese mit Hilfe der Methode getInv() invertiert. Mit der Methode PlotYAppend
können die invertierten Daten an das Signalfenster gesendet werden.
Die Methode sendDataToWfPlot übernimmt zwei Parameter. Der erste Parameter ist ein
AnalogWaveForm Array. In diesem Array sind die von dem Modul empfangenen Daten
gespeichert. Hierbei spielt die Reihenfolge der Daten eine große Rolle. Der zweite Parameter
ist eine Liste vom Typ WaveFormPlot. In dieser Liste sind die Plots, die mit einem Kanal
versehen sind, gespeichert.
Eine for Schleife dient zum Durchiterieren der Listen. Bei jedem Durchlauf wird kontrolliert,
ob die Signaleigenschaft Invertierung des Signals aktiviert wurde. Wenn dies der Fall ist,
werden die Daten invertiert und über die Methode PlotYAppend an das WaveFormGraph
Control übergeben.
Um eine Messung zu starten, muss nicht jedes Signal einem Channel zugeordnet sein. Man
kann z.B. Signal 1 und Signal 3 mit einem Channel versehen, dabei aber Signal 2 und Signal
4 unberührt lassen. Damit aber die Messwerte richtig zugeordnet werden können, gibt es eine
dritte Liste namens signalNumber. In dieser Liste stehen die Indizes der für die Messung
ausgewählten Signale.
Dies wird im Folgenden erklärt:
Code 11
private void sendDataToWfPlot(AnalogWaveform<double>[] data,
List<NationalInstruments.UI.WaveformPlot> plotList)
{
Signalinformation si;
for (int i = 0; i < data.Length; i++)
{
si = signalInfo[(int)signalNumber[i]];
if (si.inverted == true)
plotList[i].PlotYAppend(c.getInv(data[i].GetRawData()));
else
plotList[i].PlotWaveformAppend(data[i]);
}
}
Vor der if Anweisung wird die Variable si mit dem richtigen Signalinformations-Objekt
initialisiert. Danach wird kontrolliert, ob die Invertierung aktiviert wurde (Zeile 7, Code 11).
Wie auch oben beschrieben, werden dann die Messwerte entweder invertiert oder nicht an das
WaveFormGraph Control übergeben.
3.4 Signaleigenschaften
Damit man die Signale von einander unterscheiden kann, ist es von Vorteil, wenn die Signale
unterschiedliche Eigenschaften besitzen.
Abbildung 12: Konfigurationsdialog für Signaleigenschaften

Arten der Eigenschaften:
Farbe:
Um die Differenzierbarkeit der Signale zu verbessern, kann man die Farbe der einzelnen
Plots beliebig über das selbst erstellte Steuerelement ändern. Man kann entweder auf die
PictureBox oder auf den Button klicken. Es erscheint ein ColorDialog Fenster. Hier wählt
man die gewünschte Farbe aus und klickt anschließend auf OK.
Linienstärke:
Es ist ein Screenshot zu erstellen, wobei ein Signal besonders hervorgehoben werden soll.
Dies kann man durch Ändern der Linienstärke des Signals realisieren.
Linienart:
Ein weiteres Feature ist die Linienart. Es gibt insgesamt 5 Linienarten:
• Dash: Gibt eine Linie an, die aus Strichen besteht.
• DashDot: Gibt eine Linie an, die aus einer sich wiederholenden Strich-Punkt-Folge
besteht.
• DashDotDot: Gibt eine Linie an, die aus einer sich wiederholenden Strich-Punkt-
Punkt-Folge besteht.
• None: Die Linie ist unsichtbar.
• Solid: Gibt eine durchgehende Linie an.
Kanal:
Damit ein Signal überhaupt dargestellt werden kann, muss es einem Channel zugeordnet sein.
Deswegen muss man bevor man die Messung startet, ein Kanal auswählen, um Messwerte
darstellen zu können.
Sichtbar:
Nichtbenötigte Signale können über die Option Sichtbarkeit ausgeblendet werden.
Invertiert:
Wenn das Signal invertiert dargestellt werden soll, kann man dies mittels Selektieren einer
Checkbox realisieren.
Rolle des Signals im Berechnungsfenster

Man kann Berechnungen mit den vorhandenen Messwerten durchführen. Welche Rolle die
einzelnen Messwerte in der Berechnung haben, kann man über einen DropDownList
selektieren.
3.4.1 Struktur
Strukturen erlauben dem Entwickler eigene zusammengesetzte Typen zu definieren. [17]
Für das Programm wurde eine Struktur erstellt, in der die zusammenhängenden
Signaleigenschaften definiert sind. Hier wurde deswegen eine Struktur verwendet, da die
Daten gebündelt sind. Wegen dem Overhead, wurde hier statt einer Klasse eine Struktur
verwendet.
CODE 12
public struct Signalinformation
{
public int linewidth;
public String lineStyle;
public Color lineColor;
public string[] allChannels;
public string selectedChannel;
public bool dataChanged;
public bool unblocked;
public bool visible;
public bool inverted;
public int berechnung;
}
Diese Struktur hat die Rolle einer Brücke zwischen dem selbst erstellten Steuerelement und
der GUI Klasse herzustellen. In der Instanz vom Typ Signalinformation sind die
Eigenschaften eines Signals gespeichert.
3.5 Digitale Messung
Abbildung 13: Reiter für die digitale Messung
Bei der digitalen Messung sind die Werte als Integer-Werte verfügbar. In Abbildung 13 ist
ersichtlich, dass für die Messung wieder ein Channel erforderlich ist. Der digitale Wert
repräsentiert alle Eingänge vom selektierten Modul. Das heißt, dass egal welche Eingänge
belegt sind, man nur einen Integer Wert bekommt. Anders ist es bei der analogen Messung.
Dort muss man einzelne Eingänge selektieren.
Für die Abtastung der digitalen Werte wurde ein Timer eingebaut, der in auswählbaren
Abständen die Werte erfasst. Die Abtastzeit ändert man durch das NumericUpDown
Steuerelement neben dem Start Button.
Sobald die Abtastzeit und die Channels ausgewählt wurden, kann man die Messung starten.
Die Anzahl der Eingänge pro Modul ist typabhängig. Je nachdem wie viele Eingänge ein
solches Modul besitzt, wird die Länge des LedArrays (grüne Kreise) automatisch geändert.
Die Messwerte werden nach der Reihe in die zugehörige ListBox hinzugefügt. Diese
Messwerte können dann, wie bei der analogen Messung, über das Reporting-Menü
protokolliert werden.
3.6 Externe Steuerelemente

Der Vorteil der Benützung externer Steuerelemente liegt darin, dass die Methoden,
Strukturen, Enumerationen und Klassen vordefiniert sind. Die Messwerte sind als
AnalogWaveForm Objekt verfügbar. Ohne Änderungen durchführen zu müssen, werden diese
Messwerte einfach über die Methode PlotYAppend des WaveFormGraph Controls dargestellt.
Da die Steuerelemente von National Instruments zur Verfügung standen, konnte viel Zeit
eingespart werden.
3.6.1 Warum ein eigenes Steuerelement?

Das Erstellen von eigenen Steuerelementen kann viele Gründe haben. Im Folgenden werden
zwei genannt:
• Ein Grund dafür ist, dass man nicht alle Codeteile in einer Datei haben möchte. Es
sollte eine Unterteilung der Codeteile geben. Dies kann durch Erstellen eines eigenen
Steuerelements realisiert werden, da die Codeteile dann nicht mehr in einer Datei
zusammengefasst werden, sondern in verschiedenen.
• Ein anderer Grund für das Erstellen von eigenen Steuerelementen ist, dass vorhandene
Steuerelemente erweitert werden sollen und eventuell zusammengefasst werden.
3.7 Berechnungen
Die Berechnungen beziehen sich auf das selektierte Signal.
• FFT: Von dem berechneten Frequenzspektrum wird die Grundfrequenz berechnet und
ausgegeben. Zusätzlich wird das Frequenzspektrum im FFT Fenster dargestellt, das
wie die Werte von der Berechnungsfunktion kommt.
• Effektivwert: Der Effektivwert des ausgewählten Signals wird berechnet und zur
Ausgabe gebracht.
• Amplitude: Die Werte werden von der Berechungsklasse zurückgegeben und bei
Klick auf den Button dargestellt.
3.8 Screenshots erstellen

Es wäre sehr nützlich, selten erscheinende Signalergebnisse speichern zu können, um das
Ergebnis später jemand anderem zu zeigen. Für die Dokumentation der Messergebnisse
werden auch Bilder der dargestellten Signale benötigt. Über das Untermenü
Bearbeiten/Screenshot kann ein Screenshot von dem ausgewählten WaveFormGraph erstellt
werden.
Signalberechnungsfunktionen – Tobias Kazmierczak Seite 33
4 Signalberechnungsfunktionen
Neben dem Auslesen und Darstellen von Signalen ist es wichtig, diese auch richtig zu
interpretieren. Dabei helfen verschiedene Berechnungen, die die Aussagekraft von Messungen
erhöhen. Da das computergestützte Messsystem ähnliche Eigenschaften wie ein Oszilloskop
haben soll, werden auf Basis von Messwerten verschiedene Berechnungen durchgeführt. Um
Signale auszuwerten, wird in der Software diese Klasse verwendet, die beim Start des
Programms initialisiert wird.
4.1 Warum Signalanalyse und -manipulation?

Als Messergebnis stehen zunächst nur eine bestimmte Anzahl (n) von Abtastwerten pro
Sekunde zur Verfügung. Diese geben die Signalstärke in Volt in dem vom Modul
unterstützten Bereich (siehe Kapitel 2.3. „Auslesen von Geräteeigenschaften“) in einer
bestimmten Genauigkeit an. Amplitudenwerte alleine geben nur begrenzt und ungenau
Auskunft über Signaleigenschaften [18]. Die digitale Speicherung von Messdaten bietet eine
optimale Basis für die einfache Analyse, Berechnung und Manipulation von Werten.
4.2 Einfache Berechnungsfunktionen

Viele aufschlussreiche Eigenschaften eines Signals lassen sich durch Betrachten jedes
einzelnen Messwertes herausfinden. Um das umzusetzen, wird eine Schleife verwendet. Die
Methoden der Berechnungsklasse bekommen dafür den Messwert als einen double-Array
übergeben und liefern dann entweder wieder einen Array oder einen double-Wert zurück.
4.2.1 Invertierung des Signals

Eine leicht implementierbare Manipulation eines Signals ist die Invertierung. Dabei wird
jeder Wert mit -1 multipliziert.
public double[] getInv(double[] s) {
double[] sn = new Double[s.Length];
for (int i = 0; i < s.Length; i++)
sn[i] = s[i] * (double)-1;
return sn;
}
Codelisting X: Signal invertieren
4.2.2 Minimal- und Maximalwert eines Signals

Diese Messung gibt bei periodischen Signalen Auskunft über die Amplitude eines Signals.
Die Korrektheit der Ergebnisse hängt dabei von zwei Faktoren ab:
• Einhaltung des Abtasttheorems von Shannon: Wie in Kapitel 2.1.1 näher erläutert,
kann das abgetastete Signal trotzdem stark vom Originalsignal abweichen.
• Zusammenhang Abtastrate / Signalfrequenz: Selbst wenn die Abtastung nicht für eine
korrekte Wiederherstellung des Signals ausreicht, kann bei einer großen Anzahl von
Abtastwerten der Minimal-
Minimal und Maximalwert sehr genau gemessen werden.
Die folgende Grafik zeigt ein Signal, das mit etwas mehr als der doppelten Frequenz
abgetastet wird. Bei der Abtastung von nur einer Periode erhält
erhält man ein falsches Ergebnis.
Verwendet man jedoch mehrere Abtastwerte, bekommt man einen sehr genauen Wert. Im
gezeigten Beispiel hat das Originalsignal eine Frequenz von 1 Hz und wird mit 0,45 Hz
abgetastet. Nach fünf Abtastungen wird bereits der Maximalwert
Maximalwert genau erfasst, nach weiteren
10 Abtastungen wird der Minimalwert getroffen [19].
[19]
Abbildung 14:: Signalabtastung
Um die Methoden so einfach und aussagekräftig wie möglich zu halten, wurde di

diee Ermittlung
des Minimal-
Minimal und Maximalwerts separat von der Amplitudenmessung realisiert. Wiederum
mit der Hilfe einer for-Schleife
for Schleife (siehe Codelisting X)
X) wird jeder Abtastwert mit dem am
Anfang auf 0 gesetzten Minimal-
Minimal oder Maximalwert verglichen und wenn kleiner oder
oder größer,
wird die aktuelle Minimal-
Minimal- oder Maximalwert mit dem aktuellen Wert überschrieben. Nach
dem Durchlaufen aller Abtastwerte werden die beiden Werte zurückgegeben.
Bei der Implementierung in C# wurde dabei ein eigener Datentyp ((Struct)) [18] zur
Speicherung der Werte verwendet. Dieses ist wie folgt aufgebaut:
public struct mm {
public double min;
public double max;
}
Codelisting X: Struktur für die Speicherung von Double Werten

Der Vorteil gegenüber einem double Array ist, dass das Arbeiten mit den Rückgabewerten der
Methode erleichtert wird. Bei einem Aufruf mit mm value = getMinMax(samples) greift man
mit value.min und value.max auf die Werte zu.
4.2.3 Amplitudenmessung eines Signals

Basierend auf der Methode zur Ermittlung des Minimal- und Maximalwertes wird die
Amplitude des Signals berechnet. Die Formel für periodische Signale (zum Beispiel Sinus)
lautet (siehe Formel 3):
‫=ܣ‬
U୫ୟ୶ − U୫୧୬
2
Formel 3: Amplitudenmessung
Die Funktion implementiert genau diese Rechnung und gibt die Amplitude als double Wert
zurück.
4.2.4 Addition, Subtraktion und Multiplikation zweier Signale

Das Messsystem unterstützt das Auslesen mehrerer Signale. Soll das Zusammenspiel
mehrerer Signale z.B. durch Addierer berechnet werden, muss jeder Wert eines Signals mit
einem Wert eines anderen Signals verrechnet werden. Bei der Implementierung des
Addierers, Subtrahierers bzw. Multiplizierers wurde genau die gleiche Vorgehensweise wie
bei der Methode zur Invertierung benutzt. Statt mit -1 multipliziert wird jetzt aber der Wert
des zweiten Signals addiert, subtrahiert bzw. multipliziert.
4.2.5 Effektivwertberechnung
Der Effektivwert, der auch als „Root Mean Square Value“ bezeichnet wird, kann nicht nur
von periodischen Signalen bestimmt werden, sondern auch von zufälligen. Deswegen ist er
eine beliebte Messgröße. Man erhält ihn, wenn man die Wurzel des quadratischen Mittelwerts
berechnet. Wertet man ein Signal statistisch aus und erhält den Mittelwert µ = 0, entspricht
der Effektivwert der Standardabweichung. Voraussetzung dafür ist, dass das Signal keinen
Gleichanteil besitzt [19].
Bei Abtastsignalen quadriert man jeden Wert, bildet die Summe und teilt diese durch die
Anzahl der Abtastwerte. So erhält man annähernd den quadratischen Mittelwert eines Signals,
das der Leistung des Signals entspricht. Dabei ist zu beachten, dass eine hohe Abtastfrequenz
die Genauigkeit erhöht. Zieht man aus diesem Ergebnis die Wurzel, erhält man den
gewünschten Effektivwert des Signals.
ܷ௘௙௙ = ඩ ෍ uଶ୧
୒ିଵ
1
N
୧ୀ଴
Formel 4: Effektivwertmessung
Dabei entspricht N der Anzahl der Abtastwerte und ui ihrem Wert [20].
Bei der Implementierung in C# ist die Berechnung des Effektivwerts in zwei Methoden
aufgeteilt. Die Erste (getEffcurve()) quadriert jeden Abtastwert und gibt das Ergebnis als
double Array zurück. So kann das Ergebnis separat gezeichnet werden und zeigt einen
Zwischenschritt auf dem Weg zur Bildung des Effektivwerts. Die zweite Methode
(getEffvalue()) summiert die Rückgabewerte der ersten, teilt sie durch die Anzahl der Werte
und zieht die Wurzel.
4.3 Frequenzmessung
Die Frequenzbestimmung eines Signals stellt eine wichtige Anforderung an ein Messgerät
dar. Dabei gibt es bei der digitalen Messung im Wesentlichen zwei Methoden.
4.3.1 Messung auf Basis von Nulldurchgängen

Ein Nulldurchgang wird durch den Wechsel der Spannung vom negativen in den positiven
Bereich bzw. umgekehrt bestimmt. Für die Ermittlung der Frequenz kann man die Anzahl der
Nulldurchgänge innerhalb eines festgelegten Zeitintervalls, Torzeit genannt, heranziehen.
Dabei muss man die Periodendauer des Messsignals für eine genaue Messung deutlich kleiner
als die Torzeit wählen. Ist das nicht der Fall, kommt es zu Messfehlern. Um das zu
vermeiden, verwendet man im Fall von niedrigen Frequenzen die Periodendauermessung
anstatt der genannten Frequenzmessung. Dabei wird die Zeit gemessen, die zwischen zwei
Nulldurchgängen mit steigender Flanke vergeht. Wird die Dauer mit Hilfe von regelmäßigen
Zählimpulsen ermittelt, entsteht hier ein ähnliches Problem wie bei der Frequenzmessung,
denn die Messung wird erst genau, wenn pro Periode genügend Impulse gezählt werden
können [21].
Bei dieser Methode lässt sich allerdings nur die Grundfrequenz messen und nicht weitere
enthaltene Frequenzen, wie sie z.B. bei einem Rechteckssignal vorkommen. Das ist nur mit
Hilfe der Fouriertransformation möglich.
4.3.2 Messung durch Fouriertransformation

Alle vorkommenden Frequenzen eines Signals können bestimmt werden, wenn das Signal
vom Zeitbereich in den Frequenzbereich transformiert wird.
Periodische Funktionen lassen sich auf Basis der Fourierreihe in Sinus- und
Cosinusschwingungen unterschiedlicher Frequenz zerlegen.
c୬ = න fሺtሻeି୧୬ன୲ dt
ୡା୘
ܶ
1
Formel 5: Komplexe Fourierreihe [23]

Ausgehend von der komplexen Darstellung der Fourierreihe, überführt man die Reihe vom
diskreten zum kontinuierlichen Signal. So gelangt man zur kontinuierlichen
Fouriertransformation [22].
Diese lässt sich jedoch nicht auf zeitdiskrete Signale anwenden, da nur eine gewisse Anzahl
von Abtastwerten zur Verfügung steht. Die diskrete Fouriertransformation ist eine Näherung
an die kontinuierliche und wird wie folgt berechnet:
a୩ = ෍ w ୨୩ a୨
ேିଵ
௝ୀ଴
Formel 6: Diskrete Fouriertransformation [23]
Hierbei ist N die Anzahl der Abtastwerte. So lässt sich also aus einer endlichen Anzahl von
Abtastwerten eine näherungsweise Transformation in den Frequenzbereich durchführen [23].
Der schnelle Algorithmus zur Berechnung einer diskreten Fouriertransformation ist die Fast
Fouriertransformation (FFT). Die Funktionsbibliothek von NI bietet eine Methode realFFT()
an, die bei Übergabe von Abtastwerten eine FFT durchführt. Für die Frequenzmessung ist nur
der Betrag5 des Rückgabearrays von Bedeutung.
public double[] getFft(double[] s) {
NationalInstruments.ComplexDouble[] a =
NationalInstruments.Analysis.Dsp.Transforms.RealFft(s);
double[] mag = new double[a.Length/2];
for (int i = 0; i < mag.Length; i++)
mag[i] = a[i].Magnitude;
return mag;
}
Codelisting X: Ausgabe der Werte der Fouriertranformation
Bei der diskreten Fouriertransformation spiegelt sich die Größe der Beträge genau in der
Mitte. Dies bedeutet, dass beispielsweise bei 100 Werten die oberen 50 nicht relevant sind
[23]:
5
engl. magnitude
Abbildung 15:: Alle Werte der diskreten Fouriertransformat

Fouriertransformation
Deswegen wird in Zeile 4 (Codelisting

( listing 15)) nur die erste Hälfte der Werte berücksichtigt.
Stellt man das Ergebnis in einem Plot dar, kommt man zu folgendem Ergebnis:
Abbildung 16:: Die Hälfte der Werte der diskreten Fouriertransformation

Fouriertransformation
Die Skalierung der x-Achse

x Achse ist noch nicht auf die Frequenz transformiert. Im folgenden
Kapitel wird beschrieben, wie man in Abhängigkeit von der Abtastrate und der Anzahl der
Abtastwerte die Frequenz der Grundschwingung des Signals bestimmt.
4.3.3 Frequenzmessung durch FFT

Bei einer Abtastrate von 1000 Samples und 1000 Abtastwerten entspricht der Index des
Betragsmaximums genau der Frequenz, das heißt,
heißt, bei 5 Hertz liegt bei fünf das Maximum.
Sind diese zwei Zahlen jedoch nicht gleich, muss der Index des Maximums mit einem
Korrekturfaktor multipliziert werden, damit man die richtige Frequenz erhält.
Die Werte, die nach einer FFT der Funktion getFrequenzy() übergeben werden, enthalten halb
so viele Werte, wie für die Berechnung herangezogen wurden. Um das auszugleichen, muss
die Anzahl der Werte zunächst mit zwei multipliziert werden. Der Korrekturfaktor ergibt sich
aus der Abtastrate geteilt durch diese Zahl. Die Methode in Codelisting X setzt die
beschriebene Funktionalität um.
public double getFrequency(double[] fftdata, double rate) {
int max = 0;
double maxvalue = 0;
for (int i = 0; i < fftdata.Length; i++)
if (fftdata[i] > maxvalue) {
maxvalue = fftdata[i];
max = i;
}
return Convert.ToDouble(max) * (double)rate / (double)(fftdata.Length*2);
}
Codelisting X: Rückgabe der Frequenz
Umso größer der Korrekturfaktor, desto genauer kann der Frequenzwert bestimmt werden. Es
sollten möglichst viele Abtastwerte für die Frequenzbestimmung zur Verfügung stehen, damit
der Korrekturfaktor sich nicht negativ auf das Ergebnis auswirkt. Außerdem erhöht sich die
numerische Genauigkeit des Ergebnisses. Steht nur eine Periode zur Verfügung, beträgt der
maximale Fehler 0,5 Hz. Bei acht Perioden tritt rechnerisch maximal ein Fehler von 0,0625
Hz auf. Der maximale Fehler bei n Perioden wird in Formel 7 als ∆f angegeben [21].
1
∆݂ =
2௡
Formel 7: Maximaler Fehler bei der Frequenzberechnung
Reporting – Andreas Plötzeneder Seite 40
5 Reporting
Den Spezifikationen des Pflichtenhefts entsprechend soll der ReportGenerator einen Report
über mehrere Messungen erstellen. Dieser soll in mehreren Formaten ausgegeben werden
können.
5.1 Implementierung
Messwerte sollen nacheinander hinzugefügt werden können, das heißt, es soll eine Klasse
erstellt werden, in welcher diese Daten gespeichert werden. Hierzu kann man auf ein
interessantes Konzept der Softwarearchitektur zurückgreifen.
5.2 Singleton - Konzept

Bei einer derartigen Applikation kann ein wesentlicher Fehler sehr einfach auftreten:
Mehrfache Instanzen einer Klasse führen zu Speicherpersistenzproblemen.
Auch mehrere Klassen zur Speicherung der Daten sollen vermieden werden.
Um dies zu sichern, wird der sogenannte Singleton eingeführt, der von folgendem
Codebeispiel beschrieben wird:
CODE 17
static Generator instance=null;
public static Generator Instance
{
Get {
if (instance==null)
instance = new Generator();
return instance;
}
}
"Zweck des Singleton-Musters ist es, sicherzustellen, dass es nur eine Instanz einer Klasse
gibt und dass man einen globalen Zugriffspunkt auf dieses Objekt hat." [24]
Diese Sicherstellung erfolgt, indem die Generatorklasse mittels
CODE 18
Generator.Instance.Funktionsname()
aufgerufen wird. Existiert bereits eine Instanz, so wird diese zurückgegeben. Existiert noch
keine, so wird sie erstellt und dann zurückgegeben. Auf diese Weise kann man nun in der
Generator-Klasse Inhalte speichern, auf welche laufend zurückgegriffen werden kann.
5.3 Interne Datenspeicherung

Die Inhalte, also Messdaten, werden in einer ArrayList gespeichert.
Eine ArrayList kann alle Objektarten beinhalten. Man kann Zahlen hinzufügen, oder auch
Strings, sowie komplexe Datentypen wie DataSets oder DataTables. Alternativ kann man
natürlich auch eigens erstellte Strukturen einer solchen Liste hinzufügen.
CODE 18
ArrayList meineListe = new ArrayList();
meineListe.Add ("Mustertext"); // Hinzufügen eines Strings
meineListe.Add(12345); // Hinzufügen einer Zahl
Eine derartig erstellte Struktur wurde für jede Messung geschaffen. Sie ist folgendermaßen
aufgebaut:
CODE 19
struct Report
{
public string title;
public string description;
public string imagepath;
public int[] zeiten;
public int[] werte;
}
Die ArrayList mit den Messungen entspricht schlussendlich dem Report.
5.4 Hinzufügen einer neuen Messung

Soll eine neue Messung hinzugefügt werden, so ist die Methode add(...) aufzurufen. Sie ist
relativ einfach aufgebaut:
CODE 20
public void add(string imagepath,double[] zeiten,double[]werte)
{
AddReport x = new AddReport();
if(x.ShowDialog()==System.Windows.Forms.DialogResult.OK)
{
Report temp=new Report();
temp.title=x.title;
temp.description=x.text;
temp.imagepath=imagepath;
temp.zeiten=zeiten;
temp.werte=werte;
Reports.Add(temp);
}
}
Abbildung 17: Messung hinzufügen
Zuerst wird ein Fenster "AddReport" aufgerufen. Wird das Fenster mit OK geschlossen, so
wird eine neue Messung erstellt. Die Eingaben aus dem Formular fließen hierbei genauso ein,
wie auch die übergebenen Daten (Bilderpfad, Zeiten, Werte). Wie zu erkennen ist, werden
hierbei noch keinerlei Ausgabeformate spezifiziert. Die Ausgabe in verschiedenen Formaten
erfolgt erst später, aus diesem Grund werden die Inhalte formatfrei gespeichert. Dem
Benutzer stehen somit noch alle Wege offen.
5.5 Endgültige Speicherung

Um die Daten zu speichern, sind noch weitere Informationen des Benutzers nötig. So muss
man beispielsweise die Messreihe beschriften, beschreiben, den Speicherort festlegen und
auch das endgültige Format spezifizieren. Der Gerätename wird übergeben und in das
Messprotokoll eingebunden.
CODE 21
public void finish(string geraetename)
{
Finish x = new Finish();
System.Windows.Forms.MessageBox.Show(Reports.Count.ToString());
x.dataset = Reports;
x.txtdevice.Text = geraetename;
if (x.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
}
}
Abbildung 18: Entgültige Speicherung
5.6 Formate
Abhängig vom jeweiligen Anwendungsbereich eines Dokuments, gehört eine Datei einem
gewissen Dateityp an. Selbiger regelt das Format einer Datei. Er beschreibt somit eine interne
Struktur oder Codierung.
Manche Dateitypen beziehen sich hierbei jedoch nicht nur auf bestimmte Medientypen (Text
etc.), sondern auf bestimmte Anwendungssoftware.
So bezieht sich das Dateiformat pdf (Portable Document Format) primär auf den Acrobat
Reader, des Software Herstellers Adobe und seine Konkurrenzprodukte.
Oder eben auch html und htm, diese sind für bestimmte Zwecke gedacht (in diesem Fall
Webseiten), für diese existiert jedoch eine Vielzahl an populären Softwaretools, mit welchen
sie bearbeitet, gelesen und geschrieben werden können.
Die folgenden Formate wurden im Report-Generator implementiert:
5.6.1 HTML
Der Inhalt einer HTML Datei wird an dessen Enden mit <html> und </html> begrenzt. Darin
verschachtelt sind wiederum weitere Bereiche wie z.B. <body>...</body> und
<header>...</header>. In <header>...</header> sind in weiterer Folge Titel etc. gespeichert.
Weiter werden im Header auch sogenannte css (cascading style sheet) Dateien gespeichert,
welche das Design einer Website beschreibt, festgelegt. In <body>...</body> werden Inhalte
gespeichert, die der Benutzer dann betrachten kann. Mit <h1>...</h1>,<h2>...</h2>
Überschriften definiert werden.
Eine einfach aufgebaute HTML Datei mit einem cascading style sheet sieht wie folgt aus:
CODE 22
<html>
<header>
<title>Das ist der Titel</title>
<link rel="stylesheet" type="text/css" href="format.css"></header>
<body>
<h1>Hauptüberschrift</h1>
Das ist ein Text.<h2>Unterüberschrift</h2>
Das ist Text 2.
</body>
</html>
5.6.2 PDF
Beim PDF Format handelt es um ein 1993 von Adobe Systems veröffentlichtes Dateiformat,
mit dem Ziel, ein Format für elektronische Dokumente zu schaffen, welches unabhängig vom
ursprünglichen Betriebssystem oder der jeweiligen Hardwareplattform, wiedergegeben
werden kann. Das Format sollte hierbei für den Leser immer gleich bleiben und zwar so, wie
der Autor dies festgelegt hat. Typisch bekannte Probleme wie z.B. die von Microsoft Word
bekannten unterschiedlichen Seitenumbrüche sollten hierbei entfallen.
Unter C# lässt sich hierbei iTextSharp nutzen, einer Library zum PDF erstellen. iTextSharp
ist eine Portierung der iText Open-Source-Java-Bibliothek für die PDF Erzeugung.
Das Erstellen einer solchen PDF Datei ist relativ einfach. Nach Einbinden der DLL (über
sourceforge.com zu finden), kann man bereits in relativ wenigen Zeilen seinen eigenen Code
erstellen:
CODE 23
Document doc = new Document(PageSize.A4);
PdfWriter writer = PdfWriter.GetInstance(doc, File.Create(„Fachhochschule.pdf“));
doc.Open();
Chunk studiumspass= new Chunk(„Das Bachelorstudium hat Spass gemacht.“);
Chunk bachelorarbeit = new Chunk(„Krönender Abschluss war die Bachelorarbeit.“);
Phrase gesamtphrase= new Phrase(25);
gesamtphrase.Add(studiumspass);
gesamtphrase.Add(bachelorarbeit );
doc.Add(gesamtphrase);
doc.Close();
5.6.3 XML
XML (Extensible Markup Language ist eine Menge an Regeln, welche zur Codierung
elektronischer Dokumente dient. Diese wurde in der XML 1.0 Spezifikation definiert. XML
zeichnet sich durch die Einfachheit und Übersichtlichkeit seiner Datenstrukturen aus.
XML ist sehr einfach aufgebaut:
CODE 24
<? xml version = "1.0" encoding = "UTF-8"?>
<Fachhochschulen>
<Fachhochschule>
<name>FH Salzburg</name>
<standort>Puch Urstein</standort>
<englisch>University of Applied Sciences Salzburg</englisch>
</Fachhochschule>
<Fachhochschule>
<name>FH Wels</name>
<standort>Wels</standort>
<englisch>University of Applied Sciences Wels</englisch>
</Fachhochschule>
<Fachhochschule>
<name>FH Haagenberg</name>
<standort>Haagenberg</standort>
<englisch>University of Applied Sciences Haagenberg</englisch>
</Fachhochschule>
</ Fachhochschulen>
Primär wird XML zur Speicherung von Dokumenten und als Schnittstelle von Web-Services
genutzt. So ist die SOAP Schnittstelle eine im Internet weit verbreitete Schnittstelle. Aber
auch Microsoft Office und OpenOffice können in XML basierenden Formaten speichern.
Mittlerweile liefert nahezu jede Software XML Parser mit sich, weswegen es Sinn macht, ein
Speicherformat XML in das Oszilloskop zu integrieren. Weiter kann man mithilfe von XSLT
(XSL Transformations) XML Dokumente grafisch passend ausgeben. XSLT bietet die
Möglichkeit, Inhalte und Design zu trennen.
5.6.4 CSV
Eine CSV (Comma-Seperated-Values) dient zur Speicherung von Daten in einer Tabelle in
einer strukturierten Form.
Jede Zeile einer CSV Datei entspricht einer Zeile in der Tabelle. Innerhalb einer Linie sind
die Felder durch Kommas getrennt, jedes Feld einer Tabelle gehört einer Spalte an.
Das Format stammt ursprünglich aus den Anfängen der Computernutzung und ist beim
Datenaustausch zwischen verschiedenen Softwareprogrammen, wie z.B. Outlook und Lotus
Notes, sehr weit verbreitet.
CSV ist eine Implementierung einer Textdatei, die durch Komma getrennte Werte verwendet.
Eine CSV Datei ist beispielsweise so aufgebaut:
CODE 25
Zeile1Spalte1;Zeile1Spalte2;Zeile1Spalte3;
In dieses Format kann ebenfalls exportiert werden. Es eignet sich beispielsweise besonders
zum Weiterverarbeiten der Daten durch Mathematikprogramme wie z.B. MatLab, welche
eigene Funktionen zum Einlesen von CSV Dateien bereitstellt.
Zusammenfassung und Ausblick Seite 47
6 Zusammenfassung und Ausblick

Die vorliegende Bachelorarbeit behandelt eine computerbasierte Umsetzung eines
Oszilloskops. Die verwendeten Module von National Instruments dienten als Schnittstelle
zwischen Messsignal und Auswertung der Daten in einem Programm. Aufgrund der in .NET
implementierbaren Treiber wurde als Programmiersprache C# verwendet. Durch die
Softwareimplementation ist es dem Benutzer möglich Daten zu messen, analysieren und
dokumentieren. Weitere Anwendungsmöglichkeiten wären zum Beispiel ein Webserver, der
es Benutzern ermöglicht standortunabhängig Messdaten zu erfassen. Des Weiteren ist das
vorliegende Programm nicht National Instruments Module begrenzt, wodurch ist eine
Adaptierung auf Hardwaremodule anderer Hersteller möglich ist. Die Unterteilung der
Software in verschiedene Subkomponenten (siehe Kapitel 1.1.3) liefert hierbei einen
wichtigen Beitrag. Da National Instruments auch Treiber für Linux Distributionen anbietet
[25], wäre es denkbar, die Software auch für dieses Betriebssystem zu adaptieren. Da die
computergestützte Messdatenerfassung immer leistungsfähiger wird, werden derartige
Systeme in den nächsten Jahren an Bedeutung gewinnen. Es wäre denkbar, dass klassische
Oszilloskope langfristig ganz von computerbasierten Messsystemen verdrängt werden.
Anhang Seite 48
7 Literaturangaben
Literaturverzeichnis
[1] PinSonne-Elektronik. (kein Datum). LDS20405 40MHz Digital Speicher Oszilloskop mit
vielen Features. Abgerufen am 18. Januar 2010 von http://www.pinsonne-
elektronik.de/pi1/pd72.html
[2] Wolff, M. (1. Januar 2003). Software Engineering. Wuppertal.
[3] Kleuker, S. (2006). Grundkurs Datenbankentwicklung (1. Auflage Ausg.). Wiesbaden:
Friedr. Vieweg & Sohn Verlag.
[4] Steinweg, C. (2005). Management der Softwareentwicklung (6. Auflage Ausg.).
Wiesbaden: Friedr. Vieweg & Sohn Verlag.
[5] Collins-Sussman, B., Fitzpatrick, B. W., & Pilato, M. C. (2007). Versionskontrolle mit
Subversion (2. Auflage Ausg.). Köln: O´Reilly Verlag GmbH & Co. KG.
[6] Miller, M. (2006). Googlepedia. The Ultimate Google Resource (1. Auflage Ausg.).
Toronto, USA: Que Publishing.
[7] Küng, S. (2009. Juni 13). Tigris.org - Open Source Software Engineering Tools.
Abgerufen am 2010. Januar 18 von http://tortoisesvn.tigris.org/
[8] VisualSVN Limited. (2009). Abgerufen am 2010. Januar 18 von VisualSVN - Subversion-
based source control for Windows: http://www.visualsvn.com/
[9] Ramsauer, H. (2009). ZITATE - zeitenwende.ch. Abgerufen am 18. Januar 2010 von
http://zeitenwende.ch/zitate
[10] Microsoft. (9. Mai 2009). Sandcastle Help File Builder. Abgerufen am 18. Januar 2010
von http://www.codeplex.com/SHFB
[11] National Instruments. (06. Oktober 2009). Abgerufen am 12. November 2009 von NI
CompactDAQ - Data Sheet: http://sine.ni.com/ds/app/doc/p/id/ds-178/lang/en
[12] National Instruments. (kein Datum). Abgerufen am 29. November 2009 von Analog
Input: http://sine.ni.com/nips/cds/view/p/lang/en/nid/202551
[13] National Instruments. (kein Datum). Abgerufen am 30. November 2009 von NI 9423.
[14] National Instruments. (16. Januar 2009). Abgerufen am 2. Dezmber 2009 von
Einführung in die TDM-Streaming-.NET-Klassenbibliothek von Measurement Studio:
http://zone.ni.com/devzone/cda/tut/p/id/8166
[15] National Instruments. (02. Januar 2007). Abgerufen am 04. Dezember 2009 von NI-
DAQmx Hardware-Timed Single Point Lateness Checking:
http://zone.ni.com/devzone/cda/tut/p/id/3215
Anhang Seite 49
[16] National Instruments. (1. Januar 2008). Measurement Studio Help.

[17] Louis, D., & Strasser, S. (2008). Visual C# 2008. Unterschleißheim: Microsoft Press
Deutschland.
[18] Liberty, J. (2007). Programmieren mit C# (4. Auflage Ausg.). (J. Staudemeyer, & D.
Heymann-Reder, Übers.) Köln: O´REILLY.
[19] Profos, P., & Pfeifer, T. (Hrsg.). (1994). Handbuch der industriellen Messtechnik (6.
Auflage Ausg.). München: R. Oldenburg Verlag GmbH.
[20] Weißgerber, W. (2007). Elektrotechnik für Ingenieure 2 (6. Auflage Ausg.). Wiesbaden:
Vieweg & Sohn Verlag.
[21] Lerch, R. (2007). Elektrische Messtechnik (4. Auflage Ausg.). Berlin: Springer-Verlag.
[22] Butz, T. (2007). Fouriertranformation für Fußgänger (5. Auflage Ausg.). Wiesbaden:
B.G. Teuber Verlag.
[23] Kiencke, U., & Jäkel, H. (2008). Signale und Systeme (4. Auflage Ausg.). München:
Oldenbourg Wissenschaftsverlag GmbH.
[24] Bishop, J. (2008). C# 3.0 Entwurfsmuster. O'Reilly.
Anhang Seite 50
8 Anhang
8.1 Abbildungsverzeichnis
Abbildung 1: Hardware Oszilloskop ......................................................................................... 6
Abbildung 2: Vorgehensmodell ................................................................................................. 7
Abbildung 3: Visual Studio 2008 ...................................... Fehler! Textmarke nicht definiert.
Abbildung 4: Kommunikationsmodelle ..................................................................................... 9
Abbildung 5: Verwendetes Kommunikationsmodell ............................................................... 10
Abbildung 6: TortoiseSVN................................................ Fehler! Textmarke nicht definiert.
Abbildung 7: Teamviewer Applikation .................................................................................... 12
Abbildung 8: Teamviewer - entfernter Desktop ....................................................................... 12
Abbildung 9: Testablauf ........................................................................................................... 13
Abbildung 10: Sinusabtastung .................................................................................................. 16
Abbildung 11: TDM Datenmodell ........................................................................................... 17
Abbildung 12: Grundgerüst ...................................................................................................... 25
Abbildung 13: Signaleigenschaften .......................................................................................... 28
Abbildung 14: Reiter für die digitale Messung ........................................................................ 31
Abbildung 15: Signalabtastung ................................................................................................ 34
Abbildung 16: Alle Werte der diskreten Fouriertransformation .............................................. 38
Abbildung 17: Die Hälfte der Werte der diskreten Fouriertransformation .............................. 38
Abbildung 18: Messung hinzufügen ........................................................................................ 42
Abbildung 19: Entgültige Speicherung .................................................................................... 43
8.2 Quellcode
Siehe DAQReader.zip

Computergestütztes Messsystem Datenerfassung Unter Verwendung Von NI-USB-Modulen Und Bereitstellung Einer Grafischen Oberfläche Mittels C#

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Computergestütztes Messsystem Datenerfassung Unter Verwendung Von NI-USB-Modulen Und Bereitstellung Einer Grafischen Oberfläche Mittels C#

Hochgeladen von

Copyright:

Verfügbare Formate

BACHELORARBEIT

Studiengangsleiter: FH-Prof. DI.Dr. Gerhard Jöchtl

Salzburg, Januar 2010

Ort, Datum Name und Unterschrift der/s Studierenden

Abbildung 1: Hardware Oszilloskop [1]

Abbildung 2: Vorgehensmodell eines Softwareentwicklungsprozesses1

Betrachtet man einen Softwareentwicklungsprozess sehr abstrakt, so kann dieser in mehrere

1.1.1 Phase 0: Initialisierung

1.1.2 Phase 1: Problemanalyse

1.1.3 Phase 2: Entwurf

Datenerfassung Berechnung Reporting

4. Die Berechnung liefert Daten an die GUI zurück

Abbildung 4:: Verwendetes Kommunikationsmodell

1.1.4 Phase 3: Implementierung

Codeverwaltung mittels Subversion

Hardware mittels TeamViewer

Abbildung 5: TeamViewer Applikation

Abbildung 6: TeamViewer - entfernter Desktop

1.1.5 Phase 4: System- und Abnahmetests

Unittest Integration in GUI Datenerfassung

1.1.6 Phase 5: Nutzung, Wartung, Betrieb, Schulung

1.2.2 Erstellung von Help-Files

2.1 Leistungen und Eigenschaften des DAQmx

Wobei ∆U den Spannungsreich festlegt und n die Anzahl der Bit.

2.2 Die Programmierschnittstelle von National Instruments

Abbildung 9: TDM Datenmodell [14]

2.3 Auslesen von Geräteeigenschaften

Codelisting 1: Modulinformationen ausgeben

2.4 Auslesen von analogen Signalen

• ModeFiniteSamples: Einmaliges Auslesen einer festgelegten Anzahl von Werten.

• ModeContinuousSamples: Ständiges Auslesen von Messwerten in einen Puffer bis der

• ModeHardwareTimedSinglePoint: Ständiges Auslesen von Messwerten ohne Puffer

2.4.1 Initialisieren des Geräts

Codelisting 2: Analogen Input initialisieren

Codelisting 3: Sample Clock initialisieren

Codelisting 4: Überprüfen des Tasks

2.4.2 Kontinuierliche Signalerfassung

Callback wird ausgelöst: Daten werden verarbeitet

Abbildung 10: Asynchrones Auslesen von Daten

Codelisting 5: Vorbereitung zur Datenerfassung

Codelisting 6: Callbackgesteuerte Datenerfassung

2000 1000 2000 2 1 2

2000 1000 10000 10 5 2

10000 1000 1000 1 0,1 10

10000 1000 10000 10 1 10

Tabelle 1: Zusammenhänge zwischen Parametern und Anzeigeergebnissen

2.5 Auslesen von digitalen Signalen

2.5.1 Initialisieren des Geräts

• OneChannelForEachLine: Dabei lässt sich jeder digitale Anschluss separat auslesen.

• OneChannelForAllLines: Alle digitalen Anschlüsse eines Modules werden als ein

Codelisting 7: Task starten und Modul initialisieren

2.5.2 Einmalige Signalerfassung

Codelisting 8: Auslesen von Digitalen Werten

2.6 Paralleles Auslesen mehrerer Signale

Codelisting 9: Auslesen mehrerer Module

2.7 Erstellung einer Klasse

Codelisting 10: Initialiseren von Geräten mittels der Klasse niDriver.cs

3 Graphical User Interface

3.1 Struktur der Graphical User Interface

3.2 Grundlegendes Benutzeroberflächenschema

Abbildung 11: Grundgerüst

• Messung: Bei diesem Menüpunkt handelt es sich um das Reporting.

• Addition: Die Messwerte fließen positiv in die Berechnung ein.