ESD Eingangskontrollsystem

Transcription

ESD Eingangskontrollsystem
Diplomarbeit 2009
Serhat Keskin
Peter Schobesberger
Alexander Schuster
ESD-Eingangskontrollsystem
KURZBESCHREIBUNG
Es
wurde
ein
drehkreuzgesicherter
Eingang
mit
Überwachungseinrichtung
entwickelt. Der Eingang ist ausgerüstet mit einem Drehkreuz, einem ESD-Prüfgerät,
einem iButton-Leser, zwei Lichtschranken und einer Kamera. Der Eingang ist so
aufgebaut, dass sich jeder, der in den Produktionsbereich möchte, identifizieren und
eine Überprüfung ablegen muss. Sollte ein Eingang ohne Überprüfung betreten
werden, lösen die Lichtschranken aus und die Kamera schießt ein Foto. Dieses Foto
kann beliebig gespeichert werden. Bei ungültigen Zutrittsversuchen wird der Zugang
durch das Drehkreuz verhindert und in der Datenbank der misslungene
Zutrittsversuch vermerkt. In der von uns entwickelten Software ist es möglich,
Eingänge
anzulegen
und
diese
zu
verwalten.
Außerdem
kann
man
die
mitprotokollierten Daten einsehen und ausdrucken.
ABSTRACT
We have developed a turnstile-safeguarded entry with monitoring equipment. The
entry is equipped with a turnstile, an ESD test device, an iButton reader, two light
barriers and a camera. Everyone who wants to get into the production area has to
pass this entry including both identification and inspection. An entering without
inspection should be avoided because then the light barriers activate the camera
which takes a photo. This photo can be stored. In the case of invalid admission
attempts access will be denied by the turnstile and in addition there will be an entry in
the database. With the software, we developed, entries can be added, and settings
can be changed. In addition the stored data can be watched and printed by an
administrator.
2
Keskin, Schobesberger, Schuster
EIGENSTÄNDIGKEITSERKLÄRUNG
Wir erklären hiermit, dass wir die vorliegende Diplomarbeit selbstständig verfasst und
in der Bearbeitung und Abfassung keine anderen als die angegebenen Quellen oder
Hilfsmittel benutzt, sowie wörtliche und sinngemäße Zitate als solche gekennzeichnet
haben.
Vöcklabruck, am 13. Mai 2009
Peter Schobesberger
Serhat Keskin
Alexander Schuster
3
INHALTSVERZEICHNIS
1 Entstehung und Planung ......................................................................................... 7
1.1 Vorwort.............................................................................................................. 7
1.2 Die Problemstellung .......................................................................................... 7
1.2.1 ESD ............................................................................................................ 7
1.2.2 Maßnahmen für ESD-Schutz ...................................................................... 8
1.3 Die Aufgabenstellung ...................................................................................... 12
2 Projektteam ........................................................................................................... 13
2.1 Diplomanden ................................................................................................... 13
2.2 Betreuer .......................................................................................................... 13
2.3 Lehrinstitut ...................................................................................................... 14
2.4 Auftraggeber ................................................................................................... 14
2.5 Projektplanung ................................................................................................ 15
2.5.1 Projektbeginn ........................................................................................... 15
2.5.2 Sollablauf .................................................................................................. 15
2.5.3 Geplanter Ablauf....................................................................................... 17
2.5.4 Istablauf .................................................................................................... 18
2.5.5 Stundenaufteilung..................................................................................... 19
3 Umsetzung ............................................................................................................ 20
3.1 Informationen einholen.................................................................................... 20
3.2 Zeiterfassungsterminal TRS15 ........................................................................ 21
3.3 Personenerdungsprüfgerät ............................................................................. 21
3.3.1 PGT100 .................................................................................................... 21
3.4 Theoretische Lösung....................................................................................... 26
3.5 Identifizieren der Mitarbeiter ............................................................................ 27
3.6 TCP- Server .................................................................................................... 29
3.6.1 TCP- Protokoll .......................................................................................... 29
3.6.2 Protokollbeschreibung .............................................................................. 29
3.7 Digitaler I/O Controller PL ............................................................................... 37
3.8 TCP-Client ...................................................................................................... 42
3.9 Fehlerprotokoll ................................................................................................ 46
4
3.10 Ablaufsteuerung ............................................................................................ 49
3.10.1 Ablaufbeschreibung ................................................................................ 50
3.10.2 Programmablaufplan .............................................................................. 51
3.11 Die Datenbank .............................................................................................. 54
3.11.1 Die Klasse MSAccess ............................................................................ 55
3.11.2 Klasse AccessData................................................................................. 59
3.12 Dateiverwaltung ............................................................................................ 66
3.13 Die Benutzeroberfläche................................................................................. 70
3.13.1 Startbildschirm ........................................................................................ 70
3.13.2 Einstellungen mit Eigenschaften............................................................. 71
3.13.3 Pfad aussuchen per OpenFileDialog ...................................................... 73
3.13.4 Menü mit MenuStrip ............................................................................... 75
3.13.5 Das Protokoll .......................................................................................... 76
3.14 Konstruktive Tätigkeiten ................................................................................ 77
3.14.1 Lichtschrankenhalterung ........................................................................ 78
3.14.2 Gerätebox ............................................................................................... 79
3.14.3 Gerätehalterung...................................................................................... 79
3.15 Schwenktür ................................................................................................... 81
4 Gesamtaufbau ....................................................................................................... 82
4.1 Gesamtschaltung ............................................................................................ 83
4.2 Schaltung Relais-DKZ ..................................................................................... 85
4.3 Schaltung Relais-Allgemein ............................................................................ 86
4.4 Stückliste für alle 4 Relais ............................................................................... 86
4.5 Spannungsteiler (DC/DC-Wandler) ................................................................. 87
4.6 Bilder zum Aufbau ........................................................................................... 88
5 Installationsanleitung ............................................................................................. 90
5.1 Ersten Eingang anlegen .................................................................................. 90
5.2 Tür anlegen im RW Pro-Access von Salto ...................................................... 90
5.3 I/O Controller konfigurieren ............................................................................. 91
5.4 Einstellungen im Programm ............................................................................ 93
6 Validierung............................................................................................................. 94
6.1 Idealablauf ...................................................................................................... 94
6.2 Ungültige ESD-Prüfung ................................................................................... 94
5
6.3 Zeitüberschreitung .......................................................................................... 95
6.4 Alarmauslösung .............................................................................................. 95
7 Persönliche Erfahrungen und Wertschöpfung ....................................................... 96
8 Besprechungsprotokolle ........................................................................................ 97
8.1 Erste Besprechung.......................................................................................... 97
8.2 Zweite Besprechung ....................................................................................... 98
9 Geräteverzeichnis .................................................................................................. 99
9.1 I/O Controller ................................................................................................... 99
9.2 PGT100 ESD-Prüfgerät .................................................................................. 99
9.3 SkiData Drehkreuz DKZ 350 ........................................................................... 99
9.4 IDEC Reflexlichtschranke ............................................................................. 100
9.5 Identifikationshardware Salto ........................................................................ 100
9.6 Netzwerkkamera Plustek IPcam P1000 ........................................................ 100
10 Softwareverzeichnis .......................................................................................... 101
10.1 Microsoft Visual Studio................................................................................ 101
10.2 Microsoft Office Access 2007 ...................................................................... 101
10.3 Microsoft Office Word 2007......................................................................... 101
10.4 Salto RW Pro-Access Connected ............................................................... 102
10.5 Hercules by HW-Group ............................................................................... 102
10.6 SFC-Editor .................................................................................................. 102
11 Anhänge ............................................................................................................ 103
11.1 Dokumentations-CD .................................................................................... 103
11.2 Klassendiagramm ....................................................................................... 104
12 Abbildungsverzeichnis ....................................................................................... 106
6
1 Entstehung und Planung
1.1 Vorwort
Am Ende des Jahres 2007 wandte sich die Firma AlliedPanels an die HTL
Vöcklabruck und bot eine Zusammenarbeit an, um ein ESD Eingangskontrollsystem
im Sinne einer Diplomarbeit zu entwickeln. Diese Zusammenarbeit wurde
angenommen
und
anschließend
als
Diplomarbeitsthema
vergeben.
Die
Informationen wurden durch unseren Betreuer an uns weitergeleitet und wir
begannen
das
Thema genauer
zu
betrachten.
Nach
einigen
Absprachen
beschlossen wir, dieses Thema als Diplomarbeit anzunehmen.
1.2 Die Problemstellung
Die Firma AlliedPanels stellt Geräte und Komponenten für den medizinischen
Gebrauch her. Die dabei verbauten elektronischen Bauteile reagieren sehr
empfindlich auf elektrostatische Entladungen. Tritt ein solcher Fall ein können sie
sofort zerstört werden oder noch schlimmer, es kann ein späterer Ausfall des Geräts
beim Kunden eintreten. Damit ist mit erhöhten Kosten für den Hersteller zu rechnen.
Um den größten Teil dieser Kosten zu vermeiden, wird ein Zugangskontrollsystem
entwickelt und optimiert. Durch die Zugangskontrolle sollen die von Menschen
verursachten Produktausfälle durch elektrostatische Entladung vermindert werden.
1.2.1 ESD
ESD steht für „electrostatic discharge“ (elektrostatische Entladung), elektrostatische
Entladung ist eine durch Potentialdifferenz von zwei Körpern hervorgerufene
statische
Entladung.
Meist
entsteht
dieser
Potentialunterschied
durch
Reibungselektrizität. Eine Entladung in einem Halbleiter ist mit einem Blitzschlag in
einen Baum vergleichbar. ESD kann zu schweren Bauteilschäden führen, die den
Bauteil entweder zerstören oder seine Zuverlässigkeit beeinträchtigen können.
7
1.2.2 Maßnahmen für ESD-Schutz
Abbildung 1 ESD-Symbol
1
Ein derartiger Potentialunterschied muss ausgeglichen oder vermieden werden. Dies
wird durch unterschiedliche Schutzmaßnahmen erreicht.
1.2.2.1
ESD-Schutzbereiche (EPA)
Die Electrostatic Protected Area (EPA) ist ein Bereich, in welchem elektrostatische
Entladungen mit Spannungen von über 100V durch antistatische Ausrüstung
verhindert werden.
Abbildung 2 EPA-Symbol
1.2.2.2
2
Persönliche ESD-Schutzausrüstungen
Zu den persönlichen Schutzausrüstungen gehören ableitfähige Schuhe, HandgelenkErdungsbänder,
ableitfähige
Handschuhe
und
ableitfähige
Arbeitskleidung
(Arbeitsmäntel, Overalls oder Pullover). Ableitende Kleidung ist nur dann effektiv,
wenn sie kombiniert mit ableitfähigen Schuhen getragen wird. ESD-Schuhe leiten
beim Gehen eine bestimmte Spannung ab und sind der effektivste Schutz gegen
elektrostatische Entladung am Menschen.
1
2
http://www.kolzen-berufsbekleidung.de/images/esd_1.gif
http://www.asmetec.de/images/ESD-EPA2.jpg
8
1.2.2.3
ESD-geschützte Arbeitsplätze
Arbeitstische müssen mit einem ableitenden Boden verbunden sein und auf der
Arbeitsplatte
muss
ein
Anschluss
für
Erdungsarmbänder
vorhanden
sein.
Werkzeuge, Hilfsmittel, Behälter und Geräte müssen den ESD-Schutzbestimmungen
entsprechen.
1.2.2.4
Sitzgelegenheiten
Sitzflächen, Sitzflächenüberzüge, Rückenlehnen, Armlehnen sowie alle Stuhlfüße
oder –rollen müssen aus elektrostatisch ableitfähigem Material bestehen. Die
Ableitfähigkeit muss gewährleistet sein, da beim Sitzen der Kontakt der Füße mit
dem Boden nicht immer gegeben ist.
In den folgenden Bildern kann man den Unterschied zwischen einem normalen
Drehstuhl und einem ESD-Drehstuhl sehen.
9
Abbildung 3 ESD-Drehstuhl
1.2.2.5
3
ESD-geschützte Maschinen und Einrichtungen
Bei den verschieden Maschinenkomponenten, wie zum Beispiel bei Laufrollen,
Robotergreifer, Rutschen, Führungsschienen und so weiter, kann es durch Reibung
zur elektrostatischen Entladung kommen. Deshalb müssen auch dort ESDSchutzmaßnahmen getroffen werden. Durch Einsetzen von bestimmten leitenden
Materialien oder durch andere Vorkehrungen.
3
ESDSchulung.pdf
10
1.2.2.6
Weitere Schutzmaßnahmen sind:
•
ESD-geschützte Verpackungen
•
ESD-geschützte Transporteinrichtungen
•
Optimierte Klimabedingungen (klimatisierte Räume mit Luftfeuchtigkeit > 40%)
•
und bestimmte Regeln und Verhaltensmaßnahmen im Umgang mit ESD
1.2.2.7
Übersicht eines ESD-Arbeitsplatzes
Abbildung 4 ESD-Arbeitsplatz
4
4
Esd_Buch.pdf
11
1.3 Die Aufgabenstellung
•
Es sollen zwei Eingänge mit Drehkreuz und Zugangskontrolle geplant werden.
Die Möglichkeit, weitere hinzuzufügen, soll gegeben sein.
•
Die Eingänge müssen behindertengerecht (z.B.: Rollstuhlfahrer) sein und als
Fluchtweg genutzt werden können.
•
Die Überwachung der Eingänge soll mittels Kamera erfolgen. Bei unbefugtem
Übertreten soll ein Bild gespeichert werden und ein Alarm (z.B.: in Form einer
Signallampe) ausgelöst werden. Der Reset des Alarms sollte an einer
zentralen Stelle erfolgen können.
•
Es muss eine Datenbank mit einer entsprechenden Oberfläche zur Verfügung
stehen, um die fehlerhaften Messergebnisse der Mitarbeiter und die Uhrzeit
aufzulisten.
•
Bei der Validierung müssen sämtliche Fehlbedienungen berücksichtigt
werden.
12
2 Projektteam
2.1 Diplomanden
Serhat Keskin
Klasse: 5BHWII
Geburtsdatum: 13. Juli 1989
Wohnort: Frankenmarkt
Peter Schobesberger
Klasse: 5BHWII
Geburtsdatum: 08. August 1989
Wohnort: Neukirchen/V.
Alexander Schuster
Klasse: 5BHWII
Geburtsdatum: 06. August 1988
Wohnort: Aurach
2.2 Betreuer
Prof. DI Michael Opelt
13
2.3 Lehrinstitut
Höhere Technische Bundeslehranstalt
(HTBLA) Vöcklabruck
Bahnhofstraße 42
A-4840 Vöcklabruck
Tel: +43 (0) 7672 24605
Fax: +43 (0) 7672 27805
E-Mail: [email protected]
Internet: http://www.htlvb.at
2.4 Auftraggeber
AlliedPanels Entwicklungs- und
Produktions GmbH
AlliedPanels Park 1
A-4873 Frankenburg, Austria
Tel: +43 (0) 7683 20111
Fax: +43 (0) 7683 20031
E-Mail: [email protected]
Internet: http://www.alliedpanels.com
AlliedPanels ist ein internationales Entwicklungs- und Produktionsunternehmen in
der Medizintechnik. Die Einsatzgebiete der Firma reichen von der Entwicklung
einzelner
Systemkomponenten
bis
hin
zur
Produktion
medizintechnischer
Komplettsysteme. Das Unternehmen wurde im Jahr 2000 in Wörgl in Tirol gegründet.
AlliedPanels entwickelt und gestaltet medizintechnische Geräte und bietet ein
umfassendes Wissen und modernste Technik in den Bereichen Elektronik, Mechanik
und Software. Das Unternehmen hat drei Standorte in Österreich und zwei
Niederlassungen im Ausland. Die Zentrale befindet sich in Hopfgarten im Brixental
(Tirol)
und
das
Produktionszentrum
ist
in
Frankenburg
(Oberösterreich)
niedergelassen. Das Entwicklungs- und Technologiezentrum befindet sich in
Salzburg und weitere Standorte sind Wisconsin (USA) und Minsk (Weißrussland).
14
2.5 Projektplanung
2.5.1 Projektbeginn
Unsere Diplomarbeit startete mit dem Treffen bei AlliedPanels am 10. Jänner 2008.
Bei dem Gespräch wurde uns näher gebracht, wie die Eingänge ausgestattet sein
sollen und was genau passieren soll. Es sollten zwei Eingänge mit Drehkreuzen
versehen werden. Jeder Benutzer soll sich beim Betreten eines Eingangs an einem
Terminal identifizieren und dann eine ESD-Prüfung ablegen. Das Drehkreuz darf
natürlich erst öffnen, wenn beide Überprüfungen erfolgreich abgelegt wurden. Um
den Zugang gegen unbefugten Übertritt zu schützen, soll eine Überwachungsanlage
mit zwei Lichtschranken und einer Kamera, die Bilder bei Übertreten ohne
Überprüfung macht, installiert werden. Nach dieser Besprechung und einer
anschließenden Besprechung mit Prof. Opelt sind wir davon ausgegangen, dass wir
mit einer SAP-Datenbank arbeiten müssen und in diese Datenbank auch die
mitdokumentierten Daten speichern sollen. Bei unserem 2. Treffen hat sich dann
jedoch herausgestellt, dass das Zutrittskontrollsystem unabhängig von der SAPDatenbank arbeitet, und die Daten der Eingänge in einer separaten Datenbank
gespeichert werden. Mit diesem Wissen begannen wir dann mit der Projektplanung.
2.5.2 Sollablauf
Meilensteine
Beschreibung
Bemerkungen
Projektbeginn
Erste Besprechung bei
10. Jänner 2008
AlliedPanels
Pflichtenheft
Pflichtenheft erstellt,
21. Mai 2008
Besprechung mit Herr DI
Opelt bei AlliedPanels
Inbetriebnahme der
Inbetriebnahmen vom
Testgeräte
ESD-Prüfgerät und vom
ab 01.Juni 2008
SaltoZutrittskontrollsystem
Theoretische Lösung
Erstellung eines
30. Juni 2008
Lösungsvorschlages für
15
das Zutrittskontrollsystem
Praktikumsantritt
Aufbauen eines
30. Juni 2008 bis 25.Juli
Teststandes
2008
Endgültige Auflage des
Besprechung mit Herrn
25. Juli 2008
Pflichtenhefts
Plakholm
Vorvorpräsentation
Präsentation des Projekts
23.September 2008
im ESR-Unterricht
Testsystem aufbauen
Erster Probelauf in der
Oktober 2008
Firma
Vorpräsentation
Vorpräsentation in der
16.Dezember 2008
HTL
Internetauftritt
Präsentation auf der
Dezember.2008
Internetplattform www.htlinnovativ.at
Abgabe Dokumentation
Abgabe der
April 2009
Dokumentation an DI
Opelt
Abschluss der
April/Mai 2009
Diplomarbeit
Abgabe an Herrn DI
Ende der Projektarbeit
Waser
16
2.5.3 Geplanter Ablauf
Planung
Installation
Anpassung
Anforderungen
Aufbauen des
Nötige
bestimmen
Teststandes
Änderungen
Absprache mit
Begleitende
Auftraggeber
Dokumentation
Fertigstellung
Präsentation
Validierung
Lösungsweg
ausarbeiten
Plichtenheft
erstellen
Abbildung 5 Geplanter Ablauf
17
2.5.4 Istablauf
Abbildung 6 Screenshot Gantdiagramm des Istablaufs (MSProject)
18
2.5.5 Stundenaufteilung
Insgesamt haben wir 837 Stunden für die Diplomarbeit benötigt.
Zeitaufstellung
13%
18%
Organisatorisches
Programmieren
35%
35%
Aufbau
Dokumentation
Abbildung 7 Zeitaufstellung der Arbeitsstunden
19
3 Umsetzung
3.1 Informationen einholen
Zu Beginn eines Projektes ist es wichtig, so viele Informationen wie möglich
einzuholen, da Informationsbeschaffung ein wichtiger Punkt im Ablauf eines
Projektes ist. Natürlich mussten wir uns zuerst über die verwendete Hardware und
Software informieren, die in der Firma bereits verwendet wird. Am Anfang holten wir
uns Informationen zu dem ESD-Prüfungsgerät und zum Drehkreuz (technische
Anleitung, Schaltpläne). Da wir dachten, wir müssen mit dem Zeiterfassungsterminal
und mit SAP arbeiten, begannen wir nach Möglichkeiten zu suchen, über dieses
System die benötigten Userdaten zu bekommen. Weiters mussten wir auch den Ort
des Einganges bestimmen, um zu wissen, welche Möglichkeiten wir zur Verbindung
mit dem restlichen System haben. Anhand dieser Informationen und eines
Anschlussplanes mussten wir ein geeignetes Bussystem auswählen, aber den
Eingang auch behindertengerecht und mit Fluchtmöglichkeit planen. Auch in der
Hauptphase des Projektes war die Informationsbeschaffung von größter Bedeutung,
da wir einige Geräte kaufen mussten. Beim Einkauf der benötigten Geräte und
Komponenten (Netzwerkkamera, I/O Controller) war für uns in erster Linie der
technische Support wichtig. Von großer Bedeutung war auch die Zusammenarbeit
mit den Betreuungspersonen, um Lösungen auszuarbeiten.
20
3.2 Zeiterfassungsterminal TRS15
Gleich zu Beginn haben wir Informationen zu einem Zeiterfassungsgerät bekommen.
Natürlich haben wir diese Daten gleich ausgearbeitet, um mögliche Lösungen zu
finden.
Abbildung 8 TRS15-Zeiterfassungsterminal
5
Das TRS15 ist ein Zeiterfassungsterminal, mit dem sich die Mitarbeiter anmelden
können. Bei einer Besprechung mit der Firma erfuhren wir, dass dieses Gerät nicht
verwendet werden soll, da dieses Terminal auf die SAP Datenbank zugreift.
Stattdessen sollten wir die Identifizierung durch die Eintrittsbuttons der Firma Salto
realisieren. Jeder Mitarbeiter hat zwei Schlüssel, einen zum Stempeln und einen
zweiten zum Eintreten in gewisse Bereiche (Eingang, Büros). Um dies zu realisieren
wurde die Salto-Hardware benötigt, diese wurde uns von der Firma besorgt und
vorgegeben.
3.3 Personenerdungsprüfgerät
3.3.1 PGT100
Die ersten brauchbaren Informationen bekamen wir zum PGT100 Anfang Juni.
Dieses ESD-Prüfgerät schließt einen potentialfreien Kontakt, wenn eine Prüfung
abgeschlossen wurde.
5
trs_15.pdf
21
Abbildung 9 PGT-Anschlussplan 6
Danach versuchten wir dieses Schaltereignis auf einen Rechner zu übertragen. Da
wir noch nie digitale Signale mit einem Rechner empfangen haben, holten wir uns
Hilfe von Herrn Professor Schönhuber. Er hat uns einige Möglichkeiten genannt, wie
wir diese Informationen mit einem Rechner empfangen können. Gemeinsam mit ihm
realisierten wir die erste Übertragung der Daten. Dazu haben wir zwei Converter von
ICPCon verwendet, die uns von der Schule für einige Zeit zur Verfügung gestellt
wurden. Wir verwendeten einen „RS485 To RS232“ Converter und einen Converter,
der von RS485 auf digitale Signale konvertieren kann.
6
pgt100_user_manual.pdf
22
RS 232
RS 485
DI
RS 485
Abbildung 10 Versuchsaufbau
Am Rechner nahmen wir die Daten per HyperTerminal an, nun war unser erstes
Problem bewältigt. Jetzt konnten wir die Daten am Rechner über eine serielle
Schnittstelle einlesen. Damit wir in unserem Programm die Daten annehmen können,
mussten wir Daten über eine serielle Schnittstelle lesen beziehungsweise schreiben
können. Dazu programmierten wir die Klasse ComPort, über diese Klasse können
Daten gesendet und empfangen werden.
Die Klasse ComPort
class ComPort
{
private
private
private
private
SerialPort serialPort;
Thread readThread;
bool readingStatus;
Control parentForm;
//Events erstellen
public delegate void EventHandler(string data);
public event EventHandler DataReceived;
public event EventHandler StatusChanged;
/// <summary>
/// Konstruktor
/// </summary>
23
public ComPort(Control _parentForm) {
serialPort = new SerialPort();
readThread = null;
readingStatus = false;
parentForm = _parentForm;
}
//Diese Eigenschaft gibt den aktuellen seriellen Port zurück
public SerialPort SerialPort{
get { return serialPort; }
}
/// <summary>
/// Öffnet den seriellen Port
/// </summary>
public void Open() {
try
{
if (!readingStatus)
{
//Einstellungen
serialPort.PortName
serialPort.BaudRate
serialPort.Parity =
serialPort.DataBits
serialPort.StopBits
= "COM4";
= 9600;
Parity.None;
= 8;
= StopBits.One;
//einstellen der Timeouts
serialPort.ReadTimeout = 50;
serialPort.WriteTimeout = 50;
serialPort.Open();
readingStatus = true;
readThread = new Thread(Read);
readThread.Start();
}
}
catch (IOException) {
parentForm.Invoke(new EventHandler(StatusChanged),
new object[] { String.Format("{0} exisiert
nicht",serialPort.PortName) });
}
catch (UnauthorizedAccessException)
{
new object[] { String.Format("{0} already in
use", serialPort.PortName) });
}
if (IsOpen) {
new object[] { String.Format("alles ok am COM4") });
}
}//Open
/// <summary>
24
/// Schließt den seriellen Port
/// </summary>
public void Close() {
if (readingStatus) {
readingStatus = false;
readThread.Join();
readThread = null;
serialPort.Close();
new object[] {string.Format("Connection closed")});
}
}//Close
/// <summary>
/// Diese Methode wir in einem eigenen Thread
/// Nach dem Starten läuft sie im Hintergrund
/// mit der Close-Methode beendet wird.
/// Werden Daten an die eingestellte serielle
/// gesendet werden sie an das untergeordnete
/// gesendet
/// </summary>
private void Read() {
ausgeführt.
bis die Verbindung
Schnittstelle
Controll-Object
while (readingStatus)
{
if(serialPort.IsOpen){
try
{
byte[] buffer = new
byte[serialPort.ReadBufferSize + 1];
int count = serialPort.Read(buffer, 0,
serialPort.ReadBufferSize+1);
parentForm.Invoke(new
EventHandler(DataReceived),
new object[] {
System.Text.Encoding.ASCII.
GetString(buffer, 0, count) });
}catch(TimeoutException){}
}else{
TimeSpan waitTime = new TimeSpan(0, 0, 0, 0, 50);
Thread.Sleep(waitTime);
}//if
}//while
}//Read
/// <summary>
/// Sendet Daten an die serielle Schnittstelle
/// </summary>
public void Send(string data) {
if (IsOpen)
{
serialPort.Write(data + "\r");
//Rückgabe der gesendeten Daten an das Hauptprogtramm
parentForm.Invoke(new EventHandler(DataReceived),
25
}//if
}//Send
new object[] {data+"\r"});
/// <summary>
/// Gibt den Status des seriellen Ports zurück
/// </summary>
public bool IsOpen
{
get{return serialPort.IsOpen;}
}
}//class ComPort
Da wir diese Controller wegen des veralteten RS232 Standards nicht verwenden
wollten, wurde die Klasse in unser Steuerprogramm nicht integriert. Darum wird
diese auch nicht genauer beschrieben.
3.3.1.1
Datenübertragungsschnittstelle
Die richtige Übertragungsschnittstelle zu finden war für uns schwierig, da die ganze
Arbeit darauf aufbauen sollte. Für Herrn Opelt war von Anfang an klar, dass ein
Bussystem Verwendung finden sollte, davon waren wir anfangs nicht überzeugt,
versuchten jedoch, ein passendes System zu finden. Wir informierten uns über
diverse Bussysteme, um das richtige System für unser Problem zu finden. Nachdem
einige Geräte, die Daten über das Netzwerk senden, entschieden wir uns das
hauseigene Netzwerk als Bussystem zu verwenden. Das Netzwerk als Bussystem
bietet einen großen Vorteil, denn es befindet sich schon ein Netzwerk in der Firma
und dadurch müssen wir nur ein Kabel bis zum nächsten Switch legen. Kurz darauf
wurden wir auch bei der Suche nach einem I/O Controller fündig, der die digitalen
Signale über das Netzwerk überträgt.
3.4 Theoretische Lösung
Gerät
Schnittstelle
PGT
digital
Drehkreuz
digital
Überwachungskamera
Ethernet/digital
Lichtschranken
digital
Statuslichter
digital
26
Salto-Steuereinheit
Ethernet
Server
Ethernet
I/O Controller
Ethernet / Seriell RS232
Wir haben eine Tabelle erstellt, in der wir den einzelnen Geräten ihre Schnittstellen
zugeordnet haben. Da bereits die meisten Geräte über das Netzwerk arbeiten, haben
wir uns für einen Datenaustausch über das Netzwerk entschieden. Der große Vorteil
von Ethernet ist in diesem Fall, dass es die geforderte Übertragungsgeschwindigkeit
leicht erfüllt und außerdem in der Firma überall verfügbar ist. Ein Server empfängt
und sendet Daten an die verschiedenen Geräte und ist das Zentrum des Systems.
Die gesamte benötigte Software wird auf dem Firmenserver installiert und das
System wird dann von einem zentralen Programm gesteuert. Da alle unsere Geräte
ihre Daten per Ethernet übertragen, musste auch die Kamera diese Anforderung
erfüllen. Ausgelöst wird diese Überwachungskamera jedoch per digitalem Signal. Ein
anfängliches Problem war, die digitalen Signale vom PGT-Prüfungsgerät und von
den Lichtschranken über das Netzwerk zu übertragen. Dieses Problem haben wir
durch einen I/O Controller gelöst, dieser Controller sendet ein Bytearray an den
Server, aus welchem dann die Eingänge gelesen werden. Eine Fehlinformation am
Anfang des Projekts war, dass
das Drehkreuz über einen Netzwerkanschluss
verfügt und übers Netzwerk gesteuert werden kann. Es hat sich im Verlauf des
Projektes herausgestellt, dass das Drehkreuz nur über Kontakte, die geschalten
werden, gesteuert wird. Dieses Problem haben wir ebenfalls mithilfe des I/O
Controllers lösen können, da dieser noch über genug Signal-Ein- und Ausgänge
verfügte. Am Computer werden die gesamten Daten mithilfe eines eigenen
Programms verarbeitet. Es fehlt nur noch die Identifizierung der Mitarbeiter. Die
Identifizierung soll mithilfe eines iButtons erfolgen.
3.5 Identifizieren der Mitarbeiter
Jeder Mitarbeiter hat einen iButton, mit dem er sich identifiziert und sich Zugang zu
Büro-, Produktions- oder anderen Bereichen verschafft. Dieses System wurde von
der Firma AlliedPanels zur Verfügung gestellt und musste daher verwendet werden.
27
Abbildung 11 Leseeinheit WRM2000 7
Abbildung 12 Steuereinheit CU50EN
8
Die Leseeinheit ist mit einem CAT5 Kabel an die Steuereinheit angeschlossen, diese
ist
mit
einem
Server
per
Netzwerk
verbunden.
Verwaltet
wird
das
Identifikationssystem mit einem eigenen Programm, welches auf dem Server, der
sich im selben Netzwerk wie die Steuereinheit befindet, installiert ist.
Abbildung 13 Screenshot RW Pro-Access Salto-Verwaltungsprogramm
Mit dem Programm RW Pro-Access, von der Firma Salto, werden die Eingänge
erstellt, konfiguriert und verwaltet. Auch die Mitarbeiter und dessen Zutrittsrechte
7
8
http://www.saltosystems.com/ images/stories/products/ WRM200072.jpg
http://www.saltosystems.com/images/stories/products/details/ CU50EN.jpg
28
werden in diesem System verwaltet. Jedem Mitarbeiter können bestimmte Bereiche
und Zeiträume zugeteilt werden, in denen sie diese Zugänge passieren dürfen. Alle
Daten werden in einer Access-Datenbank gespeichert.
3.6 TCP- Server
3.6.1 TCP- Protokoll
Bevor wir endgültig wussten, dass wir Daten über das TCP-Protokoll versenden und
annehmen müssen, vermuteten wir, dass wir mit diesem Protokoll die Daten
übertragen werden. Da das TCP-Protokoll ein zuverlässiges, verbindungsorientiertes
Protokoll ist, ist es genau das richtige für unser Problem. Darum befassten wir uns
schon vor unserem Praktikum mit diesem Protokoll. Wir programmierten zwei
Programme, einen TCP-Server und einen TCP-Client.
Das Schwierige daran war, dass eines der beiden Programme funktionieren musste,
um das zweite zu testen.
3.6.2 Protokollbeschreibung
Das TCP-Protokoll stellt eine virtuelle Verbindung zwischen zwei Anwendungen her.
Auf beiden Seiten der Verbindung steht eine Programmierschnittstelle bereit. Diese
Programmierschnittstelle
plattformunabhängige
wird
als
Schnittstelle
Socket
bezeichnet.
zwischen
dem
Ein
Socket
ist
eine
Netzwerkprotokoll
des
Betriebssystems und der eigentlichen Anwendungssoftware. Aus der Sicht des
Programmierers werden beim TCP-Protokoll keine Pakete übertragen, sondern
Datenströme von Bytes.
Eine TCP-Verbindung wird durch
-die IP-Adresse des Servers und die Portnummer des Serverdienstes oder
-die IP-Adresse des Clients sowie die Portnummer des Clients
bestimmt.
Da wir nicht nur mit einem Client, sondern mit mehreren kommunizieren müssen, ist
es notwendig mehrere Clients gleichzeitig behandeln zu können. Um das zu
realisieren, setzen wir das Multithreading ein.
29
Def.: Multithreading 9
Multithreading ist ein anwendungsorientiertes Verfahren, bei dem Programme in
Programmteile und Prozesse gegliedert werden, die unabhängig voneinander in
parallelen Programmpfaden ablaufen. Multithreading ist eine softwaremäßige
Aufspaltung von langsamen Vorgängen in parallele Threads, die durch zusätzliche
Instruktionen der CPU parallel bearbeitet werden.
Für den TCP-Server wurde eine eigene Klasse namens TCPServer erstellt.
Anschließend wird die Realisierung der Klasse TCPServer beschrieben.
class TCPServer
{
private TcpListener listener = null;
private IPAddress ip;
private int port = 20;
private ArrayList sessionList;
private int nc, nr;//Zählvariablen für die Anzahl der Clients
private Control parentForm;//Das übergeornete Control-Objekt
public event ProtUpdateDelegate Status;
Als Erstes wird ein TcpListener erstellt und auf null gesetzt. Der TcpListener
stellt Methoden für die Annahme von eingehenden Verbindungswünschen bereit.
Anschließend werden die IP-Adresse und ein Serverport deklariert.
Die ArrayList sessionList wird für die Clients genutzt. Jeder Client wird als
Session-Objekt in der sessionList behandelt.
public TCPServer(Control _parentForm)
{
sessionList = new ArrayList();
ip = Dns.GetHostEntry(Dns.GetHostName()).AddressList[0];
StartServer();
}//Konstruktor
Zu Beginn wird die ArrayList sessionList erzeugt. Anschließend wird die IP des
Computers in die Variable ip gespeichert und die Methode StartServer() wird
aufgerufen.
9
http://www.itwissen.info/definition/lexikon/Multithreading-multithreading.html
30
/// <summary>
/// Gibt die Anzahl der Clients zurück
/// </summary>
public int Clients{
get { return sessionList.Count; }
}
/// <summary>
/// Mit dieser Methode wird der TCP-Server gestartet
/// </summary>
public void StartServer()
{
try
{
listener = new TcpListener(ip, port);
listener.Start();
ThreadPool.QueueUserWorkItem(new
WaitCallback(this.Listen));
}
catch (Exception e)
{
MessageBox.Show(e.ToString());
}
}//Start Server
In dieser Methode wird das TcpListener-Objekt namens listener mit der IPAdresse und der Portnummer erzeugt. Danach wird der listener gestartet und die
Methode Listen wird in den ThreadPool geworfen. Tritt ein Fehler auf, wird eine
MessageBox mit einer Fehlermeldung gezeigt.
In dieser Methode kommt zum ersten Mal das Threading zum Einsatz und zwar in
einer besonderen Form, dem ThreadPool. Das Threading war für uns anfangs ein
wenig verwirrend. Sobald es mehr Threads wurden, wusste man nicht mehr genau,
wann welcher Thread gerade aktiv ist. Doch mit einigen Testprogrammen bekamen
wir das Problem in den Griff.
Def: Der ThreadPool
Statt für jede Aufgabe einen neuen Thread zeitaufwändig zu erzeugen und
anschließend wieder zu zerstören, erstellt man hier einen ThreadPool.
Durch ThreadPooling kann man Threads effizienter und ressourcenschonender
einsetzen. Im ThreadPool werden eingehende Aufträge einem freien Thread
zugeteilt oder in eine Warteschlange gestellt. Ein einzelner Thread überwacht den
Status mehrerer Wartevorgänge, die sich in der Warteschleife befinden. Nach
31
Beendigung eines Wartevorgangs wird die Rückruffunktion von einem Arbeitsthread
im ThreadPool ausgeführt.
public void Listen(object obj)
{
MSAccess ms = new MSAccess();
string sql;
try
{
while (true)
{
TcpClient tcpClient = listener.AcceptTcpClient();
lock (this)
{
//Hier wird der Datenbankpfad zugewießen
ms.Database = Properties.Settings.
Default.Datenbankpfad;
//Generiert den SQL-Code
sql = "SELECT id_lock,ControllerIP FROM
tb_Eingaenge WHERE ControllerIP='";
sql += (tcpClient.Client.RemoteEndPoint as
IPEndPoint).Address.ToString() + "'";
DataTable table = ms.DataAdapter(sql);
//Kontrolliert ob der Klient in der Datenbank
//eingetragen ist. Wenn er nicht eingetragen
//ist, wird die Verbindung verweigert
if (table.Rows.Count == 1)
{
Session session = new Session(this,
tcpClient,(int)table.
Rows[0]["id_lock"]);
ThreadPool.QueueUserWorkItem(
new WaitCallback(session.Run));
sessionList.Add(session);
}//if
}//lock
}//while
}
catch (Exception e)
{
lock (this)
{
MessageBox.Show(e.Message, "Fehler im ServerThread");
}//lock
}//catch
}//Listen
32
In dieser Methode werden eingehende Verbindungswünsche verarbeitet. Als Erstes
wird ein MSAccess-Objekt erzeugt, das Methoden bereitstellt, um Daten einer
Access-Datenbank zu verarbeiten. Anschließend wird in einer Endlosschleife geprüft,
ob ein Client eine Verbindung wünscht. Durch die Methode AcceptTcpClient, die
der TcpListener bereitstellt, wird ein TcpClient-Objekt vom Client, der die
Verbindung wünscht, zurückgegeben, das zurückgegebene Objekt wird dann in dem
Objekt tcpClient abgespeichert.
Im nächsten Schritt wird der Eigenschaft Database des MSAccess-Objekts der
Datenbankpfad zugewiesen. Anschließend wird überprüft, ob der Client überhaupt
berechtigt ist, eine Verbindung herzustellen.
Dazu wird ein SQL-String erzeugt und mit der Methode DataAdapter, welche vom
MSAccess-Objekt
zur
Verfügung
gestellt
wird,
ausgeführt.
Die
Methode
DataAdapter gibt anschließend ein DataTable Objekt zurück. Wenn die
Eigenschaft DataTable.Rows.Count gleich 1 ist, ist der Client eingetragen und eine
Verbindung wird erlaubt.
Wenn die Verbindung erlaubt wird, wird ein Session Objekt für den Client erzeugt,
diesem Objekt wird das Server-Objekt, der TcpClient und die Tür ID-Nummer
(id_lock) übergeben. Wenn das Objekt angelegt wurde, wird die Session.RunMethode() in den ThreadPool geworfen. Daraufhin wird dann das Session-Objekt
zur sessionList hinzugefügt.
Tritt in der Endlosschleife ein Fehler auf, wird eine MessageBox mit einer
Fehlermeldung (Exception) ausgegeben.
public void StopServer() {
listener.Stop();
}//StopServer
Mit dieser Methode kann der TCP-Server gestoppt werden. Dazu wird die Methode
Stop() des TcpListener-Objekt aufgerufen.
33
public void ClientRemove(object session)
{
lock (this) {
sessionList.Remove((Session)session);
}
}//Cleint Remove
Mit dieser Methode kann ein Client aus der sessionList entfernt werden. Man muss
dieser Methode das zu entfernende Session-Objekt mitübergeben. Das ArrayListObjekt stellt eine Methode namens Remove zur Verfügung, welcher man das zu
entfernende Objekt übergeben muss, um es aus der sessionList zu entfernen.
In der Klasse TCPServer werden jetzt Verbindungen angenommen, jedoch nicht
verwaltet. Der Client kann jetzt eine Verbindung herstellen, jedoch kann über diese
Verbindung noch nicht kommuniziert werden.
Um die Verbindungen der einzelnen Clients zu verwalten, wird die Klasse Session
erzeugt. Mit dieser Klasse werden nun alle Clients verwaltet. Für jeden Client wird
ein neues Objekt erzeugt und in der sessionList abgespeichert. In der jeweiligen
Klasse wurde die Kommunikation zwischen Server und dem Client programmiert.
class Session
{
private TcpClient client;
private TCPServer server;//Der Server von dem der Client akzeptiert
wurde
private int client_id; //id_lock die Eingangs ID
private NetworkStream stream;//Stream zum übertragen der Daten
private int input;//Der Code, der vom Client übertragen wird
private int inputControll;
private bool dkz;
int test = 0;
In der Session wird ein TcpClient-Objekt für den Client erzeugt.
public Session(TCPServer cs, TcpClient _client, int id)
{
server = cs;
client = _client;
client_id = id;
}//Konstruktor
Im Konstruktor werden die Felder gesetzt.
34
public void Run(object obj)
{
try
{
stream = client.GetStream();
stream.ReadTimeout = 50000;
byte[] data = new byte[14];
int nRead;
stream.Write(IOControll.OutputOffAll(), 0,
IOControll.OutputOffAll().Length);
while (true)
{
nRead = stream.Read(data, 0, data.Length);
//-----------------------------// Hier wurde der Kontrollablauf
// programmiert
//-----------------------------}//while
}
catch (IOException ex)
{
MessageBox.Show(ex.ToString())
}
finally
{
CloseSession();
}
}//Run
Durch diese Methode wird mit dem Client kommuniziert. Beim Erzeugen des
Session-Objekts wird diese Methode in einem eigenen Thread ausgeführt.
Durch die Methode GetStream(), die vom TcpClient-Objekt bereitstellt wird, wird
ein NetworkStream zurückgegeben und in stream gespeichert. Durch dieses
NetworkStream-Objekt können Daten empfangen oder gesendet werden.
Anschließend wird die ReadTimeout Eigenschaft gesetzt. Diese Eigenschaft
ruft die Zeitspanne ab, in der ein Lesevorgang während des Wartens auf Daten
blockiert wird.
Danach wird ein Bytearray erzeugt, um die empfangenen Daten zu speichern.
Durch die Methoden Write() und Read() können Daten aus oder in den Stream
geschrieben oder gelesen werden.
Damit man sicher sein kann, dass am Anfang alle Ausgänge ausgeschaltet sind,
werden sie durch die Methode IOControll.OutputOffAll() ausgeschaltet.
Um Daten zu empfangen, muss man die Methode Read() ausführen. Dies muss
35
während der ganzen Verbindungsdauer, mittels einer Endlosschleife, geschehen.
In dieser Endlosschleife wurde der Kontrollablauf des Einganges ausprogrammiert.
/// <summary>
/// Sendet einem Client Daten
/// </summary>
/// <param name="data">Das zu sendende Byte Array[7]</param>
private void TellClient(byte[] data)
{
stream.Write(data, 0, 7);
}//TellClient
Diese Methode übernimmt ein 7 stelliges Byte-Array und sendet es über den
NetworkStream an den Client beziehungsweise an den I/O Controller.
/// <summary>
/// Beendet die Verbindung mit dem Clienten
/// und wirft ihn aus der SessionList
/// </summary>
private void CloseSession()
{
client.Client.Shutdown(SocketShutdown.Both);
client.Close();
server.ClientRemove(this);
}//CloseSession
Mit dieser Methode wird die Verbindung innerhalb der Klasse beendet.
client.Client.Shutdown(SocketShutdown.Both);
Durch diesen Befehl wird der Socket im TcpClient–Objekt aufgefordert, vor dem
Schließen alle Daten zu emfangen oder zu senden.
Danach wird der Client mit der Close()-Methode geschlossen, um Ressoucen zu
schonen.
Am Ende dieser Methode wird das Session-Objekt aus der sessionList entfernt,
dazu wird die Methode ClientRemove() im TCPServer-Objekt aufgerufen. Dieser
Methode muss man das zu entfernende Session-Objekt übergeben.
36
3.7 Digitaler I/O Controller PL
Nach einer langen Suche nach einem Gerät für die Datenkonvertierung von einem
digitalen Signal auf Ethernet und umgekehrt entschieden wir uns für den I/O
Controller PL von der Firma HW-Group. Wir wussten, dass wir mindestens vier
digitale Eingänge für:
•
•
•
2x Lichtschranke
2x ESD-Prüfgerät
1x Schalter zum Zurücksetzen des Alarms
und mindestens zwei digitale Ausgänge für:
•
•
1x Signallampe
1x Signallampe für den Benutzer
benötigen.
Außerdem waren wir uns nicht ganz sicher, ob das Drehkreuz wirklich über Ethernet
erreichbar ist und auch die Auslösung von Schwenktür und Kamera war uns noch
nicht bekannt. Deshalb entschieden wir uns dafür, ein Gerät zu kaufen, das etwas
mehr digitale Ein- und Ausgänge hat, also ein Gerät mit 8 digitalen Eingängen und 8
digitalen Ausgängen. Nach einer Recherche fanden wir den I/O Controller PL von
HW-Group, der sogar preislich noch günstiger war als einige Varianten mit weniger
Ein- und Ausgängen. Außerdem hatte dieser einen COM-Port, der über Ethernet als
virtueller COM-Port erreichbar ist. Diese Funktion ist nicht nur zum Einstellen des
Controllers von Vorteil, sondern sollte eine gewisse Absicherung darstellen, falls wir
irgendein Gerät über RS-232 betreiben müssen, was fast der Fall gewesen wäre.
Nach der Recherche und einer Absprache innerhalb des Projektteams und mit
unserem Betreuer entschieden wir uns, die österreichische Vertretung der HWGroup, die Firma Bellequip, zu kontaktieren. Die Firma Bellequip begeisterte uns
sofort durch eine sehr gute Beratung, weshalb wir uns dann entschieden, das Gerät
zu kaufen.
Der I/O Controller sollte uns in unserer Arbeit um einiges vorwärts bringen. Jedoch
brachte er ein Protokoll mit, das uns lange Zeit immer wieder beschäftigen sollte, der
Name des Protokolls ist NVT (Network Virtual Terminal). Der Controller sendet in
einer Client/Server – Verbindung die Änderungen an den Eingängen als Bytearray an
den Server. Dieses Bytearray beinhaltet alle Informationen über die Situation bei den
37
Eingängen.
Da wir zu Beginn der Arbeit nicht genau genug recherchiert hatten, gingen wir davon
aus, den String, den man im Herkules-Programm angezeigt bekommt, wenn dieses
Daten
empfängt,
auch
zum
Vergleichen
und
somit
Herausfinden
der
Eingangsnummer verwenden zu können.
Abbildung 14 Screenshot Hercules Setup ulility
3.7.1.1
Das NVT-Protokoll
Unsere Überlegung, in C# ausformuliert, sah dann so aus:
public static int Input(byte[] bytearray)
{
//ByteArray in String convertieren
string hexstring = BitConverter.ToString(bytearray);
//Variable für die Eingangsnummer
int eingang;
//Switch vergleicht den Inhalt von "hexstring" mit den
//verschiedenen Eingängen, um die Nummer des Eingangs zu
//bekommen!
38
}
}
}
switch (hexstring)
{
case "FF-FA-2C-32-00-FF-F0-FF-FA-2C-34-7F-FF-F0":
{
eingang = 7;
break;
}
case "FF-FA-2C-32-00-FF-F0-FF-FA-2C-34-BF-FF-F0":
{
eingang = 6;
break;
}
case "FF-FA-2C-32-00-FF-F0-FF-FA-2C-34-DF-FF-F0":
{
eingang = 5;
break;
}
case "FF-FA-2C-32-00-FF-F0-FF-FA-2C-34-EF-FF-F0":
{
eingang = 4;
break;
}
case "FF-FA-2C-32-00-FF-F0-FF-FA-2C-34-F7-FF-F0":
{
eingang = 3;
break;
}
case "FF-FA-2C-32-00-FF-F0-FF-FA-2C-34-FB-FF-F0":
{
eingang = 2;
break;
}
case "FF-FA-2C-32-00-FF-F0-FF-FA-2C-34-FD-FF-F0":
{
eingang = 1;
break;
}
case "FF-FA-2C-32-00-FF-F0-FF-FA-2C-34-FE-FF-F0":
{
eingang = 0;
break;
}
default:
{
return 99;
}
}
return eingang;
In dieser Methode wird das vom I/O Controller gelieferte Bytearray bytearray mittels
der Standartklasse BitConverter in den String hexstring umgewandelt. Mit einer
Switchkonstruktion wird dann ermittelt, welcher aus dem Herkules-Programm
entnommene String mit dem vom I/O Controller hereingegebenen übereinstimmt.
39
Diese Methode funktioniert sehr gut, solange sich nur ein Eingang ändert, ändern
sich jedoch mehrere Eingänge, so ergibt das einen anderen String, da das NVTProgramm die Änderungen an allen 8 digitalen Eingängen mit Hilfe von 255 Byte
ausdrückt.
3.7.1.2
Die verbesserte Version
Um das Ganze zu verstehen, mussten wir uns dieses Bytearray genauer ansehen.
Bei diesem Beispiel wurde nur der Eingang sieben geschalten.
FF-FA-2C-32-00-FF-F0-FF-FA-2C-34-7F-FF-F0
Für die Ausgabe wichtig ist der Hexawert „7F“, was dezimal „127“ und binär
„0111111“ beträgt. Diese Stelle im Array beschreibt die geschalteten Eingänge. Der
Converter schickt die Daten im NVT Protokoll, welches besagt, dass in den 255
Bytes die Zustände aller Eingänge beschrieben werden. Nehmen wir also unser
Beispiel „7F“ in binär, da man es hier am besten sieht, welche Eingänge geschalten
sind, nämlich in diesem Fall der Eingang Nummer sieben bei unserem I/O Controller.
Das ist der Eingang, bei dem im Binären eine Null steht. Hätten wir die Zahl „FF“
(binär: 11111111) wäre keiner der Eingänge geschalten. Bei der Hexazahl „00“ sind
alle Eingänge geschalten.
Aus dieser Feststellung folgt dann der neue Code:
public static int Input(byte[] bytearray)
{
if (bytearray[10] != 52) {
return 99;
}
int count = bytearray[11];
if (count <= 0)
return 99;
int[] led = new int[8];
for (int i = led.Length - 1; i >= 0; i--)
{
led[led.Length - 1 - i] = count % 2;
count = Convert.ToInt32(Math.Round((double)(count / 2),
40
}
0));
{
if (led[i] == 0)
return i;
}
return 99;
}//input
Wenn sich die Lage bei den Eingängen ändert, das heißt, wenn ein Eingang schaltet,
sendet der I/O Controller ein Bytearray an den Server. Ist das der Fall, steht an der
elften Stelle des Bytearrays der Hexawert „34“, also in dezimal 52. Ist das nicht der
Fall, wird die Methode mit „return 99“ beendet. 99 wird in der Klasse IOControll
immer
dann übergeben,
wenn ein falsches
Bytearray oder
eine
falsche
Eingangsnummer übermittelt wurde. In dieser Methode wird die Hexazahl, die
stellvertretend für die geschaltenen Eingänge steht, in eine Binärzahl umgerechnet.
Wir haben also versucht, von der Zahl bei jedem Schleifendurchlauf, wenn i für die
Zählvariable steht und dekrement behandelt wird, die Zahl modulo 2 zu berechnen.
Das Ergebnis speichern wir dann in ein Array.
Dass wir damit eine Binärzahl erzeugen, merkten wir erst, als die Methode dann
fertig war und wir uns das Ergebnis ausgeben ließen.
Zum Beispiel:
255 mod 2  1
127 mod 2  1
63 mod 2  1
31 mod 2  1
15 mod 2  1
7 mod 2  1
3 mod 2  1
1 mod 2  1
Das führt zu dem Ergebnis: 1111 1111 in binär und heißt, dass keine Eingänge
geschalten sind.
41
{
}
if (led[i] == 0)
return i;
In dieser for-Schleife wird nach dem letzten geschalteten Eingang gesucht, da
dieser die höchste Priorität hat.
Dieses Programm brachte dann die gewünschten Ergebnisse, jedoch konnten wir
nicht vorhersehen, dass der I/O Controller während des Testaufbaues seinen Dienst
verweigert. Der I/O Controller bekam dadurch, dass wir keinen galvanischen Trenner
nutzten, einen zu hohen Strom auf die Eingänge, was einige ICs nicht aushielten.
Jetzt musste zum Testen ganz schnell eine Alternative her, da wir auf das neue
Gerät 2 Wochen warten mussten. Wir entschieden uns also, das Programm TCPClient, das wir zeitgleich mit dem TCP-Server programmierten, auf ein Testprogramm
umzurüsten.
3.8 TCP-Client
Abbildung 15 Screenshot TCP-Client Testprogramm
Man sieht hier die Programmoberfläche des fertigen TCP-Clients. Es wurde für jeden
Ein- beziehungsweise Ausgang ein Button oder ein Signalfeld angelegt, um den
Server ordentlich testen zu können. Da wir Probleme mit dem Programm hatten, das
42
die Daten in die Datenbank schreibt, haben wir eine Zeitstoppuhr eingebaut. Die
Stoppuhr stoppt die Zeit mit, die vom Absenden bis zum Eintreffen des simulierten
Signals für das Erdungsprüfgerät, bis zur Rückmeldung des Servers an das
simulierte Drehkreuz vergeht. Mit diesem Client konnten wir dann den Server
optimieren, ohne Zeit zu verlieren, und gleichzeitig auch noch mit mehreren Clients
testen. Das war für uns eine große Erleichterung, da wir ohne einen zweiten
Teststand jetzt wussten, dass unser Programm funktioniert.
Def.: try-catch 10
Der try-Block enthält den überwachten Code, der möglicherweise die Ausnahme
verursacht. Der Block wird solange ausgeführt, bis er erfolgreich abgeschlossen oder
eine Ausnahme ausgelöst wird.
Hier sieht man den try–Block des Clients, also den Teil, in dem versucht wird, etwas
zu lesen, oder zu schreiben.
try
{
if (connected == false)
{
client = new TcpClient("bigone", port);
connected = true;
txtinfo.Text += "tcp client gestartet" + Environment.NewLine;
lblverbindung.Text = "Verbunden mit Horst!";
ThreadPool.QueueUserWorkItem(new WaitCallback(this.Receive));
}
}
catch (ArgumentNullException ex)
{
txtinfo.Text+="Exception:"+ex.ToString()+Environment.NewLine;
}
catch (SocketException ex)
{
txtinfo.Text+= "SocketException:"+ ex.ToString()+Environment.NewLine;
}
Da der TCP-Client generell mit dem TCP-Server programmiert werden muss, um die
Programme miteinander testen zu können, gehen wir hier jetzt nicht noch einmal
genau auf die Funktionsweise ein.
10
http://msdn.microsoft.com/de-de/library/0yd65esw(VS.80).aspx
43
namespace TCPClient
{
delegate void ProtUpdateDelegate(string s);
public partial class TCPClient : Form
{
DateTime timepgt;
DateTime timedkz;
TcpClient client = null;
const int port = 20;
NetworkStream stream;
bool connected=false;
ProtUpdateDelegate protokollant;
Für den TCP-Client brauchen wir einen Serverport und einen Networkstream.
Außerdem wird die Variable bool connected deklariert und auf false gesetzt und
ein Delegate definiert.
public TCPClient()
{
InitializeComponent();
protokollant = new ProtUpdateDelegate(ProtUpdate);
}
Im Konstruktor wird das Delegate protokollant erzeugt.
private void btnstart_Click(object sender, EventArgs e)
{
try
{
if (connected == false)
{
client = new TcpClient("servername", port);
connected = true;
ThreadPool.QueueUserWorkItem(new
WaitCallback(this.Receive));
}
}
catch (ArgumentNullException ex)
{
txtinfo.Text+="ArgumentNullException:"
+ex.ToString()+Environment.NewLine;
}
catch (SocketException ex)
{
txtinfo.Text+= "SocketException:"+
ex.ToString()+Environment.NewLine;
}
}//Start
44
Die Methode btnstart_Click() verbindet den Client mit dem TCP-Server. Im
try–Block wird mit einer if-Anweisung (connected == false) überprüft, ob bereits
eine Verbindung besteht, falls das nicht der Fall ist, wird mit client = new
TcpClient("servername", port) ein neuer TCP-Client erstellt. Um mit dem TCPServer kommunizieren zu können, brauchen wir einen Stream, den wir mit stream =
client.GetStream() erstellen. Jetzt setzen wir noch connected auf true. Mit
ThreadPool.QueueUserWorkItem(new WaitCallback(this.Receive)) wird die
Methode Receive() in den Threadpool geworfen, wo sie dann verwaltet wird. Falls
der Client keine Verbindung herstellen kann, wird eine Exception ausgelöst.
void Receive(Object obj)
{
try
{
stream.ReadTimeout = 100000000; //msec
byte[] data = new byte[7];
int nRead;
while (true)
{
nRead = stream.Read(data, 0, data.Length);
if (nRead > 0)
{
BeginInvoke(protokollant,
BitConverter.ToString(data));
//Führt ein Delegate aus um bytearray aus dem
//Threadpool zu bringen
}
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Fehler beim
Nachrichtenempfang.", MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
Die Methode Receive() bildet das Herzstück des TCP-Client. Im try–Block wird ein
ReadTimeout von 10^8 Millisekunden festgelegt, das ist die Zeitspanne, in der ein
Lesevorgang während des Wartens auf Daten blockiert wird. Außerdem wird das
Bytearray data und int nRead deklariert. In einer Endlosschleife wird jetzt die Länge
des Bytearray data ermittelt und das Bytearray mit Daten gefüllt. Wenn nRead
größer als 0 wird, werden mittels Delegate die Daten an den Haupthread gesendet,
45
dazu wandeln wir das Bytearray in einen String um. Falls der Client nichts lesen
kann, wird eine Exception ausgelöst.
3.9 Fehlerprotokoll
Damit man fehlerhafte Eintrittsversuche kontrollieren kann, haben wir ein
Fehlerprotokoll programmiert. In diesem Protokoll werden alle fehlerhaften
Eintrittsversuche gespeichert. Damit nicht alle Fehleintritte angezeigt werden, kann
man einen gewissen Zeitraum auswählen.
Weiters haben wir einen Button zum
Drucken hinzugefügt.
Abbildung 16 Screenshot Protokoll der fehlerhaften Eintrittsversuche
Die Klasse Protokoll ist eine abgeleitete Klasse von Form-Object.
public partial class Protokoll : Form
{
public Protokoll()
{
InitializeComponent();
rb2tage.Checked = true;
dgvProtokoll.AllowUserToAddRows = false;
LoadData(new DateTime(1,1,3));
}
Im Konstruktor wird die Zeit, mittels Radio-Buttons, auf zwei Tage voreingestellt. Sie
kann auf 2 Tage, 7 Tage, 4 Wochen, 6 Monate und 12 Monate eingestellt werden.
46
Um die Daten anzuzeigen, wird ein DataGridView verwendet. Damit der Benutzer
keine Zeilen hinzufügen kann, wird die Eigenschaft AllowUserToAddRows auf false
gesetzt. Anschließend wird die Methode LoadData(DateTime date) aufgerufen.
Dieser Methode wird ein DateTime-Objekt mit der eingestellten Zeit mit übergeben.
private void LoadData(DateTime date){
DateTime dt = DateTime.Now;
dt = dt.AddMonths(-date.Month + 1);
dt = dt.AddDays(-date.Day + 1);
dt = dt.AddYears(-date.Year + 1);
try
{
MSAccess ms = new
MSAccess(Properties.Settings.Default.Datenbankpfad);
string sql = "SELECT ID,LastName,FirstName,Datum,tb_Locks.Name
FROM tb_Locks,tb_Users,tb_ESDfailed ";
sql += "WHERE UserID=id_user AND LockID=id_lock AND ";
sql += "Datum>#"+dt.Month+"/"+dt.Day+"/"+dt.Year+"#";
DataTable table = ms.DataAdapter(sql);
table.Columns["FirstName"].ColumnName = "Vorname";
table.Columns["LastName"].ColumnName = "Nachname";
table.Columns["Name"].ColumnName = "Eingangname";
dgvProtokoll.DataSource = table;
dgvProtokoll.Update();
}
catch (NullReferenceException)
{
return;
}
catch (Exception e) {
}
}//LoadData
Diese Methode wird im Konstruktor aufgerufen. In dem DateTime-Objekt dt wird der
anzuzeigende Zeitraum gespeichert, dazu wird die ausgewählte Zeitspanne vom
aktuellen Datum abgezogen. Anschließend werden die Daten aus der Datenbank
geladen. Dazu wird ein MSAccess-Objekt erzeugt, mit dem ein SQL-Code ausgeführt
werden kann. Anschließend wird ein SQL-String erzeugt. Dieser wird mittels der
Methode DataAdapter, die das Objekt MSAccess beinhaltet, ausgeführt.
Aus der Datenbank werden von den Tabellen tb_Locks,tb_Users,tb_ESDfailes
die Spalten ID, LastName, FirstName und Datum in dem gewissen Zeitraum
geladen. Die Methode DataAdapter() gibt ein DataTable-Objekt zurück, welches
in die Variable table gespeichert wird. Im nächsten Schritt werden die
47
Spaltennamen geändert. Damit man die Tabelle im DataGridView schließlich sehen
kann, muss man zuerst die Tabelle der DataSource-Eigenschaft des DataGridView
zuweisen. Danach wird das DataGridView mit der Update()-Methode aktualisiert.
Tritt im try-Block ein Fehler auf, wird ein catch-Teil ausgeführt. Welcher ausgeführt
wird, hängt vom Fehler ab.
private void rb2tage_CheckedChanged(object sender, EventArgs e)
{
}
private void rb7tage_CheckedChanged(object sender, EventArgs e)
{
LoadData(new DateTime(1, 1, 8));
}
private void tb4w_CheckedChanged(object sender, EventArgs e)
{
}
private void rb3monate_CheckedChanged(object sender, EventArgs e)
{
}
{
}
{
}
Um den Zeitraum der anzuzeigenden Fehleintritte zu ändern, muss per Radio-Button
eine Zeitspanne gewählt werden. Der Radio-Button erkennt die Veränderung und ein
Ereignis wird ausgeführt. In diesem Fall wird, je nach Radio Button, eine der obigen
Methoden
ausgeführt.
Diese
Methoden
rufen
wiederum
die
Methode-
LoadData(DateTime date) auf, welcher der Zeitraum mit übergeben wird.
48
private void toolStripButton1_Click(object sender, EventArgs e)
{
MyPrintPreviewDialog dr = new
MyPrintPreviewDialog(((DataTable)dgvProtokoll.DataSource));
}
Um das Protokoll nicht nur elektronisch zur Verfügung zu haben, haben wir auch das
Ausdrucken realisiert. Wenn man im linken, oberen Bereich den Button Drucken
auswählt, wird ein MyPrintPreviewDialog-Objekt erzeugt. Diesem Objekt wird die
Tabelle des DataGridView-Objekts mit übergeben. Anschließend öffnet sich eine
Druckvorschau, in der man sich das Dokument ansehen und ausdrucken kann.
3.10 Ablaufsteuerung
Die Ablaufsteuerung wurde in der Session-Klasse implementiert, da dort die
Kommunikation zwischen Server und Clients stattfindet.
Zuerst unterteilten wir die Gesamtprüfzeit in Einzelabschnitte.
WRM 2000
PGT 100
DKZ 350
t1
t2
Gesamtprüfzeit
t1 … Zeit zwischen Identifizierung und ESD-Prüfung
t2 … Zeit zwischen Drehkreuz Freigabe und dem Passieren der
Lichtschranken
Abbildung 17 Prüfzeitzerlegung
49
3.10.1 Ablaufbeschreibung
Ein großes Problem war, dass wir nicht wussten, durch welches Ereignis die Prüfung
gestartet werden soll. Eine gute Lösung wäre gewesen, wenn man die Identifizierung
als Prüfungsstart verwenden könnte, doch diese Daten werden durch ein eigenes
Programm (RW Pro- Access) von der Firma Salto verarbeitet. Da die Firma Salto ein
eigenes Protokoll verwendet und die Daten durch eine 3DES-Verschlüsselung
schützt, war es uns nicht möglich, diese Daten in unserem Programm anzunehmen.
Doch wir haben eine einfache Lösung gefunden, wir lesen die Daten einfach aus der
Datenbank der Salto-Software. Die Prüfung starten wir einfach durch das ESDPrüfgerät. Wird eine ESD-Prüfung durchgeführt, so stellt der I/O Controller eine
Verbindung zum Server her und sendet ein 14-stelliges Bytearray. Dieses Bytearray
wird mit der Klasse IOControll in eine Zahl umgewandelt. Jede Zahl steht für einen
Eingang am I/O Controller. Jetzt gibt es mehrere Möglichkeiten, es könnte eine
Prüfung gestartet werden oder jemand versucht das System zu umgehen, indem er
zum Beispiel über das Drehkreuz springt. Hat das ESD-Prüfgerät Daten gesendet, so
wird eine Prüfung gestartet. Das ESD-Prüfgerät unterscheidet, ob die Prüfung positiv
oder negativ war. Als Nächstes werden die Identifizierungsdaten aus der Datenbank
gelesen, wurde in der Zeit t1 kein Mitarbeiter identifiziert, dann wird die Prüfung
verworfen.
Wenn sich jemand in der Zeit t1 identifiziert hat, dann wird die Prüfung fortgesetzt.
War die ESD-Prüfung positiv, dann wird das Drehkreuz freigegeben und der
Mitarbeiter hat eine gewisse Zeit (t2), um die Lichtschranken zu passieren. In dieser
Zeit werden die Lichtschranken deaktiviert. Wenn die ESD-Prüfung jedoch negativ
war, wird der Mitarbeiter in die Datenbank eingetragen, außerdem wird eine rote
Signalleuchte für zwei Sekunden eingeschaltet.
Wenn jetzt die Lichtschranken senden, wird überprüft, welcher der beiden
Lichtschranken zuerst ausgelöst wurde. Damit können wir die Gehrichtung
bestimmen. Kommt jetzt ein Mitarbeiter vom EPA-Bereich und will diesen verlassen,
werden zwar beide Lichtschranken aktiviert, doch es wird die Kamera nicht
ausgelöst. Will jedoch jemand über das Drehkreuz springen, dann werden die
Lichtschranken aktiviert und ein Bild wird aufgenommen. Dieses Bild wird lokal am
Server abgelegt.
50
In dieser Tabelle wird die Aussage der Signalleuchten veranschaulicht:
Signalleuchte 1
Signalleuchte 2
(Grün)
(Rot)
Bedeutung
Es kann eine neue Prüfung gestartet werden.
Die Identifizierung war nicht erfolgreich oder
wurde nicht durchgeführt.
Negative ESD-Prüfung. Der Mitarbeiter wurde in
die Datenbank eingetragen.
Eine ESD-Prüfung wurde gestartet. Beide
Lampen leuchten für eine gewisse Zeit
(Übergangszeit) nicht. Wenn das Drehkreuz
freigegeben wird, muss der Mitarbeiter, solange
keine Lampe leuchtet, die Lichtschranken
passieren.
3.10.2 Programmablaufplan
Programmablaufplan der Run()-Methode in der Session-Klasse:
51
Abbildung 18 SFC - Programmablaufplan der Prüfungsmethode 1
52
Programmablaufplan der StarteKontrolle()-Methoden in der Session-Klasse:
Diese Methode wird in einem eigenen Thread ausgeführt, wenn ein Prüfungsstart
erfolgt.
Abbildung 19 SFC - Programmablaufplan der Prüfmethode 2
53
Erläuterung
der
wichtigsten
Variablen
und
Methoden
der
beiden
Programmablaufpläne:
bool dkz
Standardmäßig auf false gesetzt. Wird diese Variable auf true
gesetzt, wird das Drehkreuz freigegeben. Nach der Zeit t2 wird die
Variable wieder auf false gesetzt.
int test
Hat standardmäßig den Wert 0. Wird eine Prüfung gestartet, so
wird die Variable auf 1 gesetzt. Nach der Prüfung wird der Variable
test wieder der Wert 0 zugewiesen.
bool vierer
Wenn input 4 oder 5 ist, wird die Variable vierer oder fuenfer
bool fuenfer
auf true gesetzt. Nach einer gewissen Zeit wird die Variable
wieder auf false gesetzt.
int input
Wird vom Client ein Bytearray gesendet, wird es, nach dem
Umwandeln mit der IOController-Klasse, der Variable input
zugewiesen.
Übergangszeit
In dieser Zeit muss der Mitarbeiter, nach einer bestandenen
Prüfung, die Lichtschranken passiert haben.
OutputOn(x)
Mit diesen Methoden werden die Ausgänge am I/O Controller
bzw
geschaltet. Die Zahl x gibt die Ausgangsnummer an.
OutputOff(x)
3.11 Die Datenbank
Eine sehr große Rolle in der Arbeit spielt die Datenbank. Auf den Grund werde ich
jetzt näher eingehen. Und zwar müssen wir die Daten von der SaltoZugangskontrolle übernehmen und dann weiterverarbeiten. Wir haben natürlich
versucht, die Daten, also die user-ID, direkt anzunehmen. Diese Idee war jedoch
nicht durchsetzbar, da Salto alle Daten in einem eigenen Protokoll verschlüsselt
sendet. Spätestens als wir das herausfanden, mussten wir uns Gedanken über eine
andere Lösung machen. Nach längerer Recherche kamen wir schließlich auf die
Idee, die Daten aus der Datenbank zu lesen. Während wir an dieser Lösung bereits
arbeiteten, suchten wir auch noch nach einer Lösung, die Daten anders zu
54
bekommen. Eine Alternative wäre ein zusätzliches Steuergerät gewesen, welches
jedoch wieder hohe Kosten verursacht hätte und durch eine Datenübertragung per
RS232 nicht gerade beeindruckend war, da wir versuchten die Datenübertragung, so
weit es geht, per Bussystem zu vollziehen. So entschieden wir uns, die Daten
einfach aus der bereits bestehenden Access-Datenbank zu holen. Das hatte
natürlich den Vorteil, dass wir auch anfallende Daten gleich in der Datenbank mit
dokumentieren können.
3.11.1 Die Klasse MSAccess
Die Klasse MSAccess wurde von uns programmiert, um mit der Methode
DataAdapter() aus der Datenbank lesen zu können oder mit der Methode
DataWrite() in die Datenbank schreiben zu können. Diese beiden Methoden
werden bei jeder Kommunikation mit der Datenbank verwendet.
class MSAccess
{
private string database;
public MSAccess() {
}//Konstruktor
}
public MSAccess(string _database)
{
database = _database;
}//Konstruktor
//--------------------Eigenschaften-------------------/// <summary>
/// Setzt die Datenbank
/// </summary>
public string Database{
set { database = value; }
In der Eigenschaft Database wird hier die Datenbank gesetzt.
/// <summary>
/// Öffnet die Datenbank und führt einen SQL string aus.
/// </summary>
/// <param name="sql">SQL String</param>
/// <returns>Gibt zurück ob das Schreiben in die Datenbank
///erfolgreich war</returns>
public bool DataWrite(string sql)
{
try
55
{
string connStr = @"Provider=Microsoft.ACE.OLEDB.12.0;
Data Source=" + database + ";Jet OLEDB:Database
Password=xxxxxxxxxxxxxxxx";
OleDbConnection connection = new OleDbConnection(connStr);
connection.Open();
OleDbCommand command = new OleDbCommand(sql, connection);
command.ExecuteNonQuery();
connection.Close();
return true;
}
catch (OleDbException) {
MessageBox.Show("Fehler beim Schreiben in die Datenbank",
"Fehler beim Schreiben");
return false;
}
}//DataWrite
}//MSAccess
}//ESD_Eingangskontrollsystem
Die Methode DataWrite() wird verwendet, um in die Datenbank zu schreiben. In
einem try-Block wird versucht, in die Datenbank zu schreiben. War das Schreiben
erfolgreich, wird true zurückgegeben, falls das Schreiben nicht erfolgreich beendet
werden konnte, wird eine Exception ausgelöst und false zurückgegeben. Die
Verbindung zur Datenbank wird folgendermaßen aufgebaut. Zuerst wird ein
Connectionstring definiert:
Password= xxxxxxxxxxxxxxxx ";
Dieser connStr wird dem Verbindungsobjekt direkt als Argument mit übergeben.
OleDbConnection connection = new OleDbConnection(connStr);
Um jetzt die Verbindung zur Datenbank zu öffnen und auf die in ihr enthaltenen
Daten zugreifen zu können, muss noch die Methode Open() aufgerufen werden.
OleDbCommand command = new OleDbCommand(sql, connection);
command.ExecuteNonQuery();
connection.Close();
return true;
56
Wir erzeugen ein Datenbankobjekt command und schreiben mit der Methode
ExecuteNonQuery() die Daten in die Datenbank. Nach dem Schreiben wird die
Verbindung getrennt und true zurückgegben.
3.11.1.1 Methode DataAdapter
Um nicht ständig mit der Datenbank kommunizieren zu müssen, entschlossen wir
uns dazu, den OleDbDataAdapter zu verwenden. Der OleDbDataAdapter ist eine
Art Bindeglied zwischen der Datenquelle und dem lokalen Speicher. Er hat die
Fähigkeit, Daten aus einer Datenquelle abzufragen und diese dann in einer oder
mehrerer Tabellen lokal abzulegen. Um die Auslastung so gering wie möglich zu
halten, baut der OleDbDataAdapter nur dann eine Verbindung zur Datenbank auf,
wenn es unbedingt notwendig ist. Sind die Operationen abgeschlossen, wird die
Verbindung sofort wieder beendet.
Die folgende Methode liest die Daten aus der Datenbank mittels eines
OleDbDataAdapter. Übergeben wird dabei die Variable string sql, welche den
SQL-Datenbankbefehl beinhaltet.
//---------------Mehtoden---------------/// <summary>
/// Ließt Daten aus der Datenbank mittels Data Adapter
/// Bei einem Fehler gibt diese Methode null zurück
/// </summary>
/// <param name="sql">SQL Befehl</param>
public DataTable DataAdapter(string sql)
{
try
{
Password= xxxxxxxxxxxxxxxx";
Natürlich wird auch beim OleDbDataAdapter ein Connectionstring zum Aufbauen
einer Verbindung benötigt.
if (!File.Exists(database))
{
throw new DatabaseException("Die Datenbank existiert
nicht!", "test");
}
57
Mit File.Exists(database) wird kontrolliert, ob das File existiert, sollte das nicht
der Fall sein, wird hier eine DatabaseException geworfen, die einen misslingenden
Verbindungsaufbau verhindert. Mit
OleDbDataAdapter adapter = new OleDbDataAdapter(sql,connStr);
wird
das
OleDbDataAdapter–Objekt
Datenbankbefehl sql
erzeugt.
Außerdem
wird
der
SQL-
und das Verbindungsobjekt connStr übergeben.
Jetzt
erzeugen wir noch ein DataSet, in dem die Daten vorübergehend gespeichert
werden.
DataSet ds = new DataSet();
adapter.Fill(ds);
Gegenüber der normalen Datenbankverbindung entfällt hier das Öffnen, da das der
DataAdapter selbständig macht. Die Methode Fill(ds) füllt die Tabelle ds mit den
Daten aus der Tabelle in der Datenbank..
return ds.Tables[0];
Im Falle eines auftretenden Laufzeitfehlers gibt es auch hier wieder Exceptions, die
bei Auftreten eines Fehlers den Vorgang ohne Programmabsturz beenden.
}
catch (OleDbException e) {
MessageBox.Show(e.Message.ToString(),"OleDbException");
return null;
}catch (Exception e)
{
MessageBox.Show(e.Message.ToString(),"Exception");
return null;
}
}//DataAdapter
58
3.11.2 Klasse AccessData
Im Folgenden werden die Methoden aus der Klasse AccessData beschrieben und
erklärt. Die Klasse AccessData nimmt sich hauptsächlich die Klasse MSAccess als
Werkzeug.
class AccessData
{
private int user_id;
private DateTime datum;
private int count;
public AccessData()
{
}//Konstruktor
//Eigenschaften
public int User_Id
{
get { return user_id; }
set { user_id = value; }
}
public DateTime Datum
{
get { return datum; }
set { datum = value; }
}
public int Count {
get { return count; }
set { count = value; }
}
Hier setzten wir die Variable int user_id, was logischerweise der User-ID, also der
Nummer des Mitarbeiters im Salto-System entspricht. Weiters wird DateTime datum
und int count gesetzt, was einem DateTime, also einem Zeitobjekt, und einer
einfachen Zählvariable entspricht.
3.11.2.1 Userdaten abfragen
Beginnen wir mit der Methode GetUserData(), hier wird versucht, die Userdaten
aus der Datenbank zu lesen.
//Static Methoden
public static AccessData GetUserData(int _id_lock)
{
try
{
DateTime dtime = DateTime.Now;
59
//neues Datenbank objekt erstellen
MSAccess ms = new
//tabelle erstellen
DataTable table = new DataTable();
TimeSpan ts =
TimeSpan.FromSeconds(Properties.Settings.Default.ZeitESDPruefung+2);
Hier wird ein neues DateTime-Objekt dtime erstellt, welches die aktuelle Zeit
beinhaltet. Anschließend wird ein neues MSAccess-Objekt ms deklariert und diesem
der Datenbankpfad aus den Properties übergeben. Die Eigenschaften werden im
Kapitel 3.16.2 behandelt. Als nächstes wird ein neues DataTable-Objekt table und
ein TimeSpan-Objekt ts erstellt. Dem TimeSpan-Objekt wird die Zeit für die ESD-
Prüfung aus den Eigenschaften übergeben. Es werden hier 2 Sekunden addiert, da
es sich dabei um den Zeitunterschied zwischen Computer und Steuereinheit handelt.
DateTime time;
time = DateTime.Now;
DateTime timesql = time.Subtract(ts);
string sql = "SELECT dt_audit,id_lock,id_user FROM
tb_LockAuditTrail WHERE id_lock=" + _id_lock;
sql += " AND dt_Audit>#" + timesql.Month + "/" +
timesql.Day + "/" + timesql.Year + " " +
timesql.Hour + ":" + timesql.Minute + ":" +
timesql.Second + "#";
sql += " AND dt_Audit<#" + time.Month + "/" +time.Day + "/"
+ time.Year+ " " + time.Hour + ":" +time.Minute +
":" + time.Second + "#";
Hier wird wieder ein DateTime-Objekt timesql erstellt und darin die Zeit für die ESDPrüfung +2 subtrahiert von der aktuellen Zeit time gespeichert. Jetzt geht es darum,
den string sql zusammenzusetzen. Benötigt wird eine Abfrage der Userdaten.
SELECT dt_audit,id_lock,id_user ist der Teil, der bestimmt, was genau wir
abfragen wollen. In diesem Fall ist dt_audit das Datum und die Zeit, zu der eine
Anmeldung getätigt wurde, id_lock, also die Eingangsnummer und id_user, die
Mitarbeiternummer. FROM tb_ LockAuditTrail ist jener Teil, der bestimmt, aus
welcher Tabelle die Daten bezogen werden sollen. tb_ LockAuditTrail ist in
diesem Fall die abzufragende Tabelle.
Nun kommt der Teil, der die Bedingungen festlegt. WHERE id_lock=" + _id_lock
besagt, dass das id_lock in der Datenbank mit dem _id_lock, das der Methode
60
übergeben wurde, übereinstimmen muss. dt_Audit muss außerdem größer sein als
die Zeit aus dem DateTime-Objekt timesql. Da man das DateTime-Objekt hier aber
nicht einfach so übergeben kann, muss man es aufspalten und die einzelnen Daten
einzeln an Access übergeben. Nach dem letzten AND kommt dann die Bedingung,
dass dt_Audit kleiner als die Zeit im DateTime-Objekt time ist. Um keinen zu
langen String auf einmal zu haben, teilten wir den Befehl auf mehrere kürzere Strings
auf.
float zeit = Properties.Settings.Default.ZeitESDPruefung;
zeit -= 0.5F;
//Nicht unbedingt notwendig
DateTime con = DateTime.Now;
Thread.Sleep(500);
table = ms.DataAdapter(sql);
Wir erstellt eine neue Variable zeit und wiesen dieser aus den Eigenschaften die
Zeit für die ESD-Prüfung zu. Nun subtrahieren wir von dieser Zeit, die in Sekunden
angegeben wird, eine halbe Sekunde.
Nachdem wir danach das DateTime-Objekt con erzeugen blockieren wir den Thread
für 500 Millisekunden und füllen danach unsere Tabelle table mit dem
DataAdapter.
if (table.Rows.Count > 1)
{
return null;
Falls die Tabelle mehr als eine Reihe beinhaltet, wird sofort null zurückgegeben.
Die folgende Schleife wird solange durchlaufen, bis Daten eingelangt sind oder die
Zeit abgelaufen ist.
}else{
int i = 0;
while (0 == table.Rows.Count && i < (zeit / 0.25))
{
try
{
table = ms.DataAdapter(sql);
}
catch (DatabaseException e)
{
}
61
Falls nicht mehr als eine Reihe in der Tabelle vorhanden ist, kommen wir in den
else-Teil, wo eine while –Schleife solange durchläuft, solange die Reihen in der
Tabelle Null sind und i kleiner ist als die eingestellte Zeit für die ESD-Prüfung
dividiert durch 0.25. Die Variable i fungiert hier als Zählvariable und wird am Ende
eines jeden Durchlaufes inkrementiert. In einem try–Block wird versucht, die Tabelle
table
per
DataAdapter
zu
füllen.
Per
catch
wird
eine
mögliche
DatabaseException abgefangen. Eine Exception ist sinngemäß übersetzt eine
Ausnahme.
}
if (table.Rows.Count > 1)
{
return null;
}//if
i++;
Thread.Sleep(250);
}//else
Wenn mehr als eine Zeile in der Tabelle table ist, wird sofort null zurückgegeben.
Ansonst wird der Thread wieder für 250 Millisekunden blockiert, bevor die Schleife in
den nächsten Durchgang geht.
if (table.Rows.Count < 1) {
MessageBox.Show(DateTime.Now
.Subtract(con).ToString(),"rows<1");
return null;
}//if
Wenn die Schleife beendet wurde, weil die Zeit abgelaufen ist, wird die Tabelle leer
sein und die Methode gibt null zurück.
AccessData ad = new AccessData();
ad.User_Id =
Convert.ToInt32(((DataRow)table.Rows[0])["id_user"]);
ad.Datum =
(DateTime)(((DataRow)table.Rows[0])["dt_Audit"]);
ad.Count = table.Rows.Count;
return ad;
Jetzt wird ein neues AccessData-Objekt ad erzeugt. Danach werden den
Eigenschaften User_Id, Datum und Count die jeweiligen Werte aus der Tabelle
62
zugewiesen. Außerdem wird die User_Id aus der Tabelle geholt und per
Convert.ToInt32 zu einem Integer konvertiert. Table.Rows[0] beschreibt die erste
Zeile und id_user die Spalte, aus der die UserID geholt werden soll. Es wird dann
das Objekt ad per return zurück.
Im Folgenden gibt es für den Ausnahmefall noch eine allgemeine Exception, welche
ausgelöst eine MessageBox mit einer Fehlermeldung zeigt und null zurückgibt.
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(),"Fehler AccessData");
return null;
}
}//GetAccessData
Falls das System zum ersten Mal gestartet wird, werden mit der Methode
TabellenAnlegen() die zwei von uns benötigten Tabellen zur Salto-Datenbank
hinzugefügt.
Benötigt
werden
von
uns
die
Tabellen
tb_Eingaenge
und
tb_ESDfailed. In tb_Eingaenge speichern wir alle Daten, die wir für die einzelnen
Eingänge benötigen, wie zum Beispiel die ID des Eingangs, den Namen des
Eingangs, die IP des I/O Controllers und den Port des I/O Controllers.
Abbildung 20 Screenshot Acess tb_Eingaenge
In tb_ESDfailed werden die Daten gespeichert, die bei negativen Überprüfungen
mit dokumentiert werden. Gespeichert werden eine ID als Schlüssel, die UserID, das
Datum, die genaue Uhrzeit und die Eingangs-ID.
63
Abbildung 21 Screenshot Access tb_ESDfailed
3.11.2.2 Tabellen anlegen
public static void TabellenAnlegen()
{
try
{
MSAccess ms = new
Hier wird das neue MSAccess Objekt ms erstellt und dem sofort der Datenbankpfad
übergeben.
string sqlEingaenge = "CREATE TABLE tb_Eingaenge(id_lock
LONG PRIMARY KEY, EingangName STRING(50),
ControllerIP STRING(15), ControllerPort LONG)";
CREATE TABLE tb_Eingaenge ist der SQL-Befehl zum Erstellen der Tabelle tb
_Eingaenge. Erstellt wird die Tabelle dann mit den Spalten id_lock, EingangName,
64
ControllerIP und ControllerPort. id_lock wird als Primärschlüssel mit dem
Datentyp LONG erstellt, das entspricht einer Integerzahl mit 4Byte. ControllerIP
wird als string mit einer Länge von 15 Zeichen angelegt.
if (!ms.DataWrite(sqlEingaenge)) {
MessageBox.Show("Beim Schreiben in die Datenbank ist
ein Fehler aufgetreten!");
return;
}//if
Falls die SQL-Abfrage nicht funktioniert, wird hier ein Fehler ausgegeben und die
Methode beendet.
string sqlESDfailed = "CREATE TABLE tb_ESDfailed(ID COUNTER
PRIMARY KEY, UserID LONG, Datum DATETIME, LockID LONG)";
Dieser sql-Code soll die Tabelle tb_ESDfailed anlegen. Angelegt werden hier die
Spalten ID als COUNTER und PRIMARY KEY, was heißt, dass sich die ID selbständig
durchnummeriert und dadurch auch einen eindeutigen Schlüssel darstellt, UserID,
Datum als DATETIME, sprich Datum und Uhrzeit, und LockID.
if (!ms.DataWrite(sqlESDfailed)) {
MessageBox.Show("Beim Schreiben in die Datenbank ist
ein Fehler aufgetreten!");
return;
}//if
}catch(Exception e){
MessageBox.Show(e.Message.ToString());
}
}//TabellenAnlegen
3.11.2.3 Negative Identifizierungsversuche speichern
Die Methode WriteFailedData() soll die ungültigen Zutrittsversuche in die
Datenbank schreiben, übergeben werden der Methode die userid, das Datum und
die Eingangsnummer.
public static void WriteFailedData(int userid,DateTime date,int
_id_lock)
{
MSAccess ms = new
65
Es wird ein MSAccess-Objekt erzeugt und dem der Datenbankpfad übergeben.
string sql="INSERT INTO tb_ESDfailed (UserID,Datum,LockID)
VALUES ("+userid+",";
sql += "#" + date.Month + "/" + date.Day + "/" + date.Year + "
" + date.Hour + ":" +date.Minute + ":" +date.Second + "# ";
sql += "," + _id_lock + ")";
Da wir jetzt in die Datenbank schreiben wollen, verwenden wir INSERT INTO und
schreiben damit in die Tabelle tb_ESDfailed in die Spalten UserID, Datum,
LockID. Mit VALUES legen wir die Werte oder Daten fest, die gespeichert werden
sollen. In unserem Fall zuerst einmal userid, dann das aktuelle Datum und
abschließend _id_lock.
if (!ms.DataWrite(sql)) {
MessageBox.Show("Beim Schreiben in die Datenbank ist ein
Fehler aufgetreten!");
TabellenAnlegen();
}
Falls das Ausführen von DataWrite() nicht funktionieren sollte, falls also eine
Tabelle noch nicht besteht, werden hier mit TabellenAnlegen() die Tabellen
angelegt. Die Methode TabellenAnlegen() wurde im Kapitel 3.11.2.2 ausführlich
beschrieben.
}//WriteFailedData
}//AccessData
3.12 Dateiverwaltung
Die Klasse Dateiverwaltung ist für die Verwaltung der Bilder auf dem Server
zuständig. Die Kamera beim Eingang macht ein Bild, sobald jemand unbefugt die
EPA betritt. Diese Bilder werden am Server in einem lokalen Verzeichnis
abgespeichert. Da hier der Speicherplatz begrenzt ist, löscht das System ab einer
bestimmten Anzahl von Bildern immer das älteste. Die Methode DeleteData()
wird immer dann aufgerufen, wenn die Kamera ein Bild gemacht hat.
66
Abbildung 22 Hauptprogramm - Eigenschaften
In den Eigenschaften kann dem Programm das Zielverzeichnis der Kamera
angegeben werden. Die Kamera legt die Bilder standardmäßig unter C:\tmp ab.
Außerdem kann die maximale Anzahl der Bilder eingestellt werden.
class Dateiverwaltung
{
Thread dv;
public Dateiverwaltung() {
dv = new Thread(new ThreadStart(this.Run));
dv.Start();
}
Zu allererst wird ein neuer Thread dv definiert, welcher im Standardkonstruktor der
Klasse erzeugt und gestartet wird.
public void Run() {
DeleteData();
dv.Abort();
}
Die Methode Run()wird beim Threadstart aufgerufen und führt die Methode
DeleteData() aus. Nach dem Ausführen wird der Thread mit Abort() beendet.
67
public void DeleteData()
{
string pfad = Properties.Settings.Default.PicturesPfad;
DirectoryInfo di = new DirectoryInfo(@pfad);
DeleteData() ist die “Arbeitsmethode” in der Klasse Dateiverwaltung. In dieser
Methode werden wie beschrieben die Bilder gelöscht. Aber zuerst wird der string
pfad definiert. Dieser Pfad gibt an, wo sich die Bilder befinden. Dem definierten
string wird der Pfad aus den Properties zugewiesen. Die Klasse DirectoryInfo
stellt einige Methoden zum Arbeiten mit Verzeichnissen zur Verfügung. Neben
DirectoryInfo gibt es auch die Klasse Directory, wir haben uns jedoch für die
erstere
entschieden,
Zugriffsberechtigungen
da
die
bestehen.
Klasse
Und
Directory
nachdem
wir
immer
wissen,
überprüft,
dass
ob
diese
grundsätzlich bestehen entschieden wir uns für die ressourcensparsamere Variante.
Dem neuen DirectoryInfo Objekt di wird der Pfad übergeben.
//di.Exists überprüft, ob das Verzeichnis di existiert
if (di.Exists)
{
while(di.GetFiles().Length >
Properties.Settings.Default.MaxPictures)
{
In der if–Anweisung wird mit di.Exists überprüft, ob das Verzeichnis di existiert.
Falls das Verzeichnis existiert, wird eine while-Schleife ausgeführt, die mit
GetFiles() ein Array mit den Daten im ausgewähltem Verzeichnis di füllt und
dann die Anzahl der Dateien bestimmt. Ist die Anzahl der Dateien größer als der
erlaubte Wert, wird der Code ausgeführt. Die maximale Anzahl der Bilder wird aus
den Properties geladen.
//FileInfo-Objekt für das File-Array
FileInfo[] files = di.GetFiles();
//DateTime Objekt mit aktueller Zeit erzeugen
DateTime dtime = DateTime.Now;
string tempname = "";
foreach (FileInfo fi in files)
{
if (dtime > fi.CreationTime)
{
68
dtime = fi.CreationTime;
tempname = fi.Name.ToString();
}
}
}
}
//Zum Löschen neues FileInfo-Objekt erzeugen
//und den Pfad und Dateiname übergeben
FileInfo deletefile = new FileInfo(pfad+tempname);
deletefile.Delete();
FileInfo[] files erzeugt ein neues FileInfo-Objekt-Array files, dieses wird mit
den Daten aus dem Verzeichnis gefüllt. Um den genauen Zeitpunkt zu wissen,
brauchen wir ein DateTime-Objekt dtime, welches die genaue Zeit beinhaltet. Jetzt
definieren wir den string tempname, diesen brauchen wir, um uns den Dateinamen
des ältesten Bildes fürs Löschen zu merken. In einer foreach-Schleife werden jetzt
alle files durchgegangen und das älteste Bild wird bestimmt. In der if-Anweisung
wird beim ersten Schleifendurchlauf überprüft, ob die aktuelle Zeit dtime größer ist,
also ob die aktuelle Zeit weiter fortgeschritten ist als die Erstellzeit der ersten Datei.
Wenn dtime aktueller ist als die Erstellzeit der gerade überprüften Datei, wird das
Erstelldatum dtime zugewiesen, welches wir aus der Eigenschaft CreationTime
bekommen. Der Variable tempname wird der Name der behandelten Datei
zugewiesen. Den Dateinamen bekommen wir aus der Eigenschaft Name. Zum
Löschen der ältesten Datei erzeugen wir jetzt ein neues
FileInfo-Objekt
deletefile. Dem übergeben wir den genauen Pfad der Datei, der sich aus dem
Verzeichnispfad pfad und dem Dateinamen tempname zusammensetzt. Die Methode
Delete()löscht jetzt die älteste Datei tempname.
}
}
else
{
MessageBox.Show("Falsches Verzeichnis!");
}
Falls das Verzeichnis nicht existiert, wird eine MessageBox mit der Nachricht
„Falsches Verzeichnis!“ ausgegeben.
69
3.13 Die Benutzeroberfläche
Eine unserer wichtigsten Vorgaben war eine einfache und gut zu bedienende
Benutzeroberfläche. Wir haben also eine Oberfläche realisiert, auf der sich jeder
zurechtfinden sollte, der mit dem System zu tun hat. Da ein weiteres unserer Ziele
war das System erweiterbar zu machen, kann man in unserer Oberfläche alle zum
Ablauf notwendigen Daten eingeben. Außerdem muss man alle gespeicherten
Daten, also alle ungültigen Zutritte, über die Benutzeroberfläche abrufen können,
wofür wir ein Protokoll einbauten. Das Protokoll kann bis zu 12 Monate im
Nachhinein eingesehen und gedruckt werden.
3.13.1 Startbildschirm
Auf dem folgenden Bild sieht man die Programmoberfläche, wie sie direkt nach dem
Start aussieht. Wie man hier sieht, haben wir für die Navigation ein Menü verwendet,
mit dem man ziemlich einfach eine tolle Navigation erzeugen kann. Außerdem sieht
man auf den ersten Blick sofort, welche Eingänge aktiv sind und kommt zudem mit
einem Klick zu den Einstellungen der Eingänge.
70
Abbildung 23 Screenshot Hauptprogramm Übersichtsseite
3.13.2 Einstellungen mit Eigenschaften
Das Allererste, das man nach dem ersten Programmstart machen muss, ist die
Angabe
eines
Datenbankpfades.
Der
Datenbankpfad
wird
als
Eigenschaft
abgespeichert. Eigenschaften haben den Vorteil, dass sich das Programm die
gespeicherten Daten merkt, ohne eine externe Datei wie zum Beispiel eine
Datenbank oder andere Files verwenden zu müssen. Auf dem Bild unten sieht man
das Fenster Eigenschaften, hier kann der Benutzer seinen Datenbankpfad und das
gewünschte Zeitfenster für die ESD-Prüfung eingeben.
71
Abbildung 24 Screenshot Hauptprogramm Eigenschaften
Die Einstellungen erreicht man, indem man im Microsoft Visual Studio auf „Project“
„Programmname Properties…“ klickt. Wählt man hier dann „Settings“ aus, muss man
nur mehr die gewünschten Namen und Datentypen der Einstellungen eingeben und
schon sind sie im Programm verfügbar.
Abbildung 25 Einstellungen der Settings
72
Wenn man nach der Eingabe der Daten auf Speichern klickt, wird folgende Methode
ausgeführt.
}
private void btnSaveEinstellungen_Click(object sender, EventArgs e)
{
Properties.Settings.Default.Datenbankpfad = tbxDBPfad.Text;
Properties.Settings.Default.ZeitESDPruefung =
Convert.ToInt32(nudZeitESDPruefung.Value);
Properties.Settings.Default.UbergangszeitDKZLS =
Convert.ToInt32(nUDUebergangszeit.Value);
Properties.Settings.Default.UserControll =
cbusercontroll.Checked;
Properties.Settings.Default.PicturesPfad =
tbxPicturesPath.Text;
Properties.Settings.Default.MaxPictures =
Convert.ToInt32(numMaxAnzPics.Value);
Properties.Settings.Default.Save();
this.Close();
Properties.Settings.Default.Datenbankpfad
=
tbxDBPfad.Text
zum
Beispiel weist Properties.Settings.Default.Datenbankpfad den Wert in der
TextBox Datenbankpfad zu. Mit Properties.Settings.Default.Save() werden
dann alle zugewiesenen Eigenschaften gespeichert. this.Close() schließt nach
dem Speichern das Fenster.
3.13.3 Pfad aussuchen per OpenFileDialog
Da C# hier wieder einmal eine große Erleichterung bietet, haben wir uns auch
diesmal wieder dessen bedient. Diesmal handelt es sich um die Klasse
OpenFileDialog. Damit kann man wie auf dem Bild unten den Server nach Daten
durchsuchen.
73
Abbildung 26 Screenshot OpenFileDialog zur Datenbank Auswahl
Wenn man also „Suchen“ klickt, wird die folgende Methode ausgeführt.
private void btnDBPfadDurchsuchen_Click(object sender, EventArgs e)
{
//es lassen sich nur mdb Files öffnen
openfiledialogDBPfad.Filter = "mdb Files (*.mdb)|*.mdb";
openfiledialogDBPfad.InitialDirectory =
Properties.Settings.Default.Datenbankpfad;
openfiledialogDBPfad.FileName =
Properties.Settings.Default.Datenbankpfad;
openfiledialogDBPfad.ShowDialog();
tbxDBPfad.Text = openfiledialogDBPfad.FileName;
}//DBPfadDurchsuchen
Wenn
man
die
Eigenschaft
openfiledialogDBPfad.Filter
mit
"mdb
Files
(*.mdb)|*.mdb" festlegt, können nur .mdb-Files geöffnet werden. Ein .mdb-File ist
ein Datenbankfile. Weiters legen wir den Datenbankpfad fest und rufen per
ShowDialog() das Öffnen-Fenster auf. Der ausgewählte Datenbankpfad wird in die
Textbox tbxDBPfad gespeichert.
74
3.13.4 Menü mit MenuStrip
Das Navigationsmenü wurde von uns mit der Klasse MenuStrip, die C# bereitstellt,
erstellt.
Abbildung 27 Screenshot MenuStrip des Hauptprogramm
Auf dem obigen Bild sieht man, wie das Menü jetzt konkret aussieht. Wenn man jetzt
auf „Eingang hinzufügen“ klickt, löst man folgenden Code aus:
private void eingangHinzufügenToolStripMenuItem_Click(object
sender, EventArgs e)
{
Einganghinzufuegen add = new Einganghinzufuegen(eingang);
add.FormClosed += new FormClosedEventHandler(UpdateEingaenge);
add.Show();
}
Dieser Code öffnet ein Fenster, in dem man Eingänge hinzufügen kann.
75
Abbildung 28 Screenshot Hauptprogramm Eingang hinzufügen
Hier sieht man das Formular zum Anlegen eines neuen Eingangs. Um einen Eingang
anlegen zu können, braucht man die IP-Adresse des I/O Controllers. Man muss
diesen also vorher richtig konfigurieren, um hier fortfahren zu können. Grundsätzlich
kann jeder Eingang, der sich in der Datenbank befindet, also jeder Eingang in der
kompletten Firma, für ein ESD-Kontrollsystem verwendet werden. Sinnvoll ist das
natürlich nur bei den Eingängen zum Produktionsbereich. Das Programm kontrolliert
außerdem die eingegebene IP-Adresse auf Gültigkeit. Diese Klasse ist jedoch freier
Code und wurde nicht von uns programmiert.
3.13.5 Das Protokoll
Im Protokoll kann man sich die fehlgeschlagenen Zutrittsversuche über eine
Zeitspanne von 2 Tagen bis zu 12 Monaten anzeigen lassen. Mit einem Klick auf das
Drucksymbol wird eine Druckvorschau erstellt.
76
Abbildung 29 Screenshot Hauptprogramm Fehlerprotokoll
Abbildung 30 Screenshot Hauptprogramm Druckansicht des Fehlerprotokolls
3.14 Konstruktive Tätigkeiten
Für den Zugang waren auch kleine konstruktive Tätigkeiten notwendig, so brauchten
wir zum Beispiel eine Halterung für das Prüfgerät, das Identifizierungsgerät und die
Signalleuchten, eine Blechbox für alle anderen Geräte und eine Halterung für die
77
Lichtschranken.
Die Konstruktionen wurden in der HTL-Werkstätte gefertigt und pulverbeschichtet.
3.14.1 Lichtschrankenhalterung
Die Lichtschrankenhalterung hat die Aufgabe, die Lichtschranken in einer
festgelegten Höhe und mit variablem Abstand zu halten. Die beiden Halter sind in
einer Nut geführt und somit verstellbar. Die Kabel werden durch die Formrohre
geführt und sind deshalb von außen nicht sichtbar. Die Lichtschrankenhalterung
kann an beiden Seiten des Drehkreuzes befestigt werden, so wurde die Flexibilität
der Konstruktion noch einmal erhöht.
Abbildung 31 Screenshot Catia – Lichtschrankenhalterung
78
3.14.2 Gerätebox
In dieser Gerätebox werden alle zur Steuerung nötigen Geräte aufbewahrt. Da wir
einige Geräte benötigen und ziemlich viel verkabelt wurde, ist eine Box die
wahrscheinlich beste Lösung. Die Gerätebox musste versperrbar sein und die
Klappe aus Platzgründen nach oben aufgehen.
Abbildung 32 Screenshot Catia - Gerätebox
3.14.3 Gerätehalterung
Die
Gerätehalterung
wurde
notwendig,
um
das
ESD-Prüfgerät
und
das
Identifikationsgerät von Salto in einer für den Mitarbeiter angenehmen Höhe
montieren zu können. Weiters werden auf der Gerätehalterung die Signallampen
befestigt.
79
Abbildung 33 Screenshot Catia - Gerätehalterung
Abbildung 34 Screenshot Catia - Gerätehalterung
80
3.15 Schwenktür
Um auch Rollstuhlfahrern den Zutritt zu ermöglichen und außerdem die Möglichkeit
zu erhalten, größere Gegenstände in die EPA zu transportieren, sollte eine
Schwenktür zugekauft werden. Wir holten uns von der Firma Stadlmayr
Verkehrssysteme in Unterpilsbach bei Vöcklabruck ein Angebot über eine solche
Schwenktür ein. Diese Schwenktür kann über einen digitalen Eingang angesteuert
werden und somit durch unseren I/O Controller bedient werden.
Abbildung 35 Schwenktür vom Typ Ikarus 11
11
http://www.stadlmayr.at/personensperre_ikarus.htm
81
4 Gesamtaufbau
Abbildung 36 Gesamtaufbau
Dies ist eine vereinfachte Darstellung des Gesamtaufbaus unseres Systems. Da wir
als Bussystem Ethernet verwenden, konnten die Geräte, die über Ethernet arbeiten
(dargestellt durch die roten Linien), leicht in das System integriert werden. Etwas
anders
sieht
es
bei
den
Komponenten
aus,
die
über
keinen
direkten
Netzwerkanschluss verfügen (dargestellt durch die gelben Linien). Diese werden mit
dem I/O Controller in das Netzwerk integriert. Zum Betätigen des Drehkreuzes und
der Netzwerkkamera und zum Betreiben der LEDs sind Relais erforderlich, diese
mussten zusätzlich gebaut werden. Die 12V-LEDs werden durch die vom
Spannungsteiler geteilte 24V-Versorgung des Drehkreuzes betrieben.
82
4.1 Gesamtschaltung
Abbildung 37 Gesamtschaltung
83
Oben sieht man den Schaltplan des Gesamtaufbaus, für alle Geräte, die per
digitalem Signal mit dem I/O Controller kommunizieren. Der I/O Controller befindet
sich im Zentrum der Geräte, der Controller bildet das Bindeglied zum Netzwerk. Der
I/O Controller erhält durch die Inputs die benötigten Informationen und gibt die
Befehle durch die Outputs an die einzelnen Geräte weiter. An den Inputs sind das
PGT und die zwei Lichtschranken angeschlossen. An den Outputs befinden sich die
Relais des Drehkreuzes, der LEDs und der Netzwerkkamera. Das Erdungsprüfgerät
(PGT100) ist an den Inputs I.7 und I.6 angeschlossen. Es schließt den Kontakt
zwischen dem PWR-Anschluss (Power) mit dem I.7 bei einer positiven oder mit dem
I.6 bei einer negativen ESD-Prüfung. Die Lichtschranken funktionieren genauso und
schließen den Kontakt bei einem Durchtritt. Die Lichtschranken werden mit der 24VVersorgung des Drehkreuzes betrieben. Alle Relais in der Schaltung arbeiten mit
einer Spannung von 24V, die direkt von der Platine des Drehkreuzes kommen. Die
Relais werden mit dem I/O Controller betätigt. Auf der Platine des Drehkreuzes ist
der IN2-A und der IN1-B mit dem GND (ground) und der IN1-A durch einen Öffner
mit den 24V verbunden. Dies dient nur zur Festlegung der Drehrichtung des
Drehkreuzes. Das Relais-DKZ schließt den Kontakt zwischen den 24V und den IN2B, um das Drehkreuz für einen Durchgang freizugeben. Der Spannungsteiler teilt die
24V-Betriebsspannung des Drehkreuzes und stellt damit die Hauptversorgung der
12V-LEDs her. Die LEDs leuchten nur dann, wenn das Relais den Stromkreis
schließt. Die beiden LEDs funktionieren nach demselben Prinzip. Das Relais der
Netzwerkkamera schließt zum Auslösen nur einen Kontakt (ähnlich wie beim
Drehkreuz). Das Relais des Drehkreuzes ist im Gegensatz zu den restlichen Relais
anders aufgebaut.
Die Input-Belegung des I/O Controllers:
84
Input
Gerät
Gerät/Beschreibung
7 (I.7)
PGT
ESD-Prüfung positiv
6 (I.6)
PGT
ESD-Prüfung negativ
5 (I.5)
Lichtschranke
Lichtschranke 2 aktiv
4 (I.4)
Lichtschranke
Lichtschranke 1 aktiv
Die Output-Belegung des I/O Controllers:
Output
Gerät
Gerät/Beschreibung
0 (O.0)
Relais-DKZ
Drehkreuz-Freigabe
1 (O.1)
Relais-ALG
NetzwerkkameraAuslöser
2 (O.2)
Relais-ALG
Rote LED
3 (O.3)
Relais-ALG
Grüne LED
4.2 Schaltung Relais-DKZ
Abbildung 38 Schaltung DKZ
Die Relais sind nur vorhanden, da der I/O Controller die benötigte Spannung zum
Steuern der Geräte nicht aufbringen kann. An den Outputs haben wir nur eine
Ausgangsspannung von 0,6 Volt gemessen. Dies war zu wenig, um die Geräte zu
betreiben. Deshalb haben wir uns an unsere Betreuer gewendet und gemeinsam
eine Schaltung entworfen. Mithilfe eines Optokopplers (4) reichen die 0,6V aus, um
ein
Relais
zu
betätigen.
Das
Relais
(8)
nimmt
die
Spannung
vom
Festspannungsregler (5). Das Relais schließt hier einen 24V Kontakt.
85
4.3 Schaltung Relais-Allgemein
Abbildung 39 Schaltung allgemein
Der Unterschied zum Relais-DKZ ist, dass ein 24V Relais (9) statt einem 5V Relais
(8) verwendet wird und hier ein potentialfreier Kontakt geschlossen wird.
4.4 Stückliste für alle 4 Relais
86
Position
Name
Bezeichnung
Anzahl
1
Widerstand
820
4
2
Widerstand
47
4
3
Widerstand
510
4
4
Optokoppler
SFH6156
4
5
Festspannungsregler
7805
1
6
Transistor
BC546
4
7
Diode
BAS32
4
8
Relais
5V
1
9
Relais
24V
3
4.5 Spannungsteiler (DC/DC-Wandler)
Abbildung 40 Spannungsteiler
Der Spannungsteiler dient nur zur Umwandlung der Spannung für die LEDs und
bezieht eine Spannung von 24 Volt vom Drehkreuz.
87
4.6 Bilder zum Aufbau
Abbildung 41 Aufbau der Geräte
Abbildung 42 Drehkreuz
Abbildung 43 PGT und WRM2000
Abbildung 44 Platine vom Drehkreuz
88
Abbildung 45 Eingangsbereich
Abbildung 46 Netzwerkkamera
Abbildung 47 Drehkreuzbereich
Abbildung 48 Testdurchläufe
89
5 Installationsanleitung
5.1 Ersten Eingang anlegen
Sollten bereits Eingänge angelegt sein, können Sie diesen Schritt überspringen.
Installieren Sie, bevor Sie weiter gehen, die hier aufgelisteten Programme:
-
Sollte kein MS-Access installiert sein, oder es sich um eine alte Version
handeln, installieren Sie bitte den beiliegenden MS-Office-Treiber
Salto RW Pro-Access
5.2 Tür anlegen im RW Pro-Access von Salto
1.
2.
3.
4.
Öffnen Sie das RW Pro-Access von Salto.
Klicken Sie auf den Menüpunkt „Türen“.
In dem geöffneten Fester klicken sie auf „Neu“.
Geben Sie hier den Türnamen ein, und setzen sie den Öffnungsmodus auf
„Drückergesteuert (DÖ)“.
5. Sollte bei „Is online“ kein Häkchen sein, bitte jetzt anhaken.
6. Setzen Sie die „Freigabezeit“ und die „verlängerte Freigabezeit“ auf 1 Sek.
7. Anschließend speichern Sie.
8. Jetzt klicken Sie auf „Verbindung konfigurieren“.
9. Geben sie hier eine IP-Adresse ein.
- Die IP-Adresse muss vom Netzwerkadministrator vergeben werden!
10. Drücken Sie jetzt wieder „Speichern“.
11. Drücken Sie in der Steuereinheit auf den „CLR“ Knopf, bis die Led daneben
blinkt.
12. Drücken Sie jetzt „Adressieren“.
13. Drücken Sie auf „Scan Ein“ und anschließend „Schließen“.
14. Sie befinden sich jetzt wieder im „Tür“ Menü.
15. Klicken Sie auf „Tür updaten“ und anschließend auf „Schließen“.
Hinweis:
-
RW Pro-Access muss immer im Hintergrund laufen.
Es kann teilweise länger dauern, bis Einstellungen übernommen
werden.
16. Jetzt, wie vom RW Pro-Access gewohnt, die Benutzer oder Benutzergruppen
zuweisen.
90
5.3 I/O Controller konfigurieren
1. Verbinden Sie den I/O Controller per seriellem Kabel mit dem PC
2. Der Dipschalter 1 muss auf „ON“ und der Dipschalter 2 muss auf „OFF“
gestellt sein
3. Gehen Sie auf „Start“ „Programme“ „Zubehör“ „HyperTerminal“ und wählen
Sie dieses aus.
4. Beliebigen Namen eingeben und „Weiter“ drücken.
5. Bei „Connect using“ den richtigen COM-Port Port auswählen.
6. Jetzt bei den Eigenschaften Folgendes ändern:
- Bits/s auf 9600
- Datenbits auf 8
- Parität auf keine
- Stoppbits auf 1
- Flusssteuerung auf kein
7. Klicken Sie auf „Übernehmen“ und dann auf „OK“.
8. Klicken Sie jetzt auf „File“ „Properties“ „Settings“ „ASCII Setup“ und wählen
Sie hier folgende Einstellungen:
Abbildung 49 Screenshot ASCII Setup des HyperTerminal
9. Jetzt zweimal „OK“ klicken, um zurück zum HyperTerminal zu kommen.
10. I/O Controller zurücksetzen (die Verbindung zum Stromnetz trennen).
11. Drücken Sie jetzt „Enter“, um Informationen vom I/O Controller zu
bekommen.
12. Ändern Sie IP Adresse, Port, Mask, Gateway auf die gewünschten Werte.
Geben Sie dazu den Buchstaben, der vor der jeweiligen Einstellung steht,
an und gleich danach den neuen Wert. Für eine neue IP-Adresse z.B.:
I192.168.1.51
- Die Netzwerkeinstellungen müssen vom Netzwerkadministrator
getätigt werden!
91
Abbildung 50 Screenshot I/O Controller-Einstellungen mit dem HyperTeminal
92
13. Ändern Sie jetzt „Send to IP“ und „Server Port“ auf die IP-Adresse und die
IP des Servers auf dem „ESD-Eingangskontrollsystem“ und „RW ProAccess“.
14. Speichern Sie jetzt die Einstellungen, dazu geben Sie „D2“ ein und
drücken Sie „Enter“.
15. I/O Controller zurücksetzen (die Verbindung zum Stromnetz trennen),
beide Dipschalter auf „Off“ setzen und Verbindung zum Stromnetz wieder
herstellen.
5.4 Einstellungen im Programm
1. Öffnen Sie das Programm „ESD-Eingangskontrollsystem“.
2. Damit das Programm arbeiten kann, müssen Sie den Pfad zur Datenbank
angeben. Dazu klicken Sie auf „Einstellungen“ und dann auf „Suchen“.
Jetzt einfach die richtige .mdb-Datei auswählen.
Abbildung 51 Screenshot Hauptprogramm Einstellungen Eigenschaften
3. Weiters kann man in diesem Fenster die Zeitdauer für die ESD-Prüfung
festlegen, diese Dauer beschreibt die Zeitspanne zwischen Registrierung
und ESD-Prüfung und sollte auf 5 Sekunden gesetzt werden.
4. Bei „Übergangszeit DKZ-Lichtschranken“ können Sie die Zeit, die
zwischen Schalten des Drehkreuzes und Aktivieren der Lichtschranken
verstreichen darf.
5. Wenn Sie „nur ESD-Kontrolle“ anhaken, wird die Personenidentifizierung
abgeschaltet.
6. Im Programm „ESD-Eingangskontrollsystem“ gehen Sie jetzt zu
„Eingänge/Eingang“ hinzufügen und suchen sich den gewünschten
Eingang aus. Wenn ein Eingang ausgewählt wurde, muss rechts noch die
IP-Adresse und der Port angegeben werden. Die Portnummer ist vom
Netzwerkadministrator vorgegeben.
93
6 Validierung
6.1 Idealablauf
t….Istzeit
x…Vorgabe
Menschenbewegung:
WRM 2000
PGT100
DKZ 370
EPA
Datenbewegung:
ID, Zeit
WRM 2000
Datenbank
Daten zur ID
t <x
PGT100
Programm
JA
DKZ 370
JA
Abbildung 52 Validierung/Idealablauf
Ein Mitarbeiter meldet sich ordnungsgemäß an und darf das Drehkreuz passieren.
6.2 Ungültige ESD-Prüfung
Menschenbewegung:
WRM 2000
PGT100
Neu anmelden
Datenbewegung:
ID
WRM 2000
Datenbank
Daten zur ID, Zeit
t <x
PGT100
NEIN
Programm
Eintrag
Abbildung 53 Validierung/Ungültige ESD-Prüfung
Der Mitarbeiter meldet sich an, doch die ESD Prüfung war nicht positiv.
94
6.3 Zeitüberschreitung
Menschenbewegung:
WRM 2000
PGT100
Neu anmelden
Datenbewegung:
ID/Zeit
WRM 2000
Datenbank
Daten zur ID, Zeit
t >x
PGT100
Rechner
JA/NEIN
Abbildung 54 Validierung/Zeitüberschreitung
Ein Mitarbeiter meldet sich an, doch er überschreitet die Vorgabezeit.
6.4 Alarmauslösung
Menschenbewegung:
Außenbereich
EPA
Bild
Datenbewegung:
IDEC
Alarm
Rechner
IPcam
Auslösen
Abbildung 55 Validierung/Alarmauslösung
Ein Mitarbeiter versucht, den Produktionsbereich ohne Anmeldung zu passieren.
95
7 Persönliche Erfahrungen und
Wertschöpfung
Das Projekt zeigte uns sehr gut, dass es nicht so einfach ist, ein Projekt zu leiten, zu
planen und durchzuführen. Besonders die Verteilung der menschlichen Ressourcen,
also der Arbeitszeit, war nicht immer einfach. So
war es vor allem in der
Praktikumszeit nicht immer leicht, eine ideale Arbeitsteilung durchzuführen. Es hatten
zwar alle immer etwas zu tun, jedoch hätte man die Arbeit mit Sicherheit besser
verteilen und somit auch die Zeit intensiver nutzen können.
Grundsätzlich muss man sagen, dass uns das Projekt mit Sicherheit auch einiges an
Erfahrung zur Problemlösung gebracht hat. So mussten wir zum Beispiel, nachdem
der I/O Controller kaputt wurde, sofort für Ersatz sorgen. Im Laufe der Arbeit gab es
außerdem sonst noch einige Entscheidungen, die uns von der Firma übertragen
wurden. Hier muss man sagen, dass wir in vielen Dingen, wie zum Beispiel bei der
Anschaffung von neuen Geräten oder der Lösung von Problemen, selbst agieren
durften/mussten und wir somit unser Projekt selbstständig ausführten.
Vor allem die Beschaffung von Informationen beanspruchte viel Zeit. Wir mussten
einige Geräte anschaffen, die idealerweise leicht in das System zu integrieren und
dadurch, mit unseren speziellen Anforderungen, oft schwer am Markt zu finden
waren. Es war auch nicht immer einfach, den zuständigen Personen unsere
Vorhaben und Ideen nahezubringen. So haben wir sicher Erfahrung gewonnen,
anderen oft technisch nicht versierten Menschen technische Sachverhalte näher zu
bringen.
Wir bedanken uns für die gute Zusammenarbeit und die Möglichkeit, einen Teil der
Arbeit während eines Praktikums zu erarbeiten.
Das Projekt war für uns bis jetzt ein großer Erfolg und wir denken, dass wir es wieder
machen
96
würden,
trotz
des
überdurchschnittlich
großen
Arbeitsaufwandes.
8 Besprechungsprotokolle
8.1 Erste Besprechung
Protokoll
1.Treffen bei Allied Panels, am Mittwoch 10.01.2008 von 8:00 bis 8:30
Teilnehmer: Schuster, Schobesberger, Keskin
Prof. Opelt
Besprechung
Bei dieser Besprechung wurde uns das ESD-Problem der Firma näher gebracht. Es
wurde uns genau erklärt, was ESD bedeutet und wie man es verhindern kann. Im
Anschluss wurde nur geklärt, ob wir dieses Projekt realisieren möchten. Dieses
Treffen war der Projektbeginn.
97
8.2 Zweite Besprechung
Protokoll
2.Treffen bei Allied Panels, am Mittwoch 21.05.2008 von 8:00 bis 8:45
Teilnehmer: Schuster, Schobesberger
Prof. Opelt
Besprechung des Fragenkatalogs zum Pflichtenheft
Frage 1: Die Zeitdauer sollte im Administrationspanel einstellbar sein und
anfangs 30 Sekunden betragen.
Frage 2: Wie Frage 1, jedoch mit 10 Sekunden.
Frage 3: Wann das Testsystem zur Verfügung steht, ist noch nicht ganz
sicher, die Firma wird die Geräte jedoch so bald als möglich bereitstellen.
Frage 4: Es ist noch nicht ganz sicher, ob das hauseigene Kamerasystem
verwendet werden soll. Bei diesem System währen noch zwei Anschlüsse
vorhanden.
Frage 5: Die Klapptür muss mindestens 90cm breit sein. Die Firma würde sich
über einen Vorschlag vom Projektteam freuen.
Frage 6: Welche Software auf dem Server läuft, war zum Zeitpunkt der
Besprechung nicht bekannt. Die Software inklusive Datenbank liegt am
hauseigenen Server.
Änderungen durch die Besprechung
98
•
Es sind nur noch zwei Eingänge zu realisieren.
•
Die Identifizierung der Mitarbeiter erfolgt über einen extra
Identifikationsschlüssel, auf dem die Rechte des Mitarbeiters gespeichert sind.
In einer Datenbank wird mitgeschrieben, wer sich wann und wo Zutritt
verschafft hat.
•
Weiters kamen wir zur Erkenntnis, dass wir außer der Montage mit dem
TRS15 und der SAP-Datenbank nichts zu tun haben werden.
9 Geräteverzeichnis
9.1 I/O Controller
Abbildung 56 I/O Controller 12
Der I/O Controller besitzt digitale Einund Ausgänge. Er dient als Schnittstelle
zwischen dem Rechner und den
Geräten. Mithilfe des I/O Controllers
werden die Informationen vom PGT und
von den Lichtschranken verarbeitet und
die entsprechenden Befehle an das
Drehkreuz und an die Alarmvorrichtung
weitergeleitet.
9.2 PGT100 ESD-Prüfgerät
Das ESD- Prüfgerät gibt nach einer
Prüfung über den Türöffner/ZählerAusgang digitale Signale für „OK“ und
„Failed“ aus.
Abbildung 57 ESD-Prüfgerät 13
9.3 SkiData Drehkreuz DKZ 350
Das Drehkreuz ist der Durchgang zum
ESD-geschützten
Produktionsbereich.
Dieses wird nach erfolgreicher ESDPrüfung und Anmeldung des Mitarbeiters
entriegelt. In der Gegenrichtung soll es
immer passierbar sein (Fluchtweg).
Abbildung 58 Drehkreuz
12
13
IO_Controller_PL_MAN_en.pdf
pgt100_user_manual.pdf
99
9.4 IDEC Reflexlichtschranke
Die
Lichtschranken
dienen
zum
Aktivieren
des
Sicherheitssystems,
welches bei einem unerlaubten Übertritt
der Absperrung zum Einsatz kommt.
Abbildung 59 Lichtschranke 14
9.5 Identifikationshardware Salto
Abbildung 60 Lesegerät
15
Das
Salto
WRM2000
ist
die
Identifikationskontrolle und das Salto
CU50EN ist die Steuereinheit dafür. Die
Identifikationskontrolle
dient
zum
Erfassen der Daten der Person, die den
Durchgang
passieren
will.
Jeder
Mitarbeiter hat einen iButton, auf dem die
Zugangsberechtigungen
gespeichert
werden.
9.6 Netzwerkkamera Plustek IPcam P1000
Die Kamera ist eine zusätzliche
Sicherheitseinrichtung und dient zum
Überwachen der Eingänge, um bei
einem
unbefugten
Zutritt
Bilder
aufzuzeichnen.
Abbildung 61 Netzwerkkamera 16
14
http://www1.conrad.de
http://www.salto.us/index.php?option=com_content&task=view&id=1&Itemid=34
16
http://www.plustek.de/web/product/p1000.php
15
100
10 Softwareverzeichnis
10.1 Microsoft Visual Studio
Entwicklungssoftware für Programme,
Applikationen
und
andere
Programmierarbeiten
auf
Microsoft
Windows Basis. Im Projekt wird die
Programmiersprache
C#
(Csharp)
verwendet.
Abbildung 62 Microsoft Visial Studio 17
10.2 Microsoft Office Access 2007
Software von Microsoft zum Erstellen
und Verwalten von Datenbanken auf
Microsoft Windows Basis.
Abbildung 63 Microsoft Office Access 18
10.3 Microsoft Office Word 2007
Software von Microsoft zum Erstellen
und Bearbeiten von Dokumenten auf
Microsoft
Windows
Basis.
Diese
Diplomarbeit wurde mit Microsoft Word
2007 erstellt.
Abbildung 64 Microsoft Office Word 19
17
(http://www.publicvoid.dk/content/binary/WindowsLiveWriter/SortingtheVisualStudioAddNewItemDial
og_E517/VisualStudioLogo_3.gif)
18
http://www.paltechsolutions.com/images/Access_Logo.png
19
http://www.vista4beginners.com/files/logo/word2007_logo.jpg
101
10.4 Salto RW Pro-Access Connected
Software der Firma Salto für die
Verwaltung der Datenbank, in der unter
anderem
die
Türen,
Mitarbeiter,
Zugriffsrechte und andere Faktoren
verwaltet werden.
Abbildung 65 RW Pro-Access 20
10.5 Hercules by HW-Group
Diese Software wird zum Konfigurieren
von Ethernet/RS232 Convertern und von
ähnlichen Geräten der HW-Group
verwendet.
Abbildung 66 Hercules by HW-Group 21
10.6 SFC-Editor
Mit
diesem
Editor
wurden
Programmablaufpläne erstellt.
die
Abbildung 67 SFC Editor 22
20
http://www.iscwest.com/images/ 180/2008_Product_Training_Logos/ Salto_LOGO.GIF
http://www.hw-group.com
22
http://watts.cs.sonoma.edu/SFC/index.html
21
102
11 Anhänge
11.1 Dokumentations-CD
•
Beschreibungen
o TRS_15.pdf
o pgt100_user_manual.pdf
o IO_Controller_PL_MAN_en.pdf
o dkz350-1-0-de-man_1.pdf
o Esd_Buch.pdf
o ESDSchulung.pdf
•
Quellcode
•
Visualisierung.swf
•
Dokumentation.pdf
•
Bilder
•
Software
o Plustek IPcam
o Hercules.exe
o ESD-Zutrittskontrollsystem.exe
o MS-Access-Treiber
103
11.2 Klassendiagramm
Abbildung 68 Visual Studio - Klassendiagramm
104
Dieses Diagramm zeigt eine Klassenübersicht, der selbst erstellten Klassen, im
Programm. Einige Klassen sind abgeleitet, wie zum Beispiel die Klasse
ZeigeEingaenge, diese ist von der Klasse Panel abgeleitet und dient zum
Darstellen der Eingangsinformation.
105
12 Abbildungsverzeichnis
Abbildung 1 ESD-Symbol .......................................................................................... 8
Abbildung 2 EPA-Symbol .......................................................................................... 8
Abbildung 3 ESD-Drehstuhl ..................................................................................... 10
Abbildung 4 ESD-Arbeitsplatz ................................................................................. 11
Abbildung 5 Geplanter Ablauf ................................................................................... 17
Abbildung 6 Screenshot Gantdiagramm des Istablaufs (MSProject) ........................ 18
Abbildung 7 Zeitaufstellung der Arbeitsstunden ....................................................... 19
Abbildung 8 TRS15-Zeiterfassungsterminal ............................................................ 21
Abbildung 9 PGT-Anschlussplan .............................................................................. 22
Abbildung 10 Versuchsaufbau .................................................................................. 23
Abbildung 11 Leseeinheit WRM2000 ....................................................................... 28
Abbildung 12 Steuereinheit CU50EN ...................................................................... 28
Abbildung 13 Screenshot RW Pro-Access Salto-Verwaltungsprogramm ................. 28
Abbildung 14 Screenshot Hercules Setup ulility ....................................................... 38
Abbildung 15 Screenshot TCP-Client Testprogramm ............................................... 42
Abbildung 16 Screenshot Protokoll der fehlerhaften Eintrittsversuche ..................... 46
Abbildung 17 Prüfzeitzerlegung ................................................................................ 49
Abbildung 18 SFC - Programmablaufplan der Prüfungsmethode 1 .......................... 52
Abbildung 19 SFC - Programmablaufplan der Prüfmethode 2.................................. 53
Abbildung 20 Screenshot Acess tb_Eingaenge ........................................................ 63
Abbildung 21 Screenshot Access tb_ESDfailed ....................................................... 64
Abbildung 22 Hauptprogramm - Eigenschaften ........................................................ 67
Abbildung 23 Screenshot Hauptprogramm Übersichtsseite ..................................... 71
Abbildung 24 Screenshot Hauptprogramm Eigenschaften ....................................... 72
Abbildung 25 Einstellungen der Settings .................................................................. 72
Abbildung 26 Screenshot OpenFileDialog zur Datenbank Auswahl ........................ 74
Abbildung 27 Screenshot MenuStrip des Hauptprogramm ....................................... 75
Abbildung 28 Screenshot Hauptprogramm Eingang hinzufügen .............................. 76
Abbildung 29 Screenshot Hauptprogramm Fehlerprotokoll ...................................... 77
Abbildung 30 Screenshot Hauptprogramm Druckansicht des Fehlerprotokolls ........ 77
106
Abbildung 31 Screenshot Catia – Lichtschrankenhalterung ..................................... 78
Abbildung 32 Screenshot Catia - Gerätebox ............................................................ 79
Abbildung 33 Screenshot Catia - Gerätehalterung ................................................... 80
Abbildung 34 Screenshot Catia - Gerätehalterung ................................................... 80
Abbildung 35 Schwenktür vom Typ Ikarus................................................................ 81
Abbildung 36 Gesamtaufbau .................................................................................... 82
Abbildung 37 Gesamtschaltung ................................................................................ 83
Abbildung 38 Schaltung DKZ.................................................................................... 85
Abbildung 39 Schaltung allgemein ........................................................................... 86
Abbildung 40 Spannungsteiler .................................................................................. 87
Abbildung 41 Aufbau der Geräte .............................................................................. 88
Abbildung 42 Drehkreuz ........................................................................................... 88
Abbildung 43 PGT und WRM2000 ........................................................................... 88
Abbildung 44 Platine vom Drehkreuz ....................................................................... 88
Abbildung 45 Eingangsbereich ................................................................................. 89
Abbildung 46 Netzwerkkamera ................................................................................. 89
Abbildung 47 Drehkreuzbereich ............................................................................... 89
Abbildung 48 Testdurchläufe .................................................................................... 89
Abbildung 49 Screenshot ASCII Setup des HyperTerminal ...................................... 91
Abbildung 50 Screenshot I/O Controller-Einstellungen mit dem HyperTeminal ........ 92
Abbildung 51 Screenshot Hauptprogramm Einstellungen Eigenschaften ................. 93
Abbildung 52 Validierung/Idealablauf ....................................................................... 94
Abbildung 53 Validierung/Ungültige ESD-Prüfung.................................................... 94
Abbildung 54 Validierung/Zeitüberschreitung ........................................................... 95
Abbildung 55 Validierung/Alarmauslösung ............................................................... 95
Abbildung 56 I/O Controller ...................................................................................... 99
Abbildung 57 ESD-Prüfgerät .................................................................................... 99
Abbildung 59 Drehkreuz ........................................................................................... 99
Abbildung 60 Lichtschranke.................................................................................... 100
Abbildung 61 Lesegerät ......................................................................................... 100
Abbildung 62 Netzwerkkamera ............................................................................... 100
Abbildung 63 Microsoft Visial Studio ...................................................................... 101
Abbildung 64 Microsoft Office Access .................................................................... 101
107
Abbildung 65 Microsoft Office Word ....................................................................... 101
Abbildung 66 RW Pro-Access ................................................................................ 102
Abbildung 67 Hercules by HW-Group ..................................................................... 102
Abbildung 68 SFC Editor ........................................................................................ 102
Abbildung 69 Visual Studio - Klassendiagramm ..................................................... 104
108

ESD Eingangskontrollsystem

Transcription

Similar documents

Bau Management Forum GmbH Gutachterliche Information Diese

Wieviel praktischen Nutzen haben aktuelle Lernprogramme?

Ausgabe 01/2009 - Honeywell Security Group

Konzeption einer Destination Card für die Südliche Weinstraße

Adrenalinwolke mit Vanilleduft