Projektbericht 796.8 KByte - Technikpreis

Technikpreis 2006 des VDE Rhein-Ruhr e. V.
Projektdokumentation
Bau und Entwicklung einer
Wettermessstation
mit Anbindung
ins Packet Radio Netz
Reinhold Bertram
St. Antonius Gymnasium, Lüdinghausen
Betreuer : Herr Dr. Ruttert
Eingereicht am : 7. Juni 2006

Danksagung
Ich danke besonders dem VDE Rhein-Ruhr e.V. für die finanzielle Unterstützung dieser
Arbeit.
Herrn Dipl. Ing. Thomas Aundrup gilt mein besonderer Dank für die engagierte Betreuung
meines Projekts.
Die schnellen Antworten und Hilfen haben mir sehr geholfen.
Außerdem gilt mein Dank meinem Bruder Clemens, sowie dem DARC OV Lüdinghausen.
Ohne ihre Hilfe wäre die Arbeit nicht so gut gelungen.

III
Inhaltsverzeichnis
Inhaltsverzeichnis
Danksagung
II
1 ”Und nun das Wetter” 1
2 Messwerterfassung 3
2.1 Allgemeines über die serielle Schnittstelle . . . . . . . . . . . . . . . . . . 3
2.2 Funktionsweise des TLC 549 . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.3 Multiplexer/Demultiplexer . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.4 Achtstufiger Binärzähler als Seriell/Parallel-Wandler . . . . . . . . . . . 5
3 Sensortechnik 6
3.1 Temperatursensor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3.2 Lichtsensor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.3 Feuchtesensor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.4 Drucksensor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
4 Software 13
4.1 Steuerung des A/D-Wandler über serielle Schnittstelle . . . . . . . . . . . 13
4.2 Steuerung des Analog-Multiplexer . . . . . . . . . . . . . . . . . . . . . . 14
4.3 Umwandlung der Spannungswerte in Wetterdaten . . . . . . . . . . . . . 14
4.4 Dokumentation der Messparameter . . . . . . . . . . . . . . . . . . . . . 15
5 Übertragung 16
5.1 Packet Radio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
5.2 Packet Radio Station . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
5.3 Terminalprogramm Paxon . . . . . . . . . . . . . . . . . . . . . . . . . . 17
5.4 Übertragung in eine Mailbox . . . . . . . . . . . . . . . . . . . . . . . . . 19
6 Schlussbetrachtung 20
7 Ausblick 22
Literatur 23
A Schaltpläne 25
B Fotos 28

IV
Inhaltsverzeichnis
C Stückliste 32
D Quellcode 34

1 1 ”Und nun das Wetter”
1 ”Und nun das Wetter”
Mit diesen Worten leiten Nachrichtensprecher zum vielleicht spannendsten Teil der Nachrichten,
der Wettervorschau für die nächsten Tage, über. Menschliches Handeln und Tun
ist massiv vom Wetter beeinflusst. Die Wahl der Kleidung, der Sportunterricht und die
Organisation der Grillparty am nächsten Samstag sind genauso vom Wetter abhängig
wie die Arbeit der Gärtner und Bauern. Die Bedeutung der Wettervorhersage für Sturm,
Hagel und Hochwasser für unser aller Wohl liegt klar auf der Hand.
Auslöser für die Entwicklung und den Bau einer lokalen Wetterstation ist ein Projekt
der Biologischen Station Lüdinghausen zur Wiederansiedlung von Wanderfledermäusen
in unserer Region. Eine Gruppe, die sich aus Ornithologen, Naturschützern, Biologen,
Gärtnern und Schülern zusammensetzt, hat im Biologischen Zentrum Lüdinghausen einen
Fledermausstollen gebaut, der den Tieren als Herberge und Nistbaustätte dienen soll.
Für eine erfolgreiche Ansiedlung der Wanderfledermaus gehört sicherlich ein biologisches
intaktes Umfeld, das sich in einer reichen Artenvielfalt an Pflanzen und Insekten widerspiegelt,
und klimatisch passenden Bedingungen.
In der Gruppe stellten wir uns deshalb die Frage, inwieweit das Verhalten der Tiere durch
das Wetter beeinflusst wird. Bei welchen Lichtverhältnissen verlassen die Fledermäuse
den Stollen? Fliegen sie bei jeder Temperatur aus oder verbleiben sie im Stollen, wenn
es draußen zu kalt ist? Wie verhalten sich die empfindlichen Tiere bei Regenwetter? Aus
dieser Fragestellung entstand die Idee, das Wetter in unmittelbarer Nähe zum Stollen
zu messen und zeitgleich das Verlassen und Zurückkehren der bedrohten Tiere in ihre
Behausung durch Lichtschranken zu registrieren.
In dem vorliegenden Bericht möchte ich mich allein auf die Darstellung der Wetterstation
beschränken. Hier werden die Arbeitsergebnisse der letzten vier Monate beschrieben. Bei
der Planung habe ich von Beginn ab an beabsichtigt, leicht zugängliche elektronische
Bauteile zu verwenden, damit auch andere Naturgruppen die Anlage einfach nachbauen
können. Die Wetterdaten werden im Packet Radio Netz der Funkamateure übertragen
und somit einer breiten Öffentlichkeit zugänglich gemacht. Somit ist es möglich, das

2 1 ”Und nun das Wetter”
Verhalten der Tiere in Lüdinghausen mit denen in anderen Städten zu vergleichen, um
so zu einem besseren Verständnis der Tiere und zum Artenschutz beizutragen.
Vielleicht wird die Wetterstation, die ich hier beschreiben werde, auch nur von interessierten
Schülerinnen und Schülern nachgebaut, weil sie wissen wollen, wie das Wetter
an ihrer Schule gerade ist. Für die Weiterverarbeitung des von mir entwickelten Systems
an interessierte Gruppen ist allerdings eine präzise Bauanleitung mit detaillierten
Schaltplänen notwendig, um auch bei elektrotechnisch unerfahrenen Interessenten den
erfolgreichen Nachbau zu ermöglichen. Der vorliegende Bericht dokumentiert zunächst
einmal die grundlegenden technischen Ideen meines Projekts.
Nach der Einleitung folgt im zweiten Kapitel des Berichts die Erläuterungen zu den zentralen
elektronischen Bauteilen zur Messung der Wetterparameter Temperatur, Licht, relative
Luftfeuchtigkeit und Druck. Dazu gehört die serielle Schnittstelle, der TLC 549, der
Multiplexer/Demultiplexer und der achtstufige Binärzähler als Seriell/Parallel-Wandler.
Im 3. Kapitel stelle ich die Sensoren kurz vor und beschreibe die Erzeugung von Spannungswerten
aus den gemessenen Wetterparametern. Nach der Hardware wird im 4. Abschnitt
die Software vorgestellt, die von mir selbst entwickelt wurde. Die Beschreibung
der Übertragung der Daten wird im 5. Abschnitt behandelt. Der vorliegende Bericht
schließt mit einem Ausblick auf die mögliche Weiterentwicklung der Messstation.

3 2 Messwerterfassung
2 Messwerterfassung
2.1 Allgemeines über die serielle Schnittstelle
Ich habe mich für die Abfrage über die serielle Schnittstelle entschieden, weil sie relativ
einfach zu programmieren ist und häufig in älteren PCs eingebaut ist. Die serielle Schnittstelle
verfügt über neun Anschlüsse, von denen drei Sendeleitungen und fünf Empfangsleitungen
sind. Der neunte Anschluss geht nach Masse. Da die Steuerung der seriellen
Schnittstelle asynchron erfolgt (oder overlapped, wie es unter Windows heißt), können
nur vier Empfangsleitungen genutzt werden. Für den A/D-Wandler TLC549 werden zwei
Steuerleitungen und eine Empfangsleitung benötigt, weshalb eine Steuerleitung und drei
Empfangsleitungen zunächst frei bleiben 1 .
2.2 Funktionsweise des TLC 549
Anhand der Darstellung (Abbildung 2.1) erkennt man, dass bei Anschluss 1 und 3 die
obere und untere Referenzspannung anliegt, welche mit der von Pin 2 kommenden analogen
Spannung im 8-Bit Analog-to-Digital Converter ins Output Data Register geschrieben
wird. Über ChipSelect und I/O Clock wird mit Hilfe des Control Logic and Output
Counter nacheinander bitweise die Spannung als digitaler Wert ausgegeben.
Abbildung 2.2 zeigt den zeitlichen Verlauf zweier Abfragen: Mit der fallenden Flanke
an ChipSelect (CS) liegt an DataOut (Pin6) das höchstwertige Bit des acht Bit langen
digitalen Wertes an. Nach einer steigenden Flanke liegt das nächste Bit am Ausgang.
Nach achtmal Schalten ist der komplette digitale Wert ausgegeben worden.
Mit einem einzigen A/D-Wandler ist zunächst nur eine Messwerterfassung möglich, da
ich aber bis zu 8 Sensoren benutzen möchte, benötige ich eine Schaltung die mehrere
1 Vgl. H.-J. Berndt/B. Kainka, Messen, Steuern und Regeln mit Word und Excel, Poing, Francis-Verlag,
2001 3 , 100ff.

4 2 Messwerterfassung
Abbildung 2.1: Functional block diagram (Quelle: Datenblatt TLC549 )
Abbildung 2.2: Operating sequence (Quelle: Datenblatt TLC549 )

5 2 Messwerterfassung
Leitungen möglich macht. Man könnte mehrere A/D-Wandler benutzen, welche man
über Digital-Multiplexer an die serielle Schnittstelle anschließt. Oder man nutzt einen
Analog-Demultiplexer um acht Leitungen seriell, d.h. nacheinander abzufragen.
2.3 Multiplexer/Demultiplexer
Als Analog Multiplexer/Demultiplexer verwende ich den CD4051, der für acht Leitungen
ausgelegt ist. Um die Leitungen durchzuschalten ist ein achtstufiger Binärzähler notwendig.
2.4 Achtstufiger Binärzähler als
Seriell/Parallel-Wandler
Ein achtstufiger Binärzähler lässt sich aus drei jk-Master-Slave FlipFlops aufbauen, wie
er in ”Einführung in die Elektronik 2 / Kontaktlose Signalverarbeitung” von K. Block,
H.-J. Hölzel, L. Wölfing und P. Zachert auf Seite 206 beschrieben ist. Dazu schließt man
den Ausgang des ersten FF als Clock-Signal an den zweiten FF und dessen Ausgang als
Clock-Signal des dritten Ausgangs. Mit jedem Ausgang hat man dann insgesamt drei
Leitungen die 2 3 = 8 unterschiedliche Zustände annehmen können. Diese kann man nun
an den Multiplexer anschließen.
Wenn man das Signal der seriellen Schnittstelle direkt als erstes Clock-Signal weitergibt,
kann es dazu kommen, dass der achtstufige Binärzähler weiter zählt als zu erwarten
ist. Es lässt sich vermuten, dass sich dahinter ein Kontaktprellen verbirgt, weshalb eine
Vielzahl von Impulsen gezählt wird. Um dies zu verhindern könnte man wie auf S.
207 des schon genannten Buches ”Einführung in die Elektronik 2” zwei NAND-Stufen
benutzen. Ich habe mich allerdings für die Schaltung über zwei Transistoren, die die 5
Volt-Versorgungsspannung schalten, entschieden, mit der das unerwünschte Weiterschalten
auch vermieden wird.
Mit der bis hierhin beschriebenen Schaltung ist es also möglich, acht Leitungen im Bereich
von 0 bis 5 Volt mit einer Genauigkeit von 8-bit über die serielle Schnittstelle
nacheinander abzufragen.

6 3 Sensortechnik
3 Sensortechnik
Da der TLC549 einen Spannungsbereich von 0 bis 5 Volt abdeckt, ist es notwendig alle
zu ermittelnden Werte, wie Temperatur, Licht, Luftdruck usw. in veränderliche Spannungswerte
umzuwandeln.
3.1 Temperatursensor
Der Temperatursensor ist ein PTC-Widerstand (Positive Temperature Coeffizient Widerstand
- Kaltleiter). Dies bedeutet, dass er bei hohen Temperaturen einen größeren
Widerstand besitzt als bei niedrigeren. Da es aber aufwendiger wäre den Widerstand
des PTCs zu messen als eine Spannung ist es sinnvoll die Widerstandsänderung in eine
Spannungsänderung umzusetzen. Dafür benutzt man eine Widerstandsbrückenschaltung.
Sie besteht aus zwei in Reihe geschalteten Widerständen zwischen denen die Spannung
abgegriffen wird.
Die Spannungsänderung ergibt sich aus der Widerstandsänderung wie folgt:
In einer Reihenschaltung fließt durch jedes Bauteil ein gleich großer Strom: I 1 = I 2 = I ges .
Die Spannung teilt sich allerdings an jedem Bauteil und addiert sich zur Gesamtspannung
U 1 + U 2 = U ges . Das Ohmsche Gesetz besagt I ges = U ges /R ges . Mit R ges = R 1 + R 2 folgt
daraus für den Gesamtstrom I ges = U ges /(R 1 + R 2 ). Da in der Mitte zwischen beiden
Widerständen die Spannung abgegriffen wird, gilt für sie U 1 = R 1 · I ges , also:
U 1 = R 1 · U ges /(R 1 + R 2 )
Für R 1 > R 2 ist U 1 > 1/2U ges ,
für R 1 = R 2 ist U 1 = 1/2U ges und
für R 1 < R 2 ist U 1 < 1/2U ges .
Dies zeigt, wie sich eine Widerstandsänderung leicht in eine Spannungsänderung umwandeln
lässt.

7 3 Sensortechnik
Abbildung 3.1: Schaltplan für Temperatursensor

8 3 Sensortechnik
Das Datenblatt des benutzten Sensors (KTY 81-210) gibt an, dass der Widerstandswert
des Sensor bei 10 ◦ C 1772 Ohm beträgt. Wenn nun der 1. Widerstand ebenfalls auf diesen
Wert eingestellt wird, ergibt sich somit eine Spannung von 2,5 V. Bei einer Veränderung
der Temperatur ändert sich der Widerstand; die Spannung wird somit geändert. Bei dem
benutzten Sensor spielt sich die Bandbreite der Widerstandswerte in einem Bereich von
-20 ◦ C bis 40 ◦ C bei 1367 Ohm bis 2245 Ohm ab. Damit ergeben sich Spannungen im
Bereich von:
U 1 (−20 ◦ C) = 5V ·
1367Ω
1367Ω + 1772Ω
= 2, 17V
U 1 (40 ◦ C) = 5V ·
2245Ω
2245Ω + 1772Ω
= 2, 79V
Diese Spannungsbandbreite reicht für eine adäquate Messwertbestimmung jedoch nicht
aus. Aus diesem Grund muss sie verstärkt werden. Dies geschieht mit einem Operationsverstärker
als Differenzverstärker, der über R 4 und R 5 etwa eine Verstärkung v U um das
etwa fünffache bewirkt (berechnet sich nach der Formel v U = 1 + R 5 /R 4 = 5, 6, siehe
Fußnote 1 ).
Daraus folgt:
Differenz von 2,5 Volt ohne Verstärkung:
∆U 1 (−20 ◦ C) = 2, 17 − 2, 5V = −0, 33V
∆U 1 (40 ◦ C) = 2, 80 − 2, 5V = 0, 30V
Mit Verstärkung von v U = 5, 6 :
−0, 33V · 5, 6 = −1, 848V
0, 30V · 5, 6 = 1, 680V
Damit:
U1(-20 ◦ C) = 2,5 - 1,848 V = 0,652 V
U1(40 ◦ C) = 2,5 + 1,680 V = 4,18 V
1 W.-D. Schmidt, Sensorschaltungstechnik, S.30

9 3 Sensortechnik
Mit dieser Differenz von insgesamt 3,528 Volt auf 60 ◦ C ergibt sich:
3,472 V / 60 ◦ C = 0,0588 V/ ◦ C bzw. 17,01 ◦ C/V
Bei einer Genauigkeit des A/D-Wandlers von 8bit bedeutet dies:
5V/2 8 bit = 0, 019V/bit
17, 01 ◦ C/V · 0, 019V/bit = 0, 323 ◦ C/bit
Die Messung findet also mit einer Genauigkeit von 0,323 ◦ C statt (ungefähr 1/3 ◦ C
bzw. 3bit/ ◦ C).
Diese Berechung gilt für die vom Datenblatt angegebenen typischen Widerstandswerte
des Sensors. Das Datenblatt gibt allerdings auch maximale und minimale Werte für jede
Temperatur an, zwischen denen der tatsächliche Widerstandswert liegt. Laut Datenblatt
liegt der Fehler dabei im Bereich von ±2%.
3.2 Lichtsensor
Ähnlich wie der Temperatursensor besitzt der Lichtsensor (LDR 03) einen veränderlichen
Widerstandswert, der im Bereich von 2 Megaohm bei Dunkelheit und unter 100 Ohm
bei Sonnenlicht liegt. Im Schatten besitzt er immerhin noch ungefähr 2000 Ohm. Da in
dieser Arbeit keine absolute Lichtstärkemessung vorgenommen werden soll, sondern nur
eine relative Helligkeit festgestellt werden soll, besteht die Schaltung für den Lichtsensor
nur aus einer Brückenschaltung mit einem Präzisionstrimmer, mit welchem man den
gewünschten Schwellenwert für eine Messung von Hell/Dunkel einstellen kann. Aufgrund
des stark veränderlichen Fotowiderstands ist es nicht notwendig, die Spannung weiter zu
verstärken.
Abbildung 3.2: Schaltplan für Lichtsensor

10 3 Sensortechnik
3.3 Feuchtesensor
Der Feuchtesensor besitzt eine veränderliche Kapazität, weshalb er mit den bisherigen
Methoden nicht gemessen werden kann.
Meine Idee dazu sieht folgendermaßen aus:
Abbildung 3.3: Schaltplan für Feuchtesensor
Der Feuchtesensor ist als Kondensator im RC-Glied, des Timer-Schaltkreises mit einem
NE555 getaktet. Abhängig von der Kapazität entsteht eine variable Frequenz 2 . Da mit
meiner restlichen Hardware keine Frequenzmessung möglich ist, soll die Frequenz mit
einem Frequenz-Spannungs-Wandler umgewandelt werden und mit einem Operationsverstärker,
wie er auch schon benutzt wurde, angepasst werden. Die Frequenz des astabilen
Multivibrators berechnet sich mit f =
1
0,7(R 4 +2R 2 )C (siehe Fußnote3 ) . Mit den berechneten
Werten für die Widerstände kommt man auf eine mittlere Frequenz von ungefähr 10
kHz, die um ungefähr 3 kHz nach oben und unten schwankt. Die Ausgangsspannung des
2 Vgl. Schmidt, Sensorschaltungstechnik, S.134ff.
3 Schmidt, Sensorschaltungstechnik, S. 136 und Datenblatt NE555

11 3 Sensortechnik
Frequenz-Spannungs-Wandlers LM2917 berechnet sich nach: 4
V out = f in · V c · R 1 · C 1
Weshalb R 1 · C 1 = 1 · 1 kHz sein soll.
2 10
Der NE555 liefert eine positive Rechteckspannung, weshalb die Schaltung so noch nicht
funktioniert, da der LM2907 eine Frequenz erwartet, die zwischen positiven und negativen
Spannungen pendelt. Dieses Problem lässt sich beheben, indem man an Pin 11 des
LM2907 eine Spannung anlegt, die zwischen den Spitzen der Rechteckspannung liegt.
Aus dem Diagramm des Datenblattes kann man für den Feuchtigkeitssensor folgende
Werte entnehmen:
Kapazität des Feuchtesensors bei 0% r.F. ungefähr 100pF
Kapazität des Feuchtesensors bei 43% r.F. ungefähr 120pF
Kapazität des Feuchtesensors bei 100% r.F. ungefähr 150pF
Mit den benutzten Bauteilen errechnen sich folgende Werte für die Schaltung:
Frequenz am Ausgang des NE555:
für 0% r.F.:
f =
1
0, 7(R4 + 2R2)C => f 0 =
1
0, 7(47kΩ + 2 · 530kΩ) · 100pF
= 13, 0kHz
für 43% r.F.:
=> f 1 =
1
0, 7(47kΩ + 2 · 530kΩ) · 120pF
= 10, 8kHz
für 100% r.F.:
=> f 2 =
1
0, 7(47kΩ + 2 · 530kΩ) · 150pF
= 8, 7kHz
Spannungswerte für die Frequenzen:
V = f · 5V · 100kΩ · 470pF = f · 0, 000235V s
V 0 = f 0 · 0, 000235V s = 3, 056V
V 1 = f 1 · 0, 000235V s = 2, 54V
V 2 = f 2 · 0, 000235V s = 2, 038V
4 National Semiconductor,LM2907/LM2917 Frequency to Voltage Converter, DATA SHEET, 18 Seiten,
1995

12 3 Sensortechnik
Somit gibt es also eine Spannungsdifferenz von etwa 1V. Für die Messung muss sie also
um das Fünffache verstärkt werden. Der Verstärkungsfaktor v U berechnet sich nach v U
= 1 + R 11
R 10
= 5, siehe Fußnote 5
mit R 11 = 10kΩ folgt:
4 · R 10 = 10kΩ => R 10 = 2, 5kΩ
3.4 Drucksensor
Als Drucksensor kommt ein integrierter Sensor der Firma Motorola zum Einsatz, der im
Bereich von 15 bis 115 kPa ein lineares Spannungssignal im Bereich von 0.2 bis 4.8 Volt
ausgibt. Dieses wird nur noch durch die bereits beschriebene Operationsverstärkerschaltung
an die Messstation angepasst.
5 Schmidt,Sensorschaltungstechnik, S.30

13 4 Software
4 Software
Zur Programmierung der Software habe ich mich für die Programmiersprache Delphi
entschieden, da sie sowohl einfachen Gebrauch von der Windows-API machen kann als
auch eine leichte Programmierung der Benutzeroberfläche ermöglicht und zudem objektorientiert
ist.
4.1 Steuerung des A/D-Wandler über serielle
Schnittstelle
Zunächst muss die serielle Schnittstelle geöffnet werden. Die Funktion CreateFile öffnet
diese und gibt ein Handle von ihr zurück. Dies wird in der Variablen PortHandle
gespeichert, da es später für den Aufruf der übrigen Funktionen benötigt wird.
Die einzelnen Sendeleitungen werden mittels EscapeCommFunction gesetzt und zurückgesetzt.
Der Status der Empfangsleitungen wird mit GetCommModemStatus abgefragt. Um
den A/D-Wandler TLC549 nun abzufragen, wird zunächst der Variablen BitWert der
Wert 128 und b der Wert 0 zugewiesen. Durch einmaliges ein- und ausschalten von RTS
liefert der A/D-Wandler das höchstwertige Bit an der CTS-Leitung. Diese Leitung wird
in einer for-Schleife achtmal abgefragt, während I/O-Clock weitergeschaltet wird. Am
Ende ist in der Variablen b der Wert des TLC549 gespeichert und wird von der Funktion
zurückgegeben.
function TSerialThread.ByteRead : Integer; stdcall;
var BitWert, b, i : Integer;
BitWert := 128;
b := 0;
//Chipselect ein und ausschalten
SetzeRTS;
ClearRTS;
//Am Dataout liegt jetzt das 1. Bit
for i := 0 to 7 do // 8 mal weiterschalten

14 4 Software
begin
if CTS = True then
b := b + BitWert;
//I/O-Clock weiterschalten
SetzeDTR;
ClearDTR;
//nächstes Bit nur noch halbwertig
BitWert := BitWert div 2;
end;
result := b;
end;
Vgl. Berndt/Kainka, Messen, Steuern und Regeln mit Word und Excel, S. 103, Listing
6.7
4.2 Steuerung des Analog-Multiplexer
Wie schon in Abschnitt 2.4 beschrieben, reicht eine Sendeleitung für das Weiterschalten
des Achtstufigen Binärzählers aus, welcher den Analog-Multiplexer steuert. Hierfür wird
die TXD-Leitung genutzt, die insgesamt achtmal umgeschaltet wird, um anschließend
den Rückgabewert des TLC549 zu ermitteln und mit einer Wertetabelle für den Sensor
zu vergleichen. Zuletzt wird ein String mit allen Werten der Sensoren gefüllt, der in einer
Datei gespeichert und in eine Mailbox des Packet Radio Netz geschickt werden kann.
for SenNr := 0 to 7 do
begin
if mySerialThread.StatTXD = True then mySerialThread.ClearTXD
else if mySerialThread.StatTXD = False then mySerialThread.SetzeTXD;
Sensor[SenNr] := RoundTo(frmCalibSensor.CalibArray[SenNr,ByteWert],-2);
str := str + IntToStr(SenNr)+ ’;’ + FloatToStr(Sensor[SenNr]) + ’;’;
mySensorString := str;
end;
4.3 Umwandlung der Spannungswerte in Wetterdaten
Um aus den ermittelten Spannungswerten die Wetterdaten zu gewinnen, kann man zwei
verschiedene Wege gehen. Zum einen kann man den Spannungswert einfach in eine Funk-

15 4 Software
tion einsetzen und den Funktionswert angeben. Eine andere Möglichkeit ist es, den Spannungswert
mit einer Tabelle zu vergleichen, in der für alle 256 möglichen Spannungswerte
ein entsprechender Wert eingetragen ist. Der erste Weg eignet sich besonders gut für lineare
Sensoren und Systeme mit geringer Speicherkapazität und Rechenleistung. Für
den zweiten Weg spricht, dass er die Kalibrierung auch nicht linearer Sensoren einfach
ermöglicht, sowie gezielte Korrekturen der Messwerte vorgenommen werden können. Der
Nachteil des etwas größeren Speicherbedarfs von 8 KByte spielt allerdings auf PCs, wie
sie hier benutzt werden, keine Rolle. Anders sähe es bei einer Mikrocontroller gesteuerten
Station aus.
4.4 Dokumentation der Messparameter
procedure WriteMyData(FileName: OpenString; Data : OpenString);
var myFile : TextFile;
begin
AssignFile(myFile,FileName);
try
if FileExists(FileName) = True then Append(myFile) else Rewrite(myFile);
writeln(myFile,Data);
finally
CloseFile(myFile);
end;
end;
Zunächst wird überprüft, ob die Datei schon existiert, anschließend wird sie geöffnet
oder erzeugt und die Daten werden in die Datei geschrieben. Zum Schluss wird die Datei
wieder geschlossen.

16 5 Übertragung
5 Übertragung
Für die Übertragung ist es vorgesehen, dass eine automatische Übertragung in eine Packet
Radio Mailbox stattfindet, die auch über das Internet erreichbar ist. So können die Daten
z.B. auf http://www.db0res.de:8080/ angesehen werden.
5.1 Packet Radio
Packet Radio ist eine digitale Betriebsart des Amateurfunks. Sie dient dem Aufbau von
Verbindungen zu anderen Funkamateuren und dem weltweiten Informationsaustausch.
So genannte Digipeater, automatisch arbeitende Packet Radio Amateurfunkstationen an
exponierten Standorten bilden das Gerüst des Packet Radio Netzes. Die Digipeater sind
untereinander verlinkt. Sie tauschen untereinander ständig Routeninformationen aus, so
dass sie wie das Internet die effektivste Verbindung zwischen zwei Usern herstellen. Vor
Ort bieten sie den Nutzern einen lokalen User-Einstieg ins Netz.
Der Nutzer kann, nachdem er einen Digipeater connectet hat, sich mit weiteren Stationen
verbinden. Im Netz besteht die Möglichkeit, Nachrichten und Binärdateien in eine
Mailbox zu senden oder herunter zu laden. So besteht zum Beispiel auch die Möglichkeit,
sich Satellitenbilder anzusehen oder schnell Wetterdaten abzurufen.
Die Übertragung findet im 23cm, 70cm und 2m Band statt. Üblich sind dabei Übertragungsraten
von 1k2 bit/s und 9k6 bit/s bei Nutzereinstiegen und 19k8 bit/s bis zu
mehreren Megabit/s bei Linkstrecken zwischen Digipeatern.
Packet Radio wird durch Frequenzumtastung moduliert (FSK-Modulation). Moderne
kommerzielle Datenfunkanwendungen wie GPRS und WLAN nutzen die gleiche, wenn
auch weiterentwickeltere Modulation.

17 5 Übertragung
5.2 Packet Radio Station
Für die Datenübertragung benötigt man neben einem Computer und einem handelsüblichen
Amateurfunk-Transceiver ein Modem. Das Modem stellt zusammen mit entsprechender
Software (z.B. FlexNet) die Verbindung zum Packet Radio Netz her und
bewerkstelligt den Datentransfer, indem es die Befehle und Nutzdaten in Pakete des
AX.25 Protokoll einbettet. Das AX.25 Protokoll ist eine für den Amateurfunk modifizierte
Variante des kommerziellen X.25 Übertragungsprotokolls. Es sorgt für eine sichere
und fehlerfreie Datenübertragung Statt des Modems und der Software (FlexNet) kann
auch ein TNC (Terminal Node Controller) eingesetzt werden.
5.3 Terminalprogramm Paxon
Dem Nutzer steht mit einem Terminalprogramm wie Paxon eine leicht zu bedienende
Oberfläche für die Betriebsart Packet Radio auf modernen Windows PCs zur Verfügung.
Paxon ist aber nicht - wie andere Terminalprogramm unter DOS (z.B. SP) - fähig
andere Programme aufzurufen bzw. fernzusteuern. Um auf einem modernen Windows
PC dennoch die ermittelten Wetterparameter zu übertragen, muss meine Software die
Übertragung selbst übernehmen. Glücklicherweise bietet Paxon eine COM- Programmierschnittstelle,
mit der man auf wichtige Funktionen des Programms zugreifen kann,
ohne sich um die eigentlichen Funktionsweise des Verbindungsaufbaus kümmern zu müssen.
Dafür wird zunächst die Component Object Model (COM) Library mit CoInitialize initialisiert
und anschließend mit CreateOleObject eine Referenz auf die COM-Schnittstelle
von Paxon zurückgegeben. Mit dieser ist es nun möglich, Funktionen von Paxon wie
FindConnection, Connect, SendTextLine, WaitForText oder Disconnect aufzurufen.
If CoInitialize(NIL) S_OK then
begin
CoUninitialize;
exit;
end;
// Paxon finden
if FindWindow(’tHauptfenster’, NIL) > 0 then
begin
myPaxon := CreateOLEObject(’Paxon.Application’) as iApplication;

18 5 Übertragung
Zu erwähnen bleibt, dass die Übertragung in einem eigenen Thread ausgeführt wird, so
dass die Messwerterfassung ungestört von den Vorgängen der Übertragung stattfindet.
Dieses Multithreading findet mittels einer abgeleiteten Standard TThread-Klasse statt.

19 5 Übertragung
5.4 Übertragung in eine Mailbox
Um die Daten nun z.B. alle 30 Minuten zu übertragen, ist es nur noch notwendig eine
Verbindung mit dem nächsten User-Einstieg aufzubauen, sich mit einer Mailbox zu
connecten und die Mail zu senden. Anschließend kann die Verbindung beendet werden.
Dies geschieht bei meiner Software durch folgenden Code:
procedure TPaxonThread.Connect(Call : WideString);
begin
Connection := myPaxon.FindConnection(Call);
PaxonStr := ’Connection gefunden’;
Synchronize(UpdateLabel);
If Connection = Nil Then
begin
Connection := myPaxon.Connect(Call);
PaxonStr := ’Neu verbunden’;
Synchronize(UpdateLabel);
end;
end;
procedure TPaxonThread.SendToMailbox(Einstieg : WideString; Board :
WideString; Betreff : WideString);
begin
Connect(Einstieg);
Connection.SendTextLine(’ ’);
Connection.WaitForText(’=>’);
Connection.SendTextLine(’m’);
Connection.WaitForText(’-->’);
Connection.SendTextLine(’ ’);
Connection.WaitForText(’-->’);
Connection.SendTextLine(’s’ + ’ ’ + Board + ’ ’ + Betreff);
Connection.WaitForText(’:’);
Connection.SendTextLine(’Diese Mail wurde automatisch generiert’);
Synchronize(SendSensorData);
Connection.SendTextLine(myString);
Connection.SendTextLine(’NNNN’);
Connection.WaitForText(’-->’);
Connection.SendTextLine(’ ’);
Connection.WaitForText(’-->’);
Connection.SendTextLine(’q’);
SendMailNext := False;
end;

20 6 Schlussbetrachtung
6 Schlussbetrachtung
Diese Arbeit bedeutete für mich eine sehr große Herausforderung. Da zahlreiche Probleme
zu lösen waren:
• Entwicklung von Wettersensoren
• Entwicklung der Hardware zur Messwerterfassung
• Entwicklung und Programmierung von Software
• Programmierung der Übertragung ins Funknetz
Um all diese Probleme zu lösen, ging ich zunächst auf die Suche nach geeigneter Literatur.
Ich stieß auf den TLC 549 und dessen Ansteuerung mithilfe des PCs in ”Messen,
Steuern und Regeln mit Word und Excel” von H.J. Berndt und B. Kainka. Im gleichen
Buch fand sich die Schaltung eines Temperatursensors.
Für den ersten Aufbau benutzte ich ein Steckbrett, so dass ich die Schaltungen einfach
ausprobieren und erweitern konnte. Da von vornherein klar war, das nicht nur ein Sensor
abgefragt werden sollte, suchte ich Möglichkeiten, die Schaltung um Sensoren zu erweitern.
So kam ich zu der Idee, einen Analog-Multiplexer zu benutzen. Ich baute darauf
die Schaltung für den A/D-Wandler, den Multiplexer und den achtstufigen Binärzähler
auf der Steckplatine auf.
Neben dem Aufbau programmierte ich die grundlegenden Funktionen der Software und
zeichnete den Schaltplan. Nachdem auf dem Steckbrett weitere Sensoren funktionierten,
begann ich mit dem Aufbau der Station auf einer Streifenrasterplatine. Trotz einiger
zu bewältigende Programmierprobleme und Hardwareschwierigkeiten, gelang es mir,
schließlich einen Prototypen fertig zu stellen. Da dieser recht gut lief, kontrollierte ich
die Schaltung auf Fehler und ließ eine Platine dieser Schaltung ätzen.
Das hier vorgestellte Projekt bietet aus meiner Sicht vielfältige Anbindungsmöglichkeiten
an den projektorientierten Physik- und Technikunterricht in der Schule. Dies ist eine gute
Möglichkeit, den Unterricht in diesen Fächern interessant, anspruchsvoll und innovativ

21 6 Schlussbetrachtung
zu gestalten, um so das Interesse und die Begeisterung von Schülerinnen und Schülern
an der Technik zu wecken und zu fördern.
Der Leser kann sich von der Funktionsfähigkeit der Station überzeugen, indem er unter
http://www.db0res.de:8080/ den Befehl l wetter -100 in der Befehlsbox unter der Beschriftung
”Commands” eingibt. Dort findet man unter meinem Rufzeichen, DO2YRB,
mit dem Betreff ”Wx LH” die Wetterdaten aus Lüdinghausen. Anschließend einfach auf
das Rufzeichen klicken und die Mail wird angezeigt.

22 7 Ausblick
7 Ausblick
Eigenartig und dunkel erscheint schon seit der Antike das Verhalten von Fledermäusen:
So beschreibt der römische Dichter Ovid (43 v. Chr. bis 17 n. Chr.) das Ende der drei
Töchter des Königs von Böotien, Minyas: Zur Strafe wurden sie in Fledermäuse verwandelt,
weil sie es vorgezogen hatten, am Webstuhl zu arbeiten und sich Geschichten zu
erzählen, statt an den Festlichkeiten zu Ehren des Weingottes Bacchus teilzunehmen.
Tectaque, non silvas celebrant lucemque perosae
Nocte volant seroque tenent a vespere nomen.
(Häuser, nicht Wälder bewohnen sie, hassen das Licht
fliegen in der Nacht und vom späten Abend haben sie ihren Namen.)
(Ovid, Metamorphosen IV 414f.)
Ein wenig Licht in das Verhalten dieser immer schon in unserem Kulturkreis suspekten
und mit dunklem Odem behafteten Tiere, die sich in der Nähe von Häusern aufhalten
und ihren lateinischen Namen durch ihre Nachtaktivität erhalten haben, war und ist das
Ziel dieser Arbeit.
Dafür ist die Wetterstation zunächst einmal auf ihre Zuverlässigkeit bei Wind und Wetter
zu prüfen. Hat sie sich bewährt, dann soll sie in unmittelbarer Nahe zum Fledermausstollen
dauerhaft installiert werden. Dazu müssen Kabel vom Standort des nun
anzuschaffenden PC zu den Sensoren verlegt werden. Darüber hinaus ist der Erwerb von
Funkgeräten notwendig. Hier empfehle ich das Projekt einer weiteren Förderung durch
den VDE Rhein Ruhr e.V.
Denkbar für die Zukunft ist die Erweiterung der Wetterstation für IR-Lichtschranken und
eines Sensors für die Messung der Windgeschwindigkeit. Bei der Planung des Systems
wurde diese Erweiterungsmöglichkeit berücksichtigt. Eine prinzipielle Weiterentwicklung
wäre der Einsatz von Microcontrollern.
Hat sich die Station in der Praxis als zuverlässig erwiesen, wird sie bestimmt auch für
einen breiteren Nutzerkreis interessant sein.

23 Literatur
Literatur
[1] A. Wendt, “Computergestützte Wetterstation”, Praxisheft 3 für Amateurfunk und
Elektronik in Schule und Freizeit, Heft 3 , Seite 4-19, o.J..
[2] A. Schweizer, “ASYNOP-meterologischer Schlüssel für das WxNET”, Praxisheft 9
für Amateurfunk und Elektronik in Schule und Freizeit, Heft 9 , Seite 4-9, 1999.
[3] A. Schweizer, “Die AATiS-Wetterstation: Hardware”, Praxisheft 9 für Amateurfunk
und Elektronik in Schule und Freizeit, Heft 9 , Seite 10-14, 1999.
[4] A. Schweizer, “Die AATis-Wetterstation: Software”, Praxisheft 9 für Amateurfunk
und Elektronik in Schule und Freizeit, Heft 9 , Seite 15-17, 1999.
[5] A. Schweizer, “Schritte ins WxNET”, Praxisheft 9 für Amateurfunk und Elektronik
in Schule und Freizeit, Heft 9 , Seite 18-23, 1999.
[6] H.J. Berndt/B. Kainka, Messen, Steuern und Regeln mit Word und Excel, Poing,
Francis-Verlag, 2001 3 .
[7] K. Block/H.-J. Hölzel/L. Wölfing/P. Zachert, Kontaktlose Signalverarbeitung, Köln-
Porz, Verlag H. Stam GmbH, 1979 3 .
[8] W.-D. Schmidt, Sensorschaltungstechnik, Würzburg, Vogel Verlag, 2002 2 .
[9] DISCRETE SEMICONDUCTORS, KTY81-2 series. Silicon temperature sensors,
DATA SHEET, 16 Seiten, 1996
[10] STMicroelectronics, NE555 SA555 SE555. GENERAL PURPOSE SINGLE BIPO-
LAR TIMERS, DATA SHEET, 10 Seiten, 1998
[11] National Semiconductor, LM2907/LM2917 Frequency to Voltage Converter, DATA
SHEET, 18 Seiten, 1995
[12] Texas Instruments, CD4051B, CD4052B, CD4053B, DATA SHEET, 20 Seiten, 2003
[13] Fairchild Semiconductor, CD4027BC Dual J-K Master/Slave Flip-Flop with Set and
Reset, DATA SHEET,6 Seiten, 2002
[14] Philips Components, Moisture control with Philips’humidity sensor, DATA SHEET,
7 Seiten, 1997
[15] Motorola, MPX4115A MPXA4115A SERIES, SEMICONDUCTOR TECHNICAL
DATA, 9 Seiten, 2001

24 Literatur
[16] Texas Instruments, TLC548C, TLC548I, TLC549C, TLC549I 8-BIT ANALOG-
TO-DIGITAL CONVERTERS WITH SERIAL CONTROL DATA SHEET, 12 Seiten,
1996
[17] Texas Instruments, µA741, µA741Y GENERAL-PURPOSE OPERATIONAL AM-
PLIFIERS, DATA SHEET, 11 Seiten, 2000
[18] Michael Puff, Thread Programmierung unter Windows mit Delphi, Version 2.4,
http://www.luckie-online.de, 2005

A Schaltpläne
25 A Schaltpläne

26 A Schaltpläne
Abbildung A.1: Schaltplan für Wettermessstation

27 A Schaltpläne
Abbildung A.2: Schaltplan für Temperatursensoren, Lichtsensoren und Drucksensor

B Fotos
28 B Fotos

29 B Fotos
Abbildung B.1: Messschaltung auf Streifenrasterplatine, Schrägansicht
Abbildung B.2: Messschaltung auf Streifenrasterplatine, Draufsicht

30 B Fotos
Abbildung B.3: Sensoren auf Streifenrasterplatine
Abbildung B.4: Geätzte Platine, Schrägansicht

31 B Fotos
Abbildung B.5: Geätzte Platine, Draufsicht
Abbildung B.6: Geätzte Sensorplatine für Luftfeuchigkeit

C Stückliste
32 C Stückliste

33 C Stückliste
Tabelle C.1: Stückliste für Messstation (Preise: Reichelt Elektronik, 07.06.06)
Artikel Beschreibung Preis Anzahl
(inkl. MWSt.)
MOS 4051 CD4051BE Multiplexer 0.23 1
MOS 4027 Dual-JK Master-Slave Flip-Flop 0.23 1
TLC 549 CP A/D-Converter, DIP-8 1.95 1
µA 7805 Spannungsregler 1A positiv, TO-220 0.17 1
µA 7905 Spannungsregler 1A negativ, TO-220 0.17 1
LED 5MM LED, 5mm 0.05 4
1N 4001 DIODE 0.02 3
BC 107A TRANSISTOR 0.23 2
Schalter Kippschalter 1.15 2
D-SUB BU 09 D-SUB-Buchse, 9-polig, Lötkelch 0.10 1
BB 4 Bananenbuchse 4mm, vollisoliert 0.25 4
µA 741 DIP Op-Amp, DIP-8 0.14 4
64W-1,0K Präzisionspoti. 25 Gänge, stehend, 1,0 K-Ohm 0.64 2
1,0K Metalloxidschicht-Widerstand 1,0 K-Ohm 0.09 22
4,7K Metalloxidschicht-Widerstand 4,7 K-Ohm 0.09 1
NE 555 DIP Timer, DIP-8 0.12 1
LM 2907 DIL Converter, DIL-14 (LM 2907-8) 1.20 1
1,0M Metalloxidschicht-Widerstand 1 M-Ohm 0.09 1
560K Metalloxidschicht-Widerstand 560 K-Ohm 0.09 1
47K Metalloxidschicht-Widerstand 47 K-Ohm 0.09 1
KERKO 22N KERAMIK-KONDENSATOR 0.07 1
KERKO 470P KERAMIK-KONDENSATOR 0.04 1
100K Metalloxidschicht-Widerstand 100 K-Ohm 0.09 1
10K Metalloxidschicht-Widerstand 10 K-Ohm 0.09 6
2,2K Metalloxidschicht-Widerstand 2,2 K-Ohm 0.09 2
64W-10K Präzisionspoti. 25 Gänge, stehend, 10 K-Ohm 0.64 7
KERKO 100N KERAMIK-KONDENSATOR 0.07 15
H25SR160 Streifenrasterplatine, Hartpapier, 160x100mm 1.30 2
Warenwert: 21.42
MPX 4115A Motorola-Drucksensor 24.30 1
KTY 81-210 Temperatursensor, -55...+150 ◦ C 0.59 2
LDR 03 Fotowiderstand 1.60 2
FEUCHTES. Sensor für Feuchtigkeit 11.60 1
Warenwert: Sensoren 40.28
Warenwert: gesamt 61.70

34 D Quellcode
D Quellcode
program Wetherstation;
uses
Forms,
Main in ’Main.pas’ {frmMain},
Thread in ’Thread.pas’,
Speichern in ’Speichern.pas’,
Paxon in ’Paxon.pas’,
CalibSensor in ’CalibSensor.pas’ {frmCalibSensor};
{$R *.res}
begin
Application.Initialize;
Application.CreateForm(TfrmMain, frmMain);
Application.CreateForm(TfrmCalibSensor, frmCalibSensor);
MySerialThread := TSerialThread.Create(True);
MyPaxonThread := TPaxonThread.Create(@mySendMailNext, @mySensorString,frmMain.lblPaxon,True);
Application.Run;
end.
unit Main;
interface
uses
Windows, Messages, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, SysUtils, Thread, ExtCtrls, Speichern, Math, Paxon,
CalibSensor,Paxon_TLB,ActiveX,ComObj;
type
TfrmMain = class(TForm)
btnOpen: TButton;
lblStatus: TLabel;
btnCloseCom: TButton;
Label1: TLabel;
Label2: TLabel;
Label3: TLabel;
Label4: TLabel;
Label5: TLabel;
Label6: TLabel;
Label7: TLabel;
Label8: TLabel;
Label9: TLabel;
lblSensor1: TLabel;
lblSensor2: TLabel;
lblSensor3: TLabel;
lblSensor4: TLabel;
lblSensor5: TLabel;
lblSensor6: TLabel;
lblSensor7: TLabel;
lblSensor8: TLabel;

35 D Quellcode
tmrSensorabfrage: TTimer;
chbSensoren: TCheckBox;
chbSaveSensor: TCheckBox;
lblUhr: TLabel;
btnStartThread: TButton;
lblPaxon: TLabel;
btnStopThread: TButton;
btnCalibSensor: TButton;
chbSendMail: TCheckBox;
tmrMail: TTimer;
Label10: TLabel;
txtSensorTime: TEdit;
Label11: TLabel;
Label12: TLabel;
txtSendTime: TEdit;
Label13: TLabel;
txtEinstieg: TEdit;
Label14: TLabel;
lbl: TLabel;
Label15: TLabel;
txtBoard: TEdit;
txtBetreff: TEdit;
Label16: TLabel;
btnSendEinstellungen: TButton;
procedure btnOpenClick(Sender: TObject);
procedure btnCloseComClick(Sender: TObject);
procedure tmrSensorabfrageTimer(Sender: TObject);
procedure btnStartThreadClick(Sender: TObject);
procedure btnStopThreadClick(Sender: TObject);
procedure btnCalibSensorClick(Sender: TObject);
procedure tmrMailTimer(Sender: TObject);
procedure txtSensorTimeChange(Sender: TObject);
procedure txtSendTimeChange(Sender: TObject);
procedure btnSendEinstellungenClick(Sender: TObject);
private
public
end;
var
frmMain: TfrmMain;
var mySerialThread: TSerialThread;
var mySaveSensor: TSaveSensor;
var myPaxonThread: TPaxonThread;
myTimeString : String;
mySensorString : WideString;
mySendMailNext : Boolean;
implementation
{$R *.dfm}
procedure TfrmMain.btnOpenClick(Sender: TObject);
begin
if mySerialThread.OpenCOM(1)= False then
lblStatus.Caption := ’Fehler beim Öffnen’
else
lblStatus.Caption := ’Erfolgreich geöffnet’;
end;
procedure TfrmMain.btnCloseComClick(Sender: TObject);
begin
if mySerialThread.CloseCOM = true then lblStatus.Caption := ’COM geschlossen’;
end;
procedure TfrmMain.tmrSensorabfrageTimer(Sender: TObject);

36 D Quellcode
var ByteWert, SenNr, i, ByteSumme : Integer;
Sensor: array[0..7] of Extended;
str, myTimeStr, appendstr: string;
myTime : TDateTime;
const Zahler = 1000;
begin
if chbSensoren.Checked = True then
begin
myTime := Date + Time;
myTimeStr := DateToStr(Date) + ’;’ + TimeToStr(Time);
str := myTimeStr + ’;’;
mySensorString := ’PC Uhrzeit: ’ + myTimeStr + #13;
for SenNr := 0 to 7 do
begin
if mySerialThread.StatTXD = True then mySerialThread.ClearTXD
else if mySerialThread.StatTXD = False then mySerialThread.SetzeTXD;
ByteWert:=0;
ByteSumme:=0;
for i := 0 to Zahler do
begin
ByteWert := mySerialThread.ByteRead;
ByteSumme := ByteSumme + ByteWert;
end;
ByteWert := Round(ByteSumme / Zahler);
Sensor[SenNr] := RoundTo(frmCalibSensor.CalibArray[SenNr,ByteWert],-2);
appendstr := IntToStr(SenNr)+ ’;’ + FloatToStr(Sensor[SenNr]) +
frmCalibSensor.EinheitArray[SenNr] + ’;’;
str := str + appendstr;
mySensorString := mySensorString + ’SensorNr ’ + IntToStr(SenNr) + ’: ’ +
FloatToStr(Sensor[SenNr]) + frmCalibSensor.EinheitArray[SenNr]
+ #13;
end;
str := str + #13;
if chbSaveSensor.Checked = True then WriteMyData(’SensorData.txt’,str);
lblSensor1.Caption := FloattoStr(Sensor[0]);
lblSensor2.Caption := FloattoStr(Sensor[1]);
lblSensor3.Caption := Floattostr(Sensor[2]);
lblSensor4.Caption := FloattoStr(Sensor[3]);
lblSensor5.Caption := FloattoStr(Sensor[4]);
lblSensor6.Caption := Floattostr(Sensor[5]);
lblSensor7.Caption := FloattoStr(Sensor[6]);
lblSensor8.Caption := Floattostr(Sensor[7]);
lblUhr.Caption := DateTimeToStr(myTime);
end;
mySaveSensor.Free;
end;
procedure TfrmMain.btnStartThreadClick(Sender: TObject);
begin
tmrMail.Interval := StrToInt(txtSendTime.Text) * 60000;
myPaxonThread.Resume;
end;
procedure TfrmMain.btnStopThreadClick(Sender: TObject);
begin
myPaxonThread.Terminate;
end;
procedure TfrmMain.btnCalibSensorClick(Sender: TObject);
begin
frmCalibSensor.lblSensorNr.Caption := inttostr(frmCalibSensor.SensorNr);
frmCalibSensor.Show;
end;
procedure TfrmMain.tmrMailTimer(Sender: TObject);

37 D Quellcode
begin
if chbSendMail.Checked = True Then myPaxonThread.SendMailNext := True
else myPaxonThread.SendMailNext := False;
end;
procedure TfrmMain.txtSensorTimeChange(Sender: TObject);
begin
tmrSensorabfrage.Interval := StrToInt(txtSensorTime.Text) * 1000;
end;
procedure TfrmMain.txtSendTimeChange(Sender: TObject);
begin
tmrMail.Interval := StrToInt(txtSendTime.Text) * 60000;
end;
procedure TfrmMain.btnSendEinstellungenClick(Sender: TObject);
var save : boolean;
begin
save := myPaxonThread.SendMailNext;
myPaxonThread.SendMailNext := False;
myPaxonThread.myEinstieg := txtEinstieg.Text;
myPaxonThread.myBoard := txtBoard.Text;
myPaxonThread.myBetreff := txtBetreff.Text;
myPaxonThread.SendMailNext := save;
end;
end.
unit Thread;
interface
uses
Classes, Windows, SysUtils;
type
TSerialThread = class(TThread)
private
PortTimeout : _COMMTIMEOUTS;
PortHandle : Integer;
PortDCB : TDCB;
PortNr : Integer;
PortState : Cardinal;
WriteOverlapped,ReadOverlapped,StatusOs: TOverlapped; { Private-Deklarationen }
protected
fComEvent: cardinal;
fStatCTS: boolean;
fStatDCD: boolean;
fStatDSR : Boolean;
fStatRing : Boolean;
procedure Execute; override;
public
StatDTR : boolean;
StatRTS : boolean;
StatTXD : boolean;
constructor Create(CreateSuspended: Boolean);
property ComEvent: cardinal read fComEvent;
property StatCTS: boolean read fStatCTS;
property StatDCD: boolean read fStatDCD;
property StatDSR: boolean read fStatDSR;
property StatRing: boolean read fStatRing;
function ClearDTR : boolean; stdcall;
function ClearRTS : boolean; stdcall;
function ClearTXD : boolean; stdcall;
function SetzeDTR : boolean; stdcall;

38 D Quellcode
function SetzeRTS : boolean; stdcall;
function SetzeTXD : boolean; stdcall;
function ComAvailable(ComNr: byte): boolean; stdcall;
function CTS : boolean; stdcall;
function DCD : boolean; stdcall;
function DSR : boolean; stdcall;
function RING : boolean; stdcall;
function ByteRead : Integer; stdcall;
function OpenCOM(Port: byte): boolean; stdcall;
function CloseCOM : boolean; stdcall;
procedure InitOverlapped(var Overlapped : TOverlapped);
procedure ReleaseEvent(Event : Cardinal);
function SetBaudRate(baud: cardinal): boolean; stdcall;
end;
implementation
constructor TSerialThread.Create(CreateSuspended: Boolean);
begin
FreeOnTerminate:= True;
inherited Create(CreateSuspended);
Priority := tpNormal;
end;
procedure TSerialThread.ReleaseEvent(Event : Cardinal);
begin
fStatCTS := CTS;
fStatDSR := DSR;
fStatDCD := DCD;
fStatRING := RING;
end;
procedure TSerialThread.Execute;
var
SerialEvent, WaitResult, BytesRead: Cardinal;
begin
SetCommMask(PortHandle,EV_CTS or EV_DSR or
EV_RING or EV_RLSD);
if not WaitCommEvent(PortHandle,SerialEvent,@StatusOs) then
begin
if (GetLastError = ERROR_IO_PENDING) then
begin
WaitResult := WaitForSingleObject(StatusOs.hEvent,INFINITE);
case WaitResult of
WAIT_OBJECT_0:
begin
if GetOverlappedResult(PortHandle,StatusOs,BytesRead,false) then
ReleaseEvent(SerialEvent);
end;
end;
end;
end else ReleaseEvent(SerialEvent);
end;
procedure TSerialThread.InitOverlapped(var Overlapped : TOverlapped);
begin
Overlapped.Offset := 0;
Overlapped.OffsetHigh := 0;
Overlapped.Internal := 0;
Overlapped.InternalHigh := 0;
Overlapped.hEvent := CreateEvent(nil,True,False,’’);
end;

39 D Quellcode
function TSerialThread.OpenCOM(Port: byte): boolean; stdcall;
begin
PortHandle :=
CreateFile(PChar(’\\.\COM’+IntToStr(Port)),GENERIC_READ or GENERIC_WRITE,0,
nil,OPEN_EXISTING,FILE_FLAG_OVERLAPPED,LongInt(0));
if PortHandle > 0 then
begin
Result := true;
InitOverlapped(WriteOverlapped);
InitOverlapped(ReadOverlapped);
InitOverlapped(StatusOs);
end else Result := false;
end;
function TSerialThread.CloseCOM : boolean; stdcall;
begin
PurgeComm(PortHandle, PURGE_RXABORT or PURGE_RXCLEAR or PURGE_TXABORT or PURGE_TXCLEAR);
SetCommMask(PortHandle,0); //unterbricht WaitCommEvent im Polling thread
result:= CloseHandle(PortHandle);
PortHandle := 0;
end;
function TSerialThread.ComAvailable(ComNr: byte): boolean; stdcall;
var
TestHandle : integer;
begin
TestHandle :=
CreateFile(PChar(’\\.\COM’+IntToStr(ComNr)),GENERIC_READ or GENERIC_WRITE,0,
nil,OPEN_EXISTING,FILE_FLAG_OVERLAPPED,LongInt(0));
if (TestHandle

40 D Quellcode
begin
if (PortHandle 0) then Result := EscapeCommFunction(PortHandle,CLRDTR);
StatDTR := False;
end;
function TSerialThread.ClearRTS : boolean; stdcall;
begin
if (PortHandle 0) then Result := EscapeCommFunction(PortHandle,CLRRTS);
StatRTS := False;
end;
function TSerialThread.ClearTXD : boolean; stdcall;
begin
if (PortHandle 0) then Result := EscapeCommFunction(PortHandle,CLRBREAK);
StatTXD := False;
end;
function TSerialThread.DSR : boolean; stdcall;
begin
GetCommModemStatus(PortHandle,PortState);
if ((Portstate and MS_DSR_ON) 0) then Result := true
else Result := false;
end;
function TSerialThread.CTS : boolean; stdcall;
begin
GetCommModemStatus(PortHandle,PortState);
if ((Portstate and MS_CTS_ON) 0) then Result := true
else Result := false;
end;
function TSerialThread.DCD : boolean; stdcall;
begin
GetCommModemStatus(PortHandle,PortState);
if ((Portstate and MS_RLSD_ON) 0) then Result := true
else Result := false;
end;
function TSerialThread.RING : boolean; stdcall;
begin
GetCommModemStatus(PortHandle,PortState);
if ((Portstate and MS_RING_ON) 0) then Result := true
else Result := false;
end;
function TSerialThread.ByteRead : Integer; stdcall;
var BitWert, b, i : Integer;
begin
BitWert := 128;
b := 0;
//Chipselect ein und ausschalten
SetzeRTS;
ClearRTS;
//Am Dataout liegt jetzt das 1. Bit
for i := 0 to 7 do // 8 mal weiterschalten
begin
if CTS = True then
b := b + BitWert;
//I/O-Clock weiterschalten
SetzeDTR;
ClearDTR;
//nächstes Bit nur noch halbwertig
BitWert := BitWert div 2;
end;
result := b;
end;
end.

41 D Quellcode
unit Speichern;
interface
uses
Classes, Windows, SysUtils;
procedure WriteMyData(FileName: OpenString; Data : OpenString);
type
TSaveSensor = class(TFileStream)
private
protected
public
end;
const
fmCreate = $FFFF;
fmOpenRead = $0000;
fmOpenWrite = $0001;
fmOpenReadWrite = $0002;
fmShareCompat = $0000 platform;
fmShareExclusive = $0010;
fmShareDenyWrite = $0020;
fmShareDenyRead = $0030 platform;
fmShareDenyNone = $0040;
implementation
procedure WriteMyData(FileName: OpenString; Data : OpenString);
var myFile : TextFile;
begin
AssignFile(myFile,FileName);
try
if FileExists(FileName) = True then Append(myFile) else Rewrite(myFile);
writeln(myFile,Data);
finally
CloseFile(myFile);
end;
end;
end.
unit Paxon;
interface
uses Windows, Paxon_TLB, ComObj, ActiveX, Dialogs, Classes, StdCtrls;
type PBoolean = ^Boolean;
type
TPaxonThread = class(TThread)
private
lblCaption : TLabel;
myStringPointer :PWideString;
myString : WideString;
SendMailNextPointer : PBoolean;
procedure Connect(Call : WideString);
procedure SendSensorData();
protected
PaxonStr : string;
procedure Execute; override;
procedure UpdateLabel;

42 D Quellcode
public
Connection : iConnection;
myPaxon : iApplication;
SendMailNext : Boolean;
myEinstieg: WideString;
myBoard: WideString;
myBetreff: WideString;
procedure SendToMailbox(Einstieg : WideString;
Board : WideString; Betreff : WideString);
constructor Create(SendMailPointer : PBoolean; StringPointer:PWideString ;
myLabel : TLabel; CreateSuspended : Boolean);
end;
implementation
constructor TPaxonThread.Create(SendMailPointer : PBoolean; StringPointer :PWideString;
myLabel : TLabel; CreateSuspended : Boolean);
begin
FreeOnTerminate := False;
lblCaption := myLabel;
myStringPointer := StringPointer;
SendMailNextPointer := SendMailPointer;
myEinstieg:= ’DB0EA’;
myBoard:= ’Wetter @ DB0RES.#NRW.DEU.EU’;
myBetreff:= ’Wx LH’;
inherited Create(CreateSuspended);
end;
procedure TPaxonThread.Execute();
begin
Connection := nil;
myPaxon := Nil;
SendMailNext := True ;
try
If CoInitialize(NIL) S_OK then
begin
CoUninitialize;
PaxonStr :=’Fehler’;
Synchronize(UpdateLabel);
exit;
end;
// Paxon finden
if FindWindow(’tHauptfenster’, NIL) > 0 then
begin
myPaxon := CreateOLEObject(’Paxon.Application’) as iApplication;
PaxonStr := ’Paxon-Objekt erzeugt’;
Synchronize(UpdateLabel);
Connect(myEinstieg);
while (not Terminated) do
begin
if SendMailNext = True then SendToMailbox(myEinstieg,myBoard,myBetreff);
Synchronize(UpdateLabel);
end;
end
else PaxonStr := ’Application nicht erzeugt’; Synchronize(UpdateLabel);
finally
Connection.Disconnect;
CoUninitialize;
PaxonStr := ’Verbindung beendet’;
Synchronize(UpdateLabel);
end;
end;
procedure TPaxonThread.UpdateLabel;

43 D Quellcode
begin
lblCaption.Caption := PaxonStr;
end;
procedure TPaxonThread.SendSensorData();
begin
myString := myStringPointer^;
end;
procedure TPaxonThread.Connect(Call : WideString);
begin
Connection := myPaxon.FindConnection(Call);
PaxonStr := ’Connection gefunden’;
Synchronize(UpdateLabel);
If Connection = Nil Then
begin
Connection := myPaxon.Connect(Call);
PaxonStr := ’Neu verbunden’;
Synchronize(UpdateLabel);
end;
end;
procedure TPaxonThread.SendToMailbox(Einstieg : WideString; Board :
WideString; Betreff : WideString);
begin
Connect(Einstieg);
Connection.SendTextLine(’ ’);
Connection.WaitForText(’=>’);
Connection.SendTextLine(’m’);
Connection.WaitForText(’-->’);
Connection.SendTextLine(’ ’);
Connection.WaitForText(’-->’);
Connection.SendTextLine(’s’ + ’ ’ + Board + ’ ’ + Betreff);
Connection.WaitForText(’:’);
Connection.SendTextLine(’Diese Mail wurde automatisch generiert’);
Synchronize(SendSensorData);
Connection.SendTextLine(myString);
Connection.SendTextLine(’NNNN’);
Connection.WaitForText(’-->’);
Connection.SendTextLine(’ ’);
Connection.WaitForText(’-->’);
Connection.SendTextLine(’q’);
SendMailNext := False;
end;
end.
unit CalibSensor;
interface
uses
SysUtils, Windows, Messages, Classes, Graphics, Controls,
StdCtrls, ExtCtrls, Forms, Dialogs;
type TCalibArray = Array[0..7,0..255] of Single;
type TEinheitArray = Array[0..7] of ShortString;
type
TfrmCalibSensor = class(TForm)
btnOk: TButton;
btnCancel: TButton;
Label1: TLabel;
lblSensorNr: TLabel;
Label2: TLabel;
Label3: TLabel;

44 D Quellcode
Label4: TLabel;
txt0: TEdit;
txt127: TEdit;
txt255: TEdit;
txtEinheit: TEdit;
lblEinheit: TLabel;
btnSpeichern: TButton;
btnLaden: TButton;
txtSensorNr: TEdit;
lstArray: TListBox;
rdbLinear: TRadioButton;
rdbEinzelauswahl: TRadioButton;
btnUebernehmen: TButton;
procedure btnOkClick(Sender: TObject);
procedure btnSpeichernClick(Sender: TObject);
procedure btnLadenClick(Sender: TObject);
procedure ArrayFuellen();
procedure btnCancelClick(Sender: TObject);
procedure ListBoxFuellen();
procedure txtSensorNrChange(Sender: TObject);
procedure btnUebernehmenClick(Sender: TObject);
procedure Aktualisieren();
procedure lstArrayClick(Sender: TObject);
public SensorNr: Byte;
public CalibArray: TCalibArray;//Array[0..7,0..255] of Single;
public EinheitArray: TEinheitArray;
end;
const DAT_PFAD = ’CalibSensor.dat’;
const Einheit_PFAD = ’Einheit.dat’;
var
frmCalibSensor: TfrmCalibSensor;
implementation
{$R *.DFM}
procedure TfrmCalibSensor.btnOkClick(Sender: TObject);
begin
Aktualisieren;
frmCalibSensor.Hide;
end;
procedure TfrmCalibSensor.btnSpeichernClick(Sender: TObject);
var f: file of TCalibArray;
f1 : file of TEinheitArray;
begin
ArrayFuellen;
AssignFile(f, DAT_PFAD);
ReWrite(f);
Write(f, CalibArray);
CloseFile(f);
AssignFile(f1, Einheit_PFAD);
ReWrite(f1);
Write(f1, EinheitArray);
CloseFile(f1);
end;
procedure TfrmCalibSensor.btnLadenClick(Sender: TObject);
var f: file of TCalibArray;
f1 : file of TEinheitArray;
begin
// Array laden
AssignFile(f, DAT_PFAD);
Reset(f);

45 D Quellcode
Read(f, CalibArray);
CloseFile(f);
AssignFile(f1, Einheit_PFAD);
Reset(f1);
Read(f1, EinheitArray);
CloseFile(f1);
SensorNr := StrToInt(txtSensorNr.Text);
txt0.Text := FloattoStr(CalibArray[SensorNr,0]);
txt127.Text := FloattoStr(CalibArray[SensorNr,127]);
txt255.Text := FloattoStr(CalibArray[SensorNr,255]);
txtEinheit.Text:=EinheitArray[SensorNr];
ListBoxFuellen;
end;
procedure TfrmCalibSensor.ArrayFuellen();
var klWert, miWert, hoWert, Differenz, Schritt : Single;
var n : Byte;
begin
klWert := StrToFloat(txt0.Text);
miWert := StrToFloat(txt127.Text);
hoWert := StrToFloat(txt255.Text);
CalibArray[SensorNr,0] := klWert;
CalibArray[SensorNr,127] := miWert;
CalibArray[SensorNr,255] := hoWert;
EinheitArray[SensorNr] := txtEinheit.Text;
if rdbLinear.Checked = True then
begin
Differenz := hoWert - klWert;
Schritt := Differenz / 255;
for n := 0 to 255 do
begin
CalibArray[SensorNr,n] := klWert + Schritt*n
end;
end;
end;
procedure TfrmCalibSensor.btnCancelClick(Sender: TObject);
begin
Hide;
end;
procedure TfrmCalibSensor.ListBoxFuellen();
var n : Byte;
begin
lstArray.Items.BeginUpdate;
lstArray.Items.Clear;
For n := 0 to 255 do
begin
lstArray.Items.Add(Floattostr(CalibArray[SensorNr,n]));
end;
lstArray.Items.EndUpdate;
end;
procedure TfrmCalibSensor.txtSensorNrChange(Sender: TObject);
begin
SensorNr := StrToInt(txtSensorNr.Text);
lblSensorNr.Caption := txtSensorNr.Text;
end;
procedure TfrmCalibSensor.btnUebernehmenClick(Sender: TObject);
begin
Aktualisieren();
end;
procedure TfrmCalibSensor.Aktualisieren();

46 D Quellcode
begin
SensorNr := StrToInt(txtSensorNr.Text);
ArrayFuellen;
txt0.Text := FloattoStr(CalibArray[SensorNr,0]);
txt127.Text := FloattoStr(CalibArray[SensorNr,127]);
txt255.Text := FloattoStr(CalibArray[SensorNr,255]);
txtEinheit.Text:=EinheitArray[SensorNr];
ListBoxFuellen;
end;
procedure TfrmCalibSensor.lstArrayClick(Sender: TObject);
var AktIndex : integer;
begin
if rdbEinzelauswahl.Checked = true then
begin
AktIndex := lstArray.ItemIndex;
CalibArray[SensorNr,AktIndex] := StrtoFloat(InputBox(’Bitte geben Sie einen Wert ein’,
Inttostr(AktIndex) + ’ entspricht:’,
lstArray.Items.Strings [AktIndex]));
Aktualisieren;
end;
end;
end.