Diplomarbeit - Lehrstuhl für...

Universität Kaiserslautern

Fachbereich Elektrotechnik

Lehrstuhl für Nachrichtentechnik

Prof. Dr.-Ing. Ralph Urbansky

Diplomarbeit

Entwurf und Implementierungdes Physical-Layers

mit variabler Faltungscodierungfür ein Powerline-System

im Rahmen eines fächerübergreifenden Projektes

mit dem Fachbereich Informatik

Denis Geiter

September 2002

Betreuer: Prof. Dr.-Ing. Ralph UrbanskyDr.-Ing. Wolfgang Sauer-Greff

Bearbeiter: Denis GeiterGerhart-Hauptmann-Str. 24

Denis Geiter

Gerhart-Hauptmann-Str. 24

67663 Kaiserslautern

Erklärung

Die vorliegende Arbeit ist unter Betreuung von Herrn Dr.-Ing. Wolfgang Sauer-Greff

entstanden. Hiermit erkläre ich, dass ich die vorliegende Studienarbeit selbstständig und ohne

weitere fremde Hilfe verfasst und keine anderen als die ausdrücklich angegebenen Hilfsmittel

verwendet habe.

Kaiserslauern, den 26.9.2002 (Denis Geiter)

Danksagung

Ich möchte mich bei allen, die mich bei der Erstellung der vorliegenden Arbeit unterstützt

haben, herzlich bedanken.

Insbesondere danke ich Herrn Dr.-Ing. Sauer-Greff für seine Unterstützung und die Vielzahl an

Anregungen, die er in meine Arbeit einbrachte. Weiterhin gilt mein Dank allen, die meine

Arbeit gelesen und mir bei der Überarbeitung geholfen haben.

INHALTSVERZEICHNIS

I

1 Einleitung ....................................................................................................................11.1 Fächerübergreifendes Projekt "Chatroom over Powerline" ............................... 11.2 Gliederung .......................................................................................................... 21.3 Was ist Powerline-Communication? .................................................................. 2

1.3.1 Die Marktsegmente .................................................................................. 31.3.2 Eigenschaften der PLC ............................................................................ 3

2 Grundlagen der PLC .................................................................................................52.1 Kommunikationskanal/Modell........................................................................... 5

2.1.1 Koppelnetzwerk ....................................................................................... 52.1.2 Kanalmodell des PLC-Kanals.................................................................. 72.1.3 Dämpfung eines PLC-Kanals .................................................................. 82.1.4 Zeitvariantes Verhalten des Netzes.......................................................... 82.1.5 Störungen in der Stromleitung ................................................................. 8

2.2 Übertragungsverfahren OFDM .......................................................................... 92.2.1 Multiplexing........................................................................................... 102.2.2 Modulation und Demodulation .............................................................. 122.2.3 Einfügen von Schutzintervallen............................................................. 132.2.4 Impulsstörungen..................................................................................... 142.2.5 Differenzielle Modulation...................................................................... 152.2.6 Nachteile von OFDM............................................................................. 152.2.7 Anforderungen an den Sendeverstärker................................................. 162.2.8 Schmalbandige Störungen ..................................................................... 162.2.9 Kanalkapazität........................................................................................ 17

2.3 Standardisierung der Powerline-Communication ............................................ 192.3.1 Regulierungen in Europa ....................................................................... 192.3.2 Medien-Zugriffsprotokoll im CENELEC-C-Band ................................ 212.3.3 Regulierungen in USA........................................................................... 222.3.4 Regulierungen außerhalb Europas und der USA ................................... 232.3.5 Die Nutzungsbestimmung 30................................................................. 232.3.6 HomePlug Power Alliance..................................................................... 252.3.7 PowerPacket........................................................................................... 25

2.4 Das OSI-Referenzmodell ................................................................................. 292.4.1 Die Bitübertragungsschicht.................................................................... 302.4.2 Die Sicherungsschicht............................................................................ 312.4.3 Die Vermittlungsschicht ........................................................................ 312.4.4 Die Transportschicht .............................................................................. 322.4.5 Die Sitzungsschicht................................................................................ 322.4.6 Die Darstellungsschicht ......................................................................... 322.4.7 Die Anwendungsschicht ........................................................................ 33

INHALTSVERZEICHNIS

II

3 Kanalcodierung.........................................................................................................343.1 Faltungscodierung ............................................................................................ 35

3.1.1 Zustandsdiagramm................................................................................. 363.1.2 Codebaum .............................................................................................. 373.1.3 Trellisdiagramm..................................................................................... 383.1.4 Polynominale Darstellung...................................................................... 393.1.5 Katastrophale Faltungscodierer ............................................................. 403.1.6 Endliche Faltungscodes ......................................................................... 423.1.7 Punktierte Faltungscodes ....................................................................... 43

3.2 Viterbi-Algorithmus ......................................................................................... 463.3 Checksummen .................................................................................................. 49

3.3.1 CRC - Cyclic Redundancy Checksums ................................................. 493.4 Rahmensynchronisation ................................................................................... 52

3.4.1 Implementierung .................................................................................... 543.5 Forward Error Correction................................................................................. 56

4 Powerline-Communication-Chipsets .....................................................................584.1 Austria Mikro Systeme..................................................................................... 584.2 Intellon.............................................................................................................. 604.3 Echelon............................................................................................................. 624.4 Adaptive Networks........................................................................................... 634.5 Itran Communications ...................................................................................... 644.6 Inari .................................................................................................................. 654.7 Cogency............................................................................................................ 664.8 Überblick der Anbieter..................................................................................... 67

5 Programmierung des PHY-Layers .........................................................................685.1 Aufgabenstellung.............................................................................................. 685.2 Paketaufbau ...................................................................................................... 695.3 Schnittstelle PHY-/MAC-Layer ....................................................................... 705.4 Die serielle Schnittstelle................................................................................... 72

5.4.1 Overlapped/Nonoverlapped Modus ....................................................... 725.5 Multithreading .................................................................................................. 735.6 Synchronisation von Threads ........................................................................... 755.7 Eventgesteuerte Threads................................................................................... 795.8 Programmbeschreibung.................................................................................... 825.9 Test der Bitfehlerrate........................................................................................ 845.10 Übersicht der Funktionen ................................................................................. 86

5.10.1 CRC8( ) .................................................................................................. 865.10.2 CRC16( ) ................................................................................................ 875.10.3 FrameSync( ).......................................................................................... 885.10.4 Encode( ) ................................................................................................ 895.10.5 Puncture( ).............................................................................................. 905.10.6 Decode( )................................................................................................ 915.10.7 GenerateTrellis( ) ................................................................................... 925.10.8 Distance( ) .............................................................................................. 93

INHALTSVERZEICHNIS

III

5.10.9 Compare( ) ............................................................................................. 945.10.10. AddErrors( ) ........................................................................................ 955.10.11. OpenComPort( ) .................................................................................. 965.10.12. PHY_Init( ).......................................................................................... 975.10.13. PHY_Receive( ) .................................................................................. 995.10.14. PHY_Send( ) ..................................................................................... 1015.10.15. PHY_IsCarrier( ) ............................................................................... 1035.10.16. PHY_TestReceive( ) ......................................................................... 1045.10.17. PHY_TestSend( ) .............................................................................. 1055.10.18. MAC_CarrierStateChange( )............................................................. 1065.10.19. MAC_Receive( ) ............................................................................... 107

6 Ausblick ..................................................................................................................1086.1 Mögliche Realisierung eines Powerline-Modems.......................................... 108

7 Quellcode für den Physical-Layer ........................................................................111

8 Literaturverzeichnis ..............................................................................................128

9 Glossar ....................................................................................................................131

1 EINLEITUNG

1

1 Einleitung

Die vorliegende Diplomarbeit entstand im Rahmen eines fächerübergreifenden Projekts desFachbereichs Elektrotechnik und Informationstechnik (EIT) und des Fachbereichs der An-gewandten Informatik im Sommersemester 2002. Studierenden dieser beiden Fachbereichewurde die Möglichkeit damit geboten, sich an einem gemeinsamen Projekt mit Studien- undDiplomarbeiten zu beteiligen.

1.1 Fächerübergreifendes Projekt "Chatroom over Powerline"

Thema dieses Projekts war die Entwicklung eines Chatrooms, welches das hausinterne Ener-gieversorgungsnetz als Kommunikationsmedium nutzte. Unter Anleitung wurden wichtigeKomponenten eines solchen Kommunikationssystems nach modernen Engineering-Methodenvon den Teilnehmern gemeinsam entwickelt. Zur Realisierung der Anwendung wurde die Auf-gabenstellung in vier Teilbereiche gegliedert, die von kleinen Studentengruppen bearbeitetwurden. Die Gruppeneinteilung geschah in Anlehnung an das OSI-Schichtenmodell, welchesauf der obersten Ebene die Anwendung, in unserem Fall den Chatroom, und auf der unterstenEbene die Bitübertragung mittels Powerline-Modem vorsieht. Jede Gruppe bekam einen fach-kompetenten Betreuer sowie einen Moderator zugewiesen. Die Aufteilung der Gruppen sahwie folgt aus:

• Anwendung

• Kommunikations-Middleware

• MAC-Schicht

• Bitübertragungsschicht

In 14-tägigen Sitzungen präsentierten die Moderatoren in Kurzvorträgen die Fortschritte ihrerArbeit. Die anschließenden Gruppendiskussionen boten die Möglichkeit, noch offene Fragenzu erörtern sowie über technische Problemstellungen zu diskutieren. Neben diesen Treffenfanden weitere Gespräche mit den Betreuern und den Gruppen statt, um die Anforderungen dergemeinsamen Schnittstellen untereinander zu besprechen.

Ziele des Projekts waren die Förderung der Teamfähigkeit, Analyse von Problemen, Erarbei-tung von Zielsetzungen, Präsentation der Ergebnisse sowie die praktische Erfahrung für die

1 EINLEITUNG

2

Vorgehensweise in größeren Projekten. Es bot zugleich eine sinnvolle Vorbereitung im Hin-blick auf das spätere Berufsleben in der Industrie.

1.2 Gliederung

Die vorliegende Diplomarbeit behandelt eine Vielzahl an Themengebieten. Daher wird andieser Stelle ein kurzer Überblick der Kapitel gegeben. Das erste Kapitel enthält eine kurzeEinführung in das Powerline-Projekt. Das 2. Kapitel erklärt die Grundlagen der Powerline-Communication und geht dabei auf den Powerline-Kanal, OFDM-Modulation und die gesetz-lichen Rahmenbedingungen ein. Ferne beinhaltet es eine kurze Einführung in das OSI-Refer-enzmodel, da die Gliederung des Projektes nach diesem Vorbild geschah. Kapitel 3 beschreibtdie Kanalcodierung, insbesondere die Faltungscodierung, den Viterbi-Algorithmus, die Punk-tierung, Checksummen und die Rahmensynchronisation. Im 4. Kapitel werden auf dem Markterhältliche Powerline-Modems verschiedener Firmen vorgestellt. Die Implementierung desPhysical-Layers zeigt Kapitel 6 auf. Dort finden sich Programmiertechniken zur Kommunika-tion mit der seriellen Schnittstelle, Paketaufbau und ausführliche Beschreibungen zu jederFunktion des Physical-Layers. Kapitel 6 beinhaltet einen Ausblick, wie eine Weiterent-wicklung in der Powerline-Communication aussehen kann. In Kapitel 7 findet man denQuellcode für den Physical-Layers. Das Literaturverzeichnis befindet sich in Kapitel 8 und einGlossar in Kapitel 9.

1.3 Was ist Powerline-Communication?

Powerline-Communication, häufig auch lediglich Powerline oder PLC genannt, ist nichts an-deres, als die Übertragung von Daten über das existierende Stromnetz. Es stellt somit eine Al-ternative zum herkömmlichen Rechner-Netzwerk dar. PLC beinhaltet eine Reihe vonVorteilen:

• Übertragungsrate von 2,4 kbit/s bis zu über 10 Mbit/s

• ständige Verfügbarkeit

• Nutzung der in jedem Haushalt vorhandenen Stromkabel als Netzwerk – keine Verlegungneuer Kabel

• Zugang zum jeweiligen Haushalt über den Stromanschluss im Keller – letzte Meile, somitKonkurrenz zur Telekom im Ortsnetzbereich

• Vernetzung von Outhouse und Inhouse-Systemen für die Home Automation

• Möglichkeit zur (Fern-) Steuerung der elektrischen Einrichtungen eines Haushalts/Unternehmens (z.B. Audiogeräte, Kühlschrank, Zählerfernablesung oder Alarmanlage).

1 EINLEITUNG

3

1.3.1 Die Marktsegmente

Die Powerline Communication lässt sich hauptsächlich in folgende Bereiche gliedern:

• Home Area Networks mit vielen neuen Möglichkeiten für die Vernetzung unterschiedlich-ster Geräte in Privathaushalten

• Energiedienstleistungen: Zählerfernablesen, Energie- und Lastmanagement

• Automatisierung im Facility Management als Infranet

• Nutzung der PLC Technik als alternative Anschlusstechnologie für die Last Mile in einemderegulierten Telekommunikationsmarkt

1.3.2 Eigenschaften der PLC

Durch die Übertragung der Signale bis in den MHz-Bereich ergibt sich eines der mit der Ein-führung verbundenen Probleme. Denn im Gegensatz zu Telefonleitungen sind Stromkabel ge-gen die Belastung der Umgebung durch Schwingungen hoher Frequenz nicht abgeschirmt.Statt dessen wirkt das Kabel wie eine Sendeantenne und bildet Störfelder. Die Folge sindmögliche negative Einflüsse auf Funknetze, worunter auch der Radioempfang leiden kann.

Störungen durch PLC

Aus diesem Grund unterliegt die Einführung von PLC-Angeboten den Auflagen des Telekom-munikationsgesetzes und des Gesetzes über die elektromagnetische Verträglichkeit vonGeräten. Die notwendige Genehmigung wird von der Regulierungsbehörde für Telekommuni-kation und Post (RegTP) erteilt. Sie liegt momentan noch nicht vor. Das Verfahren ist in derPhase, in der Personenkreise, die von den negativen externen Effekten der PLC betroffen sind,ihre Bedenken vorbringen können (z.B. Amateur-Funker). Die Testinstallationen laufen des-halb z.B. auf Basis von Sondergenehmigungen der Regulierungsbehörde [25].

Knappes Frequenzangebot

Ein Teilaspekt ist beispielsweise, dass die betroffenen Frequenzbänder im wesentlichen bereitsbelegt sind. Sie werden u.a. auch von Polizei und Rettungsdiensten genutzt. Würde eine Re-servierung von Funkfrequenzen durch PLC genehmigt werden, würde eine netzgebundene

1 EINLEITUNG

4

Übertragungsart auch andere Übertragungsressourcen blockieren, was angesichts der z.T. be-reits knappen Frequenzbänder nur bedingt zu vertreten wäre.

Übertragungskapazität

Ein weiterer Nachteil der Technologie ist, dass sich die maximale Übertragungskapazität aufden Empfang bzw. die Signalabnahme an der Trafostation bezieht. Die zur Verfügung stehendeLeistung verteilt sich auf die Haushalte, die an eine Station angeschlossen sind. Je nachdemwie stark das Übertragungsmedium zum jeweiligen Zeitpunkt genutzt wird, kann die Übertra-gungsrate im Extremfall bzw. bei einigen Hundert angeschlossenen Haushalten noch unterISDN-Niveau sinken. Diese Unsicherheit schwächt die Attraktivität. Im Praxiseinsatz muss dieZuverlässigkeit von PLC auch im Hinblick auf die im Stromnetz vorkommenden Schwan-kungen der Datenübertragungseigenschaften gewährleistet sein. Diese Schwankungen könnenbereits beim Einschalten von einzelnen elektrischen Geräten entstehen.

2 GRUNDLAGEN DER PLC

5

2 Grundlagen der PLC2.1 Kommunikationskanal/Modell

In diesem Unterkapitel wird die Stromversorgungsleitung als Kommunikationskanal unter-sucht. Ein Kanal ist definiert als eine physikalische Verbindung zwischen Sender undEmpfänger. Zu beachten ist diesem Zusammenhang, dass das Niederspannungsnetz aus mehr-eren Kanälen mit jeweils eigener Charakteristik und Qualität besteht. Bild 2.1 zeigt ein digi-tales Kommunikationssystem, welches die Stromversorgungsleitung als Kommunikationska-nal benutzt. Der Sender befindet sich auf der linken und der Empfänger auf der rechten Seite.Wichtige Parameter dieses Komunikationssystems sind die Ausgangsimpedanz Zt des Sendersund die Eingangsimpedanz Zl des Empfängers.

Bild 2.1: Digitaler Kommunikations-Kanal für das Niederspannungsnetz

Ein Koppelnetzwerk wird verwendet, um das Kommunikationssystem mit dem Niederspan-nungsnetz zu verbinden. Das Koppelnetzwerk hat zwei Aufgaben. Es schützt einerseits dasKommunikationssystem vor 240V-Netzspannung, welches für die Energieversorgung benutztwird, und andererseits stellt es sicher, dass der größte Teil des empfangenen/gesendeten Sig-nals innerhalb des Frequenzbandes für die Kommunikation liegt.

2.1.1 Koppelnetzwerk

Das Koppelnetzwerk hat die Aufgabe die informationstragenden Signale auf die 50 HzWechselspannung des Stromnetzes aufzuprägen bzw. von ihr abzutrennen [14]. Seine Aufgabeist es, im Sendefall eine größtmögliche Signalamplitude einzuspeisen unter der Berücksichti-gung der zulässigen Grenzwerte. In Empfangsrichtung trennt das Koppelnetzwerk das Infor-

Zt

Zt

Sender Koppel-netzwerk

Powerline-Kanal

Koppel-netzwerk

Empfänger


6

mationssignal von der Netzspannung und unerwünschten Störungen ab. Die bislang in Europafreigegebenen Frequenzen der Informationssignale liegen im Bereich von etwa 95 bis 150kHz.

Zur Signalkopplung wird eine galvanische Trennung mit einem Übertrager benutzt. Der Über-trager besitzt Hochpasscharakter, so dass er die Netzspannung mit den niederfrequenten Stör-ungen unterdrückt. Im Inhouse-Bereich wird das Signal parallel zwischen Nulleiter und einerPhase eingespeist. Im Bereich zwischen Trafostation und Hausanschluss dagegen erfolgt dieKopplung zwischen zwei Phasen.

Es hat sich als vorteilhaft erwiesen, für Sende- und Empfangsseite jeweils getrennte Kopp-lungsnetzwerke zu verwenden. Für die Sendeseite wird eine starke Kopplung verwendet, umdas Sendesignal möglichst ungeschwächt ins Netz einspeisen zu können. Auf der Empfangs-seite hingegen hat sich eine schwache Kopplung bewährt, damit die netzseitige Vormag-netisierung gering wird sowie Störungen unterdrückt werden.

Grundsätzlich lässt sich die Signalkopplung auf der Sendeseite durch Abbildung 2.2. be-schreiben:

Bild 2.2: Sendeseitige Signalkopplung

Auf der Empfangsseite empfiehlt sich eine Anordnung nach Abbildung 2.3.

Bild 2.3: Empfangsseitige Signalkopplung

Ähnlich wie bei der sendeseitigen Signalkopplung wird auch empfangsseitig ein Übertragermit Hochpasscharakter benötigt, um die 50 Hz-Wechselspannung abzukoppeln. Der Hochpassfiltert alle Frequenzen bis zu etwa 20 kHz heraus, da bis zu dieser Frequenz Störungen aus demNetzbetrieb herrühren können.

Sendeendstufe Transienten-schutz

Übertragermit

HochpassStromnetz

vom D/A Wandler u.

Tiefpass

Ue

Übertragermit

Hochpasszum A/D-Wandler

Eingangs-Bandpass

Stromnetz

UaUe


7

2.1.2 Kanalmodell des PLC-Kanals

Die Beeinträchtigungen des PLC-Kanals, welche die Performanz des Kommunikationssystemsreduzieren, teilen sich hauptsächlich auf folgende Ursachen auf:

• Impedanz-Fehlanpassung am Sender

• Kanaldämpfung

• Störungen durch Rauschen

• Impedanz-Fehlanpassung am Empfänger

• Zeitvariante Beeinträchtigungen

Bild 2.4 zeigt ein Modell des Powerline-Kanals für obige Beeinträchtigungen. Alle Effekte mitAusnahme des Rauschens werden durch zeitvariante lineare Filter, welche durch denFrequenzgang charakterisiert sind, dargestellt [12]. Die zufälligen Störungen werden durchadditives Rauschen berücksichtigt.

Bild 2.4: Beeinträchtigungen im Powerline-Kommunikationskanal

Alle diese Beeinträchtigungen können zu einem einzigen Filter-Modell, bestehend aus einemzeitvarianten Filter und additivem Rauschen, zusammengefasst werden, wie es Bild 2.5 zeigt.

Bild 2.5: Vereinfachtes Powerline-Kommunikations-Modell

Trotz seiner einfachen Form umfasst dieses Modell eine ganze Reihe an Eigenschaften, welchefür den Entwurf des Kommunikationssystems und der zugehörigen Performanz grundlegend


8

sind. Die Übertragungsfunktion des Systems kann entweder durch Messungen geschätzt oderdurch theoretische Analysen abgeleitet werden.

2.1.3 Dämpfung eines PLC-Kanals

Der Widerstand in einer Leitung wächst bei Wechselstrom mit der Quadratwurzel der Fre-quenz wegen des Skineffektes. Des Weiteren sind dielektrische Verluste in den Isolier-materialien zu berücksichtigen, welche zu einer frequenzproportionalen Erhöhung der Ab-leitverluste führen.

2.1.4 Zeitvariantes Verhalten des Netzes

Ein Problem des Powerline-Kanals ist die Zeitvarianz der Beeinträchtigungen. Die Rauschleis-tung und die Dämpfung hängen teilweise von dem Verbund der angeschlossenen Lasten ab, diezeitlich variieren. Ein zeitvarianter Kanal erschwert den Entwurf eines Kommunikationssys-tems. In manchen Zeiträumen wird die Kommunikation gut verlaufen, in anderen Zeiträumenallerdings wird eine starke Rauschquelle den Kanal beeinträchtigen und den Kommunikations-kanal eventuell blockieren. Um dieses Problem zu lösen, verwendet man Kommunikationssys-teme, die sich dem Kanal anpassen [12]. Die Charakteristiken des Kanals werden fortlaufendgeschätzt, z. B. durch Messungen. Die Ergebnisse werden dazu verwendet, bessere Ent-scheidungen im Empfangsprozess zu treffen. Durch das zeitvariante Verhalten wird die Kom-plexität des Systems erhöht.

2.1.5 Störungen in der Stromleitung

Die Stromleitung als Kommunikationskanal ist gekennzeichnet durch eine nach Zeit und Fre-quenz variierende Impedanz. Darüber hinaus gibt es einen wechselnden Pegel von Interferenz-Signalen, Impuls-Störungen und durch Schalten hervorgerufene Störungen. Geräte, die ammeisten zum Störungspegel beitragen, sind u.a. Netzschalter, Bildschirme, induktiveHeizgeräte, Dimmer, Radiostationen und Frequenzwandler. Um Auswirkungen dieser Stör-ungen vorzubeugen, wurden bereits erhebliche Entwicklungsanstrengungen im Bereich Kanal-codierung, Forward error correction (siehe Kapitel 3.5), dynamische Adaptivität und minimaleSNR-Anforderungen für verlässliche Signalerkennung unter den speziellen Störungsbeding-ungen im Stromnetz unternommen. Des Weiteren wurden kostengünstige Zusatzgeräte ent-wickelt, um den Effekt bei kritischen Störquellen wie zum Beispiel Geräten mit Schaltnetz-teilen zu eliminieren.


9

2.2 Übertragungsverfahren OFDM

Powerline-Modems übertragen die Daten anders als zum Beispiel Netzwerkkarten oder Tele-fon-Modems nicht im Basisband. Die Daten werden im Powerline-Kanal in höheren, von derCENELEC (Commité Européen de Normalisation Electrotechnique) freigegebenen Frequenz-bändern übertragen, sodass ein neues Modulationsverfahren erforderlich wird, um den Daten-strom aus dem Basisband in die dafür vorgesehenen Frequenzbänder zu verschieben (sieheAbschnitt 2.3). Der Nachteil bei der FSK-Modulation in den CENELEC-Bändern liegt in derniedrigen Datenübertragungsrate. Neue Entwicklungen für die Übertragung via Powerline ver-wenden die OFDM-Modulation , welche sich bei höheren Übertragungsraten etabliert hat [24],[13]. Einige Anbieter derartiger Powerline-Modems finden sich in Kapitel 4.

Die Abkürzung OFDM steht für “Orthogonal Frequency Division Multiplexing”. Anstatteinem einzelnen, breiten Träger, kommen bei diesem Modulationsverfahren viele schmaleTräger zum Einsatz. Das Modem teilt zu diesem Zweck den zu sendenden seriellen Daten-strom (beispielsweise 1 x 200 kbit/s) in mehrere parallele Datenströme auf (etwa 4 x 50 kbit/s).Das Besondere der OFDM-Modulation ist, dass es die Nutzinformation auf viele Kanäle soverteilt, dass deren Nominal-Frequenzen in spektralen Nullstellen ihrer Nachbarkanäle liegen.Dadurch kann das Frequenzspektrum besser ausgenutzt werden, und es lässt eine aufwendigeKanalentzerrung, die bei Modulationsverfahren mit nur einem Träger notwendig wäre, ent-fallen.

Theoretisch ließe sich dieses Multiplexing durch Ansteuerung einer Vielzahl von Signalgene-ratoren mit den parallelen Datenströme realisieren, wobei jeder einzelne Signalgenerator exaktauf eine Frequenz abgestimmt sein müsste. Da diese Realisierung einen zu hohen Aufwand be-deutet, bedient man sich in der Praxis der Inversen-Fourier-Transformation. Durch die IFFT(Inverse Fast-Fourier-Transformation) transformiert man das Modulationssignal für jeden ein-zelnen Träger in den Zeitbereich. Die Realisierung der IFFT geschieht beispielsweise mit demCooley-Tukey-Algorithmus. Ein Nachteil dieses Verfahrens ist jedoch der steigende Rech-enaufwand mit der Anzahl der Träger.

Da bei der IFFT-Modulation Seitenbänder entstehen, die nach der Fourier Transformation imAbstand der Übertragungsrate zu Null werden, wählt man diesen Frequenzabstand für dieTrägersignale. Der Abstand der Trägerfrequenzen entspricht bei OFDM derÜbertragungsgeschwindigkeit des modulierten Signals. Soll also beispielsweise ein 1-Mbit/s-Signal mittels OFDM über zehn Trägerfrequenzen, die jeweils mit 100 kbit/s moduliert wer-den, übertragen werden, dann ist der optimale Abstand der Trägerfrequenzen 100 kHz.

Die Vielzahl der Träger im OFDM-Verfahren gewährleistet bei den für den Powerline-Kanaltypischen schmalbandigen Störungen und Dämpfungsmaxima, dass ein Großteil der Träger


10

unbeeinträchtigt bleibt. Zusammen mit einer Forward Error Correction (FEC, siehe auch Kapi-tel 3) bieten OFDM-Modems eine sichere Übertragungsart, da der Empfänger aus dengestörten Eingangsdaten die fehlerhaften Bits rekonstruieren kann. Diese Kombination ausFEC und OFDM wird auch COFDM (Coded Orthogonal Frequency Division Multiplexing)genannt. Weitere Vorteile dieses Verfahrens sind die gezielte Ausblendung von Trägern, die ingestörten Frequenzbereichen liegen und die Möglichkeit die einzelnen Subträger je nach ihrerÜbertragungsqualität unterschiedlich zu modulieren. In Verbindung mit einem Schutzintervallist das OFDM-Verfahren unempfindlich gegen Echokanäle und eignet sich daher auch be-sonders bei stark beeinträchtigter terrestrischer Funkübertragung wie beim Digitalen RadioDAB.

Neben den genannten Vorteilen existieren jedoch auch einige Nachteile der OFDM-Technik.Der Verstärker des Senders benötigt über einen weiten Dynamikbereich eine möglichst lineareAuslegung. Zwischen Sender und Empfänger wird eine sehr präzise Synchronisation benötigt,weil die einzelnen Träger aufgrund ihrer Vielzahl sehr schmalbandig ausgelegt sind.

2.2.1 Multiplexing

Die zu übertragenden digitalen Datenströme D(t) werden beim OFDM-Verfahren durchAufteilung (Multiplexing) in n parallel laufende Datenströme Di(t) zerlegt, mit i = 1 ... n. DieTaktfrequenzen der Datenströme Di(t) werden um den Faktor n gegenüber dem zu über-tragenden Datenstrome D(t) verkleinert. Bild 2.6 gibt den Fall für n = 4 wieder.

Bild 2.6: Aufteilung (Multiplexing) des zu übertragenden Datenstromes bei OFDM in n = 4 Datenströme mit niedrigerer Datenrate

D(t)

tD1(t)

D2(t)

D3(t)

D4(t)

t

t

t

Multiplexing


11

Beim Multiplexing werden also n Bits zur gleichen Zeit übertragen. Die Datenrate der einzel-nen Teilströme sinkt hierbei um den Faktor 1/n gegenüber dem ursprünglichen Signal ab.Damit sich die vielen Teilsignale Di(t) (i = 1 ... n) gegenseitig nicht beeinflussen, werden sieauf schmalbandigen Trägern gesendet, die sich in der Mittenfrequenz derart unterscheiden,dass alle Teilsignale orthogonal zueinander stehen. Im Frequenzbereich S(f) erkennt man deut-lich die orthogonale Eigenschaft der Teilsignale. Auf jeder einzelnen Frequenz fi sind dieAmplituden aller Teilsignale bis auf eines jeweils Null, wodurch eine gegenseitige Störungausgeschlossen wird. Bild 2 verdeutlicht diese grundlegende Eigenschaft der OFDM-Modula-tion für den Fall n = 4.

Bild 2.7: Bild 2: Orthogonale Träger – bei den Mittenfrequenzen eines Trägers beträgt die Amplitude aller anderen Träger Null

t

f

S(f)f0 f1 f2 f3 f4 f5

Trägermittenfrequenzen

D1(t) D2(t) D3(t) D4(t)


12

2.2.2 Modulation und Demodulation

Im Allgemeinen kann man ein digitales OFDM-Übertragungssystem mit Abbildung 2.8 be-schreiben.

Bild 2.8: Bild 3: Grobstruktur eines OFDM-Übertragungssystems

Das ursprüngliche Datensignal wird durch einen Multiplexer in die Datenströme Di(t) (i = 1 ...n) aufgesplittet. Danach gelangen die einzelnen digitalen Datenströme Di(t) (i = 1 ... n) in denModulator des Senders. Im Modulator werden diese parallelen digitalen Signale in ein analo-ges Signal mittels IFFT umgewandelt. Eine mögliche Realisierung besteht in der Ansteuerungvon n schmalbandigen Signalgeneratoren, welche von jedem einzelnen Datenstrom Di(t) ge-trennt angesteuert wird. Das zu sendende Ausgangssignal ergibt sich somit aus der Additiondieser Einzelsignale. In der Praxis wäre der Hardwareaufwand jedoch zu hoch, so dass maneinen anderen Weg geht. Heutige OFDM-Systeme verwenden hierzu die IFFT (Fast-Fourier-Transformation). Im Falle der in Abbildung 2.7 verwendeten Modulationsart (BPSK, BinaryPhase Shift Keying) lässt sich das abgetastete Ausgangssignal y(ta) der Senders durch folgendemathematische Gleichung (2.1) darstellen. fi sind hierbei die Trägerfrequenzen.

(2.1)

Eine zeiteffiziente Berechnung der inversen diskreten Fourier-Transformation (IDFT) ermögli-cht der Cooley-Tukey-Algorithmus, welcher blockweise n Abtastwerte des zu sendenden Sig-nals y(t) generiert. Diese Realisierung zeichnet sich durch einen geringen Rechenaufwand ausund kann problemlos mit heutigen digitalen Signalprozessoren (DSPs) umgesetzt werden, weilsie auf den FFT-Algorithmus optimiert sind.

Übertragungs-Strecke

D1(t)

D2(t)

D3(t)

Dn(t)

y(t)D(t)

D1e(t)

D2e(t)

D3e(t)

Dne(t)

De(t)ye(t)

Störungen

Mul

tiple

xer

Mod

ulat

or

Dem

odul

ator

Dem

ultip

lexe

r

y ta� � Di ta� � 2�fita� �cos�

i 1=

n

� Re Di ta� � ej2� fi ta� �

�

i 1=

n

��

= =


13

Auf Empfängerseite wandelt der Demodulator die empfangenen analogen Signale wieder indie digitalen Datenströme Di(t) zurück und der Demultiplexer stellt aus den digitalen Teilda-tenströmen wieder das ursprünglich gesendete Datensignal D(t) her. Das analoge Sendesignaly(t), welches am Modulator durch inverse Fourier-Transformation entsteht, wird dement-sprechend am Demodulator durch Fourier-Transformation zurückgewonnen. Man verwendetauch hierbei den Algorithmus der schnellen Fourier-Transformation (FFT).

2.2.3 Einfügen von Schutzintervallen

Wie man in Abbildung 2.7 erkennen kann, ist die Einhaltung eines korrekten Frequenzab-standes der einzelnen Träger eine wichtige Bedingung für die Orthogonalität. Andernfalls lässtsich das ursprüngliche Datensignal nicht mehr eindeutig aus dem empfangenen Signal zurück-gewinnen.

Durch die Impulsantwort des Kanals kommt es zu einer weiteren Schwierigkeit bei der Über-tragung, welche sich in der so genannten Intersymbolinterferenz (ISI) bemerkbar macht. Einrealer Übertragungskanal besitzt ein für ihn charakteristisches dynamisches Verhalten, welchesdurch die Impulsantwort beschrieben wird. Sendet man am Eingang des Übertragungskanalseinen Impuls, vergeht am Ausgang eine gewisse Zeit bis am Ausgang alle Reaktionen auf dieAnregung abgeklungen sind. Die Dauer T der Impulsantwort wird gemessen und wird späterfür die Dauer des Schutzintervalls benötigt. Das durch eine Rechteckfunktion hervorgerufeneAusgangssignal kann Abbildung 2.9 entnommen werden.

Bild 2.9: Antwort auf ein Rechtecksignal

In Abbildung 2.10 kommt es durch zwei in dichter Abfolge gesendeter Rechteckfunktionen zueiner Überlappung der empfangenen Signale, weil der zeitliche Abstand T der Impulsantwortzwischen den Rechteckfunktionen unterschritten wurde. Diese Verzerrung am Empfängerkann Datenverlust verursachen.

Bild 2.10: Überlappungen im Empfangssignal

t t

Sendesignal Empfangssignal

Übertragungsstrecke

t t




14

Abbildung 2.11 zeigt eine Möglichkeit diese Verzerrung zu vermeiden, indem der zeitlicheAbstand der gesendeten Rechteckfunktionen größer als die Länge T der Impulsantwortgewählt wurde.

Bild 2.11: Schutzintervalle vermeiden Intersymbol-Interferenzen

Ein Bit wird vor der unerwünschten Intersymbol-Interferenz geschützt, wenn zwischen zweigesendeten Bits ein so genanntes Schutzintervall eingefügt wurde. Das Schutzintervall solltegrößer als die Dauer T der Impulsantwort des Kanals sein. Ein Nachteil dieses Schutzintervallsist jedoch die daraus resultierende niedrigere Datenrate bei der Übertragung. Die effektiveDatenrate kann durch ein im Verhältnis zur Zeitdauer eines Datenbits sehr langes Schutzinter-vall stark verringert werden. Das Schutzintervall wird bei OFDM durch periodische Fort-setzung des OFDM-Blocks erreicht.

Der Multiplexer aus Abbildung 2.6 generiert aus dem mit der Frequenz f getaktetem Daten-strom D(t) mehrere Datenströme Di(t) der Taktrate f/4. Fügt man ein Schutzintervall der Zeit-dauer 1/f vor dem Multiplexer ein, halbiert sich die Datenrate von D(t). Das Einfügen des glei-chen Schutzintervalls nach dem Multiplexer jedoch verringert die Datenrate nur um f/5. Dasich dieser Effekt der Datenratenreduktion um so mehr verringert, je größer die Anzahl derTräger ist, kann man die zeitliche Dauer der Schutzintervalle vergrößern ohne merkenswerteEinbuße der Datenrate.

Wenn man die Trägeranzahl n erhöht, verkleinert sich im Gegenzug die Datenrate der Teilda-tenströme Di(t) und die Symboldauer vergrößert sich. Damit lassen sich in der OFDM-Modu-lation beispielsweise lang andauernde Echos unterdrücken ohne den zusätzlichen Aufwandeines Echoentzerrers. Durch die erhöhte Trägeranzahl steigt aber der Rechenaufwand im FFT-Algorithmus. Denn die Anzahl der notwendigen komplexen Multiplikationen beträgt .

2.2.4 Impulsstörungen

Übertragungsstrecken sind im Allgemeinen durch eine Vielzahl unterschiedlicher Störungengeprägt. Das OFDM-Verfahren zeichnet sich besonders widerstandsfähig gegenüber Im-pulsstörungen aus. Impulsstörungen sind gekennzeichnet durch Signale, die über eine kurzeZeit eine hohe Amplitude vorweisen. Dadurch stören sie im Frequenzspektrum einen sehr

t tSchutzintervall



Schutzintervall

n2--- ld n( )�


15

breiten Bereich. Es nützt daher wenig die Informationsdaten über ein breites Spektrum zuverteilen, weil gerade dann Impulsstörungen Schwierigkeiten bereiten können. Durch dieVerteilung der Daten auf mehrere Träger und der damit verbundenen zeitlichen Ausdehnungder OFDM Symbole, können zeitlich kurze Impulse die Daten bei OFDM-Übertragung kaumbeeinflussen. Bei Modulationsverfahren mit nur einem Träger dagegen ist eine gezielte Anpas-sung an die Impulsstörungen nötig, um die gleiche Robustheit zu erhalten. Zu diesem Zweckwerden beispielsweise Limiter zur Amplitudenbegrenzung und Kanalcodierung verwendet.

2.2.5 Differenzielle Modulation

Das OFDM-Verfahren zeichnet sich weiterhin durch eine vereinfachte Kanalentzerrung bei ho-hen Übertragungsraten aus. Bei der Kanalmodellierung genügt es, einen schmalen Bereich desFrequenzbandes für jeden einzelnen Träger zu betrachten. Vereinfacht lässt sich jeder dieserUnterkanäle als ein Übertragungsglied mit fester Dämpfung und konstanter Phase darstellen.Eine Kanalentzerrung für jeden einzelnen Unterkanal ist zwar nicht sehr rechenintensiv, dennsie besteht aus einer komplexwertigen Multiplikation. Sie lässt sich jedoch für das OFDM-Ver-fahren durch differenzielle Modulationsverfahren ganz vermeiden und unbekannte Dämpfun-gen oder Phasenlagen müssen nicht ermittelt werden. Denn ein genauer Dämpfungswert bzw.eine genaue Phasenlage eines solchen Unterkanals ist nur dann wichtig, wenn die absoluteAmplitude bzw. Phase des gesendeten Signals bestimmt werden muss. Bei Einträger-Verfahr-en, welche über einen größeren Frequenzbereich gespreizt sind, ist hingegen meist eine auf-wendigere Kanalentzerrung nötig, um eine sichere Datenübertragung zu gewährleisten.

2.2.6 Nachteile von OFDM

Durch die längere Symboldauer der Datenströme Di(t) (i = 1 ... n) benötigen die moduliertenTräger eine kleinere Bandbreite im Frequenzbereich. Diesem Vorteil stehen jedoch auchNachteile entgegen. Um ein vorgegebenes Frequenzband vollständig auszunutzen, wird eineVielzahl an Trägern verwendet. Je mehr Träger benutzt werden, desto mehr Punkte müssenwährend der Fourier-Transformation bei der Modulation sowie der Demodulation im OFDM-Verfahren berechnet werden. Die Zunahme der Komplexität in der Berechnung lässt den Re-alisierungsaufwand steigen. Da die Bandbreite der einzelnen Träger relativ gering ist, muss derEmpfänger sehr genau mit dem Sender synchronisiert werden, um bei der Demodulation dieWiedergewinnung der Daten zu gewährleisten. Bei der Realisierung eines OFDM-Systemsmuss daher ein Kompromiss zwischen Schmalbandigkeit und der damit verbundenen längerenBitdauer und einer aufwändigeren Synchronisation gefunden werden.


16

2.2.7 Anforderungen an den Sendeverstärker

Das Ausgangssignal am Sender y(t) ergibt sich aus der Überlagerung der Modulation derstatistisch unabhängigen Teildatenströme Di(t) (i = 1 ... n). Die statistische Unabhängigkeit derTeildatenströme folgt aus der Annahme der statistischen Unabhängigkeit des ursprünglichenDatenstromes D(t). Daher lässt sich die Amplitudenverteilung des analogen Ausgangssignalsy(t) (für große n) nach dem Zentralen Grenzwertsatz der Wahrscheinlichkeitstheorie durch eineGaußverteilung annähern.

Der Sendeverstärker, der die meiste Zeit mit relativ kleinen Signalamplituden angesteuertwird, sollte einen großen linearen Dynamikbereich aufweisen. Denn mit einer kleinen Rest-wahrscheinlichkeit treten zu bestimmten Zeiten sehr hohe Signalamplituden auf. In diesemFall der Übersteuerung treten nichtlineare Effekte aufgrund der Signalbegrenzung auf und ge-hen einher mit Störungen der Nachbarkanäle. Da der Sendeverstärker in der Regel nur übersehr kurze Zeitbereiche übersteuert wird, kann diese Begrenzung des Sendesignals auf derEmpfangsseite vernachlässigt werden. Durch die lange Symboldauer können Impulsstörungensowie kurzeitige Übersteuerungen die Datenübertragung kaum beeinträchtigen.

2.2.8 Schmalbandige Störungen

Eine weitere Art der Störung in Energienetzen sind sinusförmige schmalbandige Störungen.Sie können aufgrund ihrer Schmalbandigkeit nur einen kleinen Frequenzbereich und damit nurwenige Unterträger stören. Auf den höheren Frequenzbereichen im MHz-Bereich beobachtetman schmalbandige Störer meist auf festen Frequenzen, da sie ihre Ursache oft in Mittel- undKurzwellensendern haben. Ein lernfähiges OFDM-System erlaubt es, in einer anfänglichenTestphase die gestörten Frequenzen ausfindig zu machen und seine Übertragung daraufhin an-zupassen. Die Anpassung geschieht durch Veränderung der Punktierung in der Kanal-codierung, durch die Modulationsart pro Unterträger oder durch „ausblenden“ gestörter Über-tragungskanäle, wie es in Abbildung 2.12 dargestellt wird.


17

Bild 2.12: Ausblenden von Unterträger gegen schmalbandige Störungen

Durch eine ständige Anpassung des Übertragungsverfahrens an den Kanal zu periodischenZeitabständen wird eine hohe und sichere Datenübertragung erreicht. Neben den schmalban-digen Störungen treten in hausinternen Stromnetzen oft durch Dimmer verursachte periodischeStörsignale sowie durch Schaltvorgänge kurzzeitige Impulse auf. Die periodischen Störungenlassen sich leicht mit Codierverfahren begrenzen. Es ist jedoch schwierig ein Verfahren zu ent-wickeln, welches gleichzeitig gegen gelegentliche Impulsstörungen sowie gegen periodischeStörungen wirkt. OFDM bietet daher durch seine generelle Robustheit gegenüber Impuls-störern eine interessante und effektive Alternative zu aufwendigen Codiermaßnahmen.

2.2.9 Kanalkapazität

Die durch die Shannon’sche Kanalkapazität begrenzte maximale Übertragungsgeschwin-digkeit erreicht bei OFDM-Modulation etwa ein Drittel der Kanalkapazität C, die durchFormel (2.2) gegeben ist [31].

(2.2)

Hierbei entspricht B der Bandbreite des Übertragungskanals und SNR dem zugehörigen Sig-nal-Rausch-Verhältnis. Die maximale Übertragungsgeschwindigkeit d ist damit abhängig vonvon der Bandbreite B sowie vom SNR. Sie berechnet sich demnach aus Gleichung (2.3).

(2.3)

Legt man beispielsweise eine Bandbreite von , wiesie die CENELEC B- und D-Bänder (siehe Abschnitt 2.3) vorgeben, zugrunde , ergibt sich bei

Unterträger

Frequenz

Störleistungs-

Störspektrum

ausgeblendeter Unterträgerdichte

C B ld 1 SNR+� ��=

d 13--- B ld 1 SNR+� ��

B BB BD+ 30kHz 8 5kHz�+ 38 5kHz�= = =


18

einem Signal-Stör-Verhältnis von ungefähr 35 dB, wie es in Haushalten anzutreffen ist, einemaximale Übertragungsgeschwindigkeit von . Verringert sich das SNR auf 20 dB,können mittels OFDM nur noch übertragen werden.

In Abbildung 2.13 findet man ein charakteristisches Sende-, Empfangs- und Rauschspektrum,wie es in einer normalen Büroumgebung vorkommen kann. Hierbei wurde eine Übertra-gungsstrecke von etwa 50 m zugrunde gelegt. Im Rauschspektrum sind bei 11, 12 und 14 kHzschmalbandige Störungen anzutreffen, wie sie durch Computermonitore hervorgerufen werdenkönnen. Im Durchschnitt beträgt das Signal-Stör-Verhältnis zwischen Empfangs- und Rausch-spektrum etwa 35 - 40 dB.

Bild 2.13: Sende-, Empfangs- und Rauschspektrum bei OFDM-Modulation im In-House-Bereich [26]

Gestörte Frequenzbereiche können durch das OFDM-Verfahren gezielt von der Übertragungausgenommen werden. Die Information wird über die ungestörten Frequenzen gesendet. DasSNR braucht dabei nicht über die gesamte Kanalbandbreite konstant sein, denn das OFDM-Verfahren beinhaltet die Möglichkeit, den Trägerfrequenzen dynamisch einen gewissen Infor-mationsgehalt je nach SNR im betreffenden Frequenzbereich zuzuordnen. Dies nennt manauch QAM-Adaptivität. Obige Formeln sind dann so zu modifizieren, dass die Einzelka-pazitäten für die Frequenzen fi mit den Bandbreiten Bi für das SNR(fi) nach Gleichung (2.4)addiert werden.

(2.4)

d 150kbit s �

d 85kbit s �

C Bii

� ld 1 SNR fi� �+� ��=


19

2.3 Standardisierung der Powerline-Communication

Es gibt mehrere verschiedene PLC Standards für Low-Speed-PLC wie z.B. EIB, EHS, Batibusin Europa und CeBus in den USA. Für Medium- und High-Speed-PLC gibt es zurzeit keinendefinierten Standard. Zu den möglichen zukünftigen Standards gehören PLCforum, Home-Plug, Echonet und weitere.

Die Trägerfrequenzen für die binäre Datenübertragung über die Stromleitung liegen deutlichüber den für den Elektrizitätstransport standardisierten Frequenzen von 50 bzw. 60 Hz. Dievon der europäischen CENELEC-Norm EN50065-1 [11] definierten Frequenzbänder sind je-doch verhältnismäßig schmal. In USA dürfen beispielsweise Trägerfrequenzen bis zu 450 kHzgenutzt werden, während in Europa die Grenze bei nur 148,5 kHz liegt. Daher sind in EuropaTechnologien, die eine große Bandbreite benötigen, wie beispielsweise Spread-Spectrum, nurbedingt einsetzbar. Werden Powerline Produkte, die für den amerikanischen Markt entwickeltwurden, so verändert, dass sie die europäischen Normen erfüllen, ist dies meist mit einer er-heblichen Reduzierung der Übertragungsgeschwindigkeit verbunden. Verfahren, die ein relativschmales Frequenzband nutzen und ein kleines Signal-Rausch-Verhältnis zur sicherenDatenerkennung benötigen, sind hier besser geeignet.

Heute übliche Standards sind:

• Europa: CENELEC: EN 55022 (CISPR 22), CISPR 24, EN 50065-1

• USA: FCC: Part 15 Subpart B

• Kanada: Canada Industry: ICES-006

2.3.1 Regulierungen in Europa

Das Europäische Komitee für Elektrotechnische Normung in Brüssel (CENELEC) hat mit derNorm EN50065-1, [11] den Rahmen für die Powerline-Kommunikation in Europa festgelegt.Sie wurde von der Deutschen Elektrotechnischen Kommission als DIN-EN50065-1 und vomVDE als Klassifikation VDE0808 übernommen und sieht vier unterschiedliche Frequenz-bänder vor:

• Das A-Band (9 kHz - 95 kHz) ist für Energieversorgungsunternehmen reserviert,

• das B-Band (95 kHz - 125 kHz) welches von allen Anwendungen innerhalb des Hausesohne Zugriffsprotokoll genutzt werden kann,

• das C-Band (125 kHz - 140 kHz), das für Home-Automation-Anwendungen vorgesehenist. Ein vorgeschriebenes Zugriffsprotokoll (CSMA/CD = Carrier Sense Multiple Access/


20

Collision Detection) ermöglicht die Koexistenz verschiedener, inkompatibler Systeme indiesem Frequenzband; und schließlich

• das D-Band (140 kHz - 148,5 kHz), das Alarm- und Sicherheitssystemen ohne Zugriffs-protokoll vorbehalten ist.

Für alle vier Frequenzbänder werden von der EN50065-1 die maximalen Signalpegel zur Mo-dulation auf das Stromversorgungsnetz definiert (Bild 2.14). Für Home-Automation-Anwen-dungen ist das C-Band mit einem Signalpegel von höchstens 116 dB(µV) bestens geeignet, dahier ein besonderes Medien-Zugriffsprotokoll gefordert wird.

Bild 2.14: Maximale Signalpegel im Frequenzbereich von 3kHz bis 148,5kHz

Zur Bestimmung des Ausgangspegels muss das Signal mit einem Spitzenwertdetektor bei ein-er vorgeschriebenen Messschaltung über einen Zeitraum von 1 Minute gemessen werden.

Daneben legt die EN50065-1 für alle elektrischen Geräte am Stromversorgungsnetz Stör-leistungsgrenzwerte in den entsprechenden Frequenzbändern fest. So wird eine parasitäre Be-einflussung der Powerline-Communication aufgrund von Störungen anderer Verbraucher ver-mieden.


21

2.3.2 Medien-Zugriffsprotokoll im CENELEC-C-Band

Im CENELEC-C-Band ist die Einhaltung eines Medien- Zugriffsprotokolls erforderlich(CSMA/CD). Dieses legt einen Frequenzbereich um die Bandmitte fest, auf dem der Signalpe-gel eine gewisse Zeit lang unterhalb von 80 dB(µV) liegen muss bevor mit dem Senden begon-nen werden kann. So lassen sich „Kollisionen“ verhindern, bei denen zwei Stationen gleich-zeitig senden. Außerdem ist die maximale Dauer für jeden Sendevorgang begrenzt, was einerGleichberechtigung der Kommunikationspartner entgegenkommt.

Das Medien-Zugriffsprotokoll wirkt dem Effekt entgegen, der zurzeit im 433 MHz-ISM-Bandzu beobachten ist: Bekanntlich kommt es hier aufgrund einer völligen Freigabe immer wiederzur ungewollten gegenseitigen Beeinflussung verschiedener Systeme im Feld. In Hinblick aufeine verstärkte Nutzung der Powerline-Frequenzbänder, vor allem auch von hochwertigen undhochdatenratigen Anwendungen wie Telefonie oder Internet-Dienste, gewährleistet dasCENELEC-C-Band sowohl eine kostengünstige als auch eine zuverlässige Kommunikation. Inden anderen Frequenzbändern (B- und D-Band) ist auf Dauer eine ähnliche Situation wie beimbesagten 433 MHz-ISM-Band zu erwarten, und es wird sich nur noch mit erheblichem Auf-wand eine ausreichende Zuverlässigkeit erreichen lassen.

Die Abbildungen 2.15 bis 2.17 zeigen die Regeln, die von der EN50065-1 bei der Nutzung desC-Bandes eingehalten werden müssen. Die gesamte Dauer des Sendevorgangs einer Station(Sender A) darf demnach nicht länger als 1 Sekunde sein (Abbildung 2.15). Während dieserZeit dürfen keine „Übertragungslücken“ von mehr als 80 ms entstehen, da sonst anderesendewillige Stationen das Medium als frei erkennen könnten. Nach Abschluss der Übertra-gung muss der Sender eine Pause von mindestens 125 ms einhalten, um den anderen Stationenebenfalls die Möglichkeit für einen Sendevorgang einzuräumen (Abbildung 2.16). Eine andereStation (Station B) darf bereits nach frühestens 85ms mit der Übertragung beginnen (Abbil-dung 2.17).

Bild 2.15: Maximale Übertragungsdauer


22

Bild 2.16: Zeit zwischen zwei Sendevorgängen von einem Sender

Bild 2.17: Zeit zwischen den Sendevorgängen von zwei Sendern

2.3.3 Regulierungen in USA

Nach den Vorschriften der FCC (Federal Communications Commission) Part 15 werden PLCSysteme für Inhouse-Anwendungen als "Carrier Current Systems" bezeichnet und arbeiten alsunbeabsichtigte Strahler. Im Bereich von 535 kHz bis 1705 kHz (Mittelwellenradio) ist der lei-tungsgeführte Ausgangspegel auf 60 dBµV (Quasipeak-Detektor, 9 kHz Bandbreite,Netznachbildung nach CISPR 16) begrenzt.

Tabelle 2.1: Grenzwerte für Strahlungsemissionen:

Frequenzbereich in MHz Feldstärkengrenze in dBµV/m Messab-stand in m

0.009 - 0.490 48.5 - 13.8 300

0.490 - 1.705 33.8 - 23 30

1.705 - 30 29.5 30


23

Grenzwerte oberhalb von 30 MHz existieren, sind aber in dieser Liste nicht aufgeführt. DerDetektor ist ein Mittelwert-Detektor unterhalb von 490 kHz, Quasipeak auch von 90-110 kHz.Die Messbandbreite ist 200 Hz unterhalb von 150 kHz und 9 kHz oberhalb von 150 kHz.

2.3.4 Regulierungen außerhalb Europas und der USA

Nach der internationalen Norm IEC 61000-3-8: 1997-08 dürfen PLC Systeme den Frequenz-bereich von 3 kHz bis 525 kHz benutzen. Gleichtakteinspeisung ist nicht zulässig. Die Grenz-werte der Ausgangspegel sind (geplant in ITU Region 3: Asien/Pazifik)

Tabelle 2.2: Ausgangspegelgrenzwerte

Sofern ein Land kein Mitgliedstaat der EU und kein Mitglied von CENELEC ist, muss im De-tail geklärt werden, welche Vorschriften anzuwenden sind.

2.3.5 Die Nutzungsbestimmung 30

Der Bundesrat verabschiedete am 30. März 2001 drei Verordnungen, die die Powerline-Nutz-ung rechtlich absichern. Voraussetzung: Andere Funkdienste dürfen nicht beeinträchtigt wer-den. Die Nutzungsbestimmung 30 (NB 30) der Regulierungsbehörde bestimmt ab 1. Juli 2001gültige “Grenzwerte für Störfeldstärken in und längs von Leitern”, die zum einen sicherstellensollen, dass Funkdienste nicht unangemessen gestört werden und zum anderen neue telekom-munikative Dienste wie Powerline nicht von vornherein verhindert werden. NB 30 beinhalteteinen Stufenplan für Störungsfälle, der nach dem Muster Störung lokalisieren, Störung be-seitigen und im Worst Case abschalten, allen Eventualitäten vorbeugen soll.

Die Nutzungsbestimmung 30 enthält die folgenden Bestimmungen:

(1) In und längs von Leitern können Frequenzen für Telekommunikationsanlagen (TK-An-lagen) und Telekommunikationsnetze (TK-Netze) im Frequenzbereich von 9 kHz bis 3 GHzfreizügig genutzt werden,

Frequenzbereich Ausgangspegelgrenzwerte

9 -95 kHz 134 dBµV

95 - 148,5 kHz 116 dBµV (134 dBµV in Industriegebieten)

148,5 - 500 kHz 66 - 56 dBµV, linear abnehmend mit dem Logarithmus der Frequenz

500 - 525 kHz 56 dBµV


24

1. wenn die Frequenznutzung in Frequenzbereichen erfolgt, in denen keine sicherheitsrelevan-ten Funkdienste betrieben werden,

2. und wenn am Betriebsort und entlang der Leitungsführung im Abstand von 3 Metern zurTK-Anlage bzw. zum TK-Netz oder zu den angeschalteten Leitungen die Störfeldstärke(Spitzenwert) der Frequenznutzung die Werte von Tabelle 1 nicht überschreitet; die Messungder Störfeldstärke erfolgt auf der Grundlage geltender EMV-Normen entsprechend der Mess-vorschrift Reg TP 322 MV 05 "Messung von Störfeldern an Anlagen und Leitungen der Tele-kommunikation im Frequenzbereich 9 kHz bis 3 GHz".

Tabelle 2.3: Grenzwerte der Störfeldstärke von TK-Anlagen und TK-Netzen

(1) Dies entspricht der äquivalenten Strahlungsleistung von 20 dBpW.(2) Dies entspricht der äquivalenten Strahlungsleistung von 33dBpW.

(2) Die Frequenznutzung nach Absatz (1) genießt keinen Schutz vor Störungen durch Aussen-dungen von Sendefunkanlagen.

(3) Die einschränkenden Bedingungen nach Absatz (1) gelten für Frequenzen bis 30 MHz vom1. Juli 2001 an und für Frequenzen über 30 MHz vom 1. Juli 2003 an.

(4) Für Frequenznutzungen in und längs von Leitern, für die keine Freizügigkeit nach Absatz(1) gegeben ist, können die räumlichen, zeitlichen und sachlichen Festlegungen durch die Re-gulierungsbehörde für Telekommunikation und Post unter Beachtung der Verhältnismäßigkeitund nach Anhörung der Betroffenen entweder im Frequenznutzungsplan oder in der erforder-lichen Frequenzzuteilung für den jeweiligen Anwendungsfall getroffen werden. Sind sicher-heitsrelevante Funkdienste betroffen, ist insbesondere zu berücksichtigen, inwieweit einekonkrete Gefährdung der Sicherheit zu befürchten ist.

Frequenzbereich Grenzwert der Störfeldstärke (Spitzenwert in 3 m Abstand dB( )

9 kHz - 1 MHz

> 1 MHz - 30 MHz

> 30 MHz - 1 GHz 27 (1)

> 1 GHz - 3 GHz 40 (2)

�Vm

-------

40 20 f MHz� � � �log�–

40 8 8� f MHz� � � �log�–


25

2.3.6 HomePlug Power Alliance

Die HomePlug Power Alliance wurde zur Entwicklung eines offenenStandards für Powerline-Systeme gegründet. Die dreizehn ursprüng-lichen Allianzmitglieder bekamen Zuwachs von vielen Firmen, ty-pischerweise Chip- und Gerätehersteller. In Jahr 2000 einigte sich dieGruppe auf die Spezifikation 1.0 basierend auf Intellon’s PowerPacket-Technologie (siehe Abschnitt 2.3.7).

2.3.7 PowerPacket

PowerPacket ist eine Technologie zur Datenübertragung viaPowerline der Firma Intellon [23]. Sie ist die Grundlage derSpezifikation 1.0 der HomePlug Power Alliance und stellteinen Standardisierungsvorschlag für den Physical- undMAC-Layer der Powerline-Kommunikation bereit.

Im Physical-Layer wird das Multi-Trägerverfahren OFDMals Basistechnologie verwendet, um eine Anpassung derSendesignale an die widrigen Übertragungsbedingungen imStromnetz zu erhalten. Die beanspruchte Bandbreite reicht von 4.5 bis 21 MHz. Die OFDM-Modulation wird ausführlich in Kapitel 2.2 beschrieben. Die Kombination aus Forward ErrorCorrection (FEC), Viterbi-Decodierung, Interleaving und Fehlerdetektion ermöglichen einehohe Fehlersicherheit und passen sich den wechselnden Kanalbedingungen an. Diese Ver-fahren werden unterstützt durch ein Automatic Repeat Request (ARQ) Protokoll, um zuverläs-sige Datenübertragung zu gewährleisten. Die Headerdaten der Pakete werden durch TurboProduct Coding (TPC) geschützt [27].

Das MAC-Protokoll der PowerPacket-Technologie ist eine Variante des Carrier Sense MultipleAccess with Collision Avoidance (CDMA/CA) Protokolls, ähnlich dem 802.11-Standard.Dieses Protokoll benutzt eine klassische listen-before-talk-Strategie und sendet nach einerzufällig ausgewählten Zeitperiode um Kollisionen zu vermeiden. Mehrere Besonderheitenwurden zusätzlich implementiert, wie beispielsweise die Unterstützung von QoS.

Pakete der PowerPacket-Technologie bestehen aus einem start-of-frame delimiter, der Payloadund einem end-of-frame delimiter. Der Paketaufbau ist in Abbildung 2.18 dargestellt. Delimit-er beinhalten eine Präambel-Sequenz gefolgt von einem TPC codiertem frame-control Feld.Die Präambel ist eine festgelegte Bitsequenz, die von den Empfängern zuverlässig erkanntwerden kann. Unicast-Aussendungen werden bestätigt durch Aussendung eines response-de-limiters.


26

Bild 2.18: PowerPacket Frameformat

Der Payloadanteil eines Frames hängt von der Übertragungsrate und der Güte des Kanals zwi-schen Sender und Empfänger ab. Die Kanalanpassung geschieht auf drei verschiedenen We-gen: Nichtbenutzung von gestörten Teilkanälen im OFDM-System, Wechsel der Modulationzwischen DQPSK und DBPSK und Änderung der FEC-Rate zwischen 3/4 und 1/2. Diese Pa-rameter auszuhandeln sind eine Besonderheit von PowerPacket, um hohe Datenraten via Pow-erline zu erzielen. Die niedrigste Datenrate und zugleich die sicherste ist der so genannteROBO-Mode. In diesem robusten Modus werden alle Träger mit DBPSK moduliert, die stärk-ste Codierung mit Interleaving verwendet sowie Bitwiederholung eingesetzt. Der ROBO-Mode benutzt keine Trägerausblendung und kann daher generell von jedem Empfänger ver-standen werden. Benutzt wird dieser Modus in der Startphase der Kommunikation zwischenGeräten, welche noch keine Kanalanpassung ausgeführt haben, für Mulicast-Aussendungenund in Unicast-Aussendungen, wenn der Kanal extrem gestört wird.

PowerPacket MAC-Layer

PowerPacket benutzt das Physical-Carrier-Sense- und Virtual-Carrier-Sense-Verfahren, umfestzustellen, ob eine andere Station gerade sendet. Im Physical-Carrier-Sense-Verfahren wer-den gesendete OFDM-Symbole einer anderen Station detektiert. Im Gegensatz dazu ist dasVirtual-Carrier-Sense-Verfahren eine zeitbasierte Nachführung der Träger. Im Frame-Control-Feld eines jeden Delimiters (siehe Abbildung 2.18) werden Informationen über Dauer einerAussendung eines Senders mitversendet. Daraus kann der Empfänger schließen, wie lange einKanal belegt sein wird, auch für den Fall, dass der Empfänger anschließend die Kanalnach-führung verliert (Physical-Carrier-Sense). Durch diese Technik wird die Performanz einesNetzwerks wesentlich verbessert, was gerade Powerline-Netzwerken zu gute kommt, inwelchen die Stationen sehr unterschiedliche Signalstärken empfangen können.

Preamble Frame control Segment control DA SA Frame Body B-PAD FCS Preamble Frame controlEFG

25 Bits 5 Bytes 6 Bytes variable Länge6 Bytes 2 Bytes 25 Bits

Delimiter Frame Header Frame BodyCheck

DelimiterSequence

4 Symbole variable Symbolanzahl: 20 - 170 Symbole 4 Symbole

Payload


27

Paket-Kollisionen können vom Powerline-Modem nicht direkt während der Aussendung er-kannt werden, da der Sender sich selbst mit einer wesentlich höheren Stärke hört als die Aus-sendungen entfernterer Stationen. Daher werden Kollisionen aus dem Fehlen von erwartetenEmpfangsbestätigungen gefolgert. Alle Unicast-Aussendungen werden durch einen Response-Delimiter bestätigt. Die PowerPacket-Technologie erlaubt dem Empfänger aber auch negativeBestätigungen (NACK oder FAIL) zu senden, je nachdem, ob ein Paket mit Fehlern empfang-en wurde oder nicht verarbeitet werden konnte.

Neu hinzukommende Stationen erhalten Zugriff auf den Kanal durch ein Wettbewerbs-Zeitfen-ster mit exponentiellem Backoff, ähnlich wie bei Ethernet. Dem Wettbewerbsfenster geht einPriority-Resolution-Zeitintervall voraus, welches mehreren Stationen die Möglichkeit gibt,entsprechend ihren Sende-Prioritäten den Kanal zu beanspruchen. Nachdem eine Station ihreAussendung vollzogen hat, signalisieren andere in der Warteschlange stehende Stationen ihrePrioritäten während dieses Priority-Resolution-Zeitintervalls. Die Absicht, im nächsten Zeit-fenster zu senden, wird durch eine binäre Codierung der Priorität signalisiert.

Jede Station wählt zufällig einen Zeitschlitz unter Berücksichtigung ihrer Priorität im Wettbe-werbsfenster aus, zählt die Zeitschlitze herunter bis der gewählte Zeitschlitz an der Reihe istund beginnt ihre Aussendung. Das Wettbewerbsfenster wächst mit zunehmender Anzahlerfolgloser Versuche Zugang zum Kanal zu erhalten. Wenn eine Station eine Aussendung eineranderen Station erkennt, bevor ihr eigener Zeitschlitz an der Reihe ist, wird der Zähler ange-halten und das Modem schaltet in den Empfangsmodus. Sobald die Aussendung der anderenStation vorüber ist, setzt die Station ihre Zählung wieder fort.

Da sich die Paketgröße der Datenrate und den Kanaleigenschaften anpasst, variiert die Zeit füreine Paketaussendung. Übermittlungszeiten von langen Paketen wirken der Einhaltung vonQuality-of-Service entgegen, weil ein Paket mit einer höheren Priorität nicht immer rechtzeitigausgesendet werden kann, wenn es auf die Beendigung einer langen Aussendung warten muss.PowerPacket umgeht diese Problematik durch eine Segmentierung von Paketen, die einegewisse Länge überschreiten. Pakete mit höherer Priorität können dadurch zwischen längereAussendungen springen. Um die Kollisionswahrscheinlichkeit von Paketen gleicher Prioritätzu vermeiden, benutzt PowerPacket das Segment-Bursting-Verfahren. In diesem Verfahrenwerden alle Pakete gleicher Priorität direkt hintereinander gesendet bis ein Paket höherer Pri-orität diesen Vorgang unterbricht. Eine Erweiterung dieser Verfahren ist der wettbewerbsfreierZugriff auf den Kanal, in welchem die Stationen eine begrenzte Anzahl von Paketen zu ver-schiedenen Stationen senden darf ohne dabei unterbrochen zu werden. Der wettbewerbsfreieZugriff verbessert die QoS bei bestimmten Multimedia-Anwendungen.

Kanalanpassung geschieht bei jeder erstmaligen Aussendung zu einer anderen Station sowiegelegentlich auch danach, wenn ein Timeout stattfindet oder sich die Kanalübertragungsfunk-tion ändert. Die Kanalanpassung hat direkten Einfluss auf die Anzahl benutzter Träger, Modu-


28

lationsart und FEC-Codierung nachfolgender Aussendungen. Sie wird vom Empfänger be-stimmt und kann sich in umgekehrter Kanalrichtung unterscheiden.

PowerPacket erstellt logische Netwerkstrukturen, die auf einem Privacy-Mechanismus basier-en. Dabei teilen sich alle teilnehmenden Stationen einen gemeinsamen Schlüssel. Verschlüs-selung wird erreicht durch einen 56-Bit-DES Algorithmus.


29

2.4 Das OSI-Referenzmodell

Das OSI-Sieben-Schichten-Modell [15] (Open System for Interconnection), von der Standardi-sierungs-Kommission ISO (International Standardisation Organisation) 1983 als Standard ISO7498 entworfen, ist ein allen Kommunikationssystemen zugrunde liegendes Referenz-Modell.Als Referenz-Modell beschreibt es den strukturellen und funktionellen Aufbau von Telekom-munikationssystemen. Ziel des OSI-Sieben-Schichten-Modell (OSI-Referenzmodell) ist es,jedes Telekommuniktionssystem in sieben Schichten zu unterteilen. Das Modell stellt somiteine offene Architektur bereit, damit Systeme unterschiedlicher Hersteller miteinander kom-munizieren können [28].

Bild 2.19: OSI-Referenzmodell mit Transitsystem und Übertragungsmedium [28]

Die unteren vier Schichten 1 - 4 werden als Transportschichten bezeichnet, da sich diese nurmit der gesicherten Übertragung der Daten von einem Endsystem zu einem anderen beschäfti-

Application

Presentation

Session

Transport

Network

Data Link

Physical

Application

Presentation

Session

Transport

Network

Data Link

Physical

7

6

5

4

3

2

1

7

6

5

4

3

2

1

Router

Bridge, Switch

Repeater, Hub

Übertragungsmedium

Endsystem A Endsystem BTransitsystem


30

gen. Ergänzt werden die Transportschichten durch die Schichten 5 - 7. Diese oberen Schichtenwerden als anwendungsorientierte Schichten bezeichnet, da diese nicht die Aufgabe derDatenübertragung, sondern die der Datenverarbeitung haben.

Vertikale Kommunikation im Modell findet ausschließlich zwischen den Schichten statt, d.h.es kann z.B. keinen direkten Austausch von Informationen der Schicht 4 auf Gerät A und derSchicht 3 auf Gerät B erfolgen. Die Kommunikation erfolgt innerhalb des OSI Modells mittelsso genannten Dienstprimitiven (Service Primitives) die den jeweiligen Schichten erlauben,Dienstanweisungen an die über oder untergeordnete Schicht weiterzugeben.

Die andere Möglichkeit im OSI Modell zu kommunizieren ist die Kommunikation über Pro-tokolle. Dabei handelt es sich nicht um die Kommunikation innerhalb eines Endgerätes,sondern die Kommunikation zweier Endgeräte auf derselben Schicht, den sog. Partnerin-stanzen. Diese bauen über die darunterliegenden Schichten eine logische Verbindung auf. DieProtokolle regeln dann in welcher Weise welches Endgerät über diese Verbindung Datensenden darf.

2.4.1 Die Bitübertragungsschicht

Schicht 1, Physical Layer, P

Die Bitübertragungsschicht stellt ungesicherte Verbindungen für die Übertragung von Bits zurVerfügung. Deswegen hat die physikalische Schicht auch exklusiven Zugriff auf das Übertra-gungsmedium, d.h. sie ist allein für das Einschreiben der Informationen auf die Trägersignalezuständig (Modulation), aber auch für das Lesen der Informationen von selbigen (Demodula-tion). Dies geschieht beispielsweise auf einem elektrischen Kabel in geeigneter Weise, z.B.durch anheben oder Wechsel des Spannungspegels.

Die Physikalische Schicht ist aber nicht nur für die Modulation und Demodulation zuständig,sondern auch für die Signalverbesserung, welche vonnöten ist, wenn durch schlechte Übertra-gungen die Signale verzerrt oder abgeschwächt (durch Leitungsdämpfung) werden. Es kannaber auch noch die Aufgabe der Kanalcodierung hinzukommen, beispielsweise im Mobilfunkoder im Funknetzwerk, wo oft stark gestörte Kanäle vorherrschen.


31

2.4.2 Die Sicherungsschicht

Schicht 2, Data Link Control Layer, D

Die Sicherungsschicht verbessert ungesicherte Verbindungen auf Teilstrecken zu gesichertenVerbindungen. Diese Schicht wird in der Regel in eine obere und untere Schicht eingeteilt. Dieuntere Schicht wird in der Regel als Medium Access Control Schicht (MAC) bezeichnet. Siehat die alleinige Aufgabe den Zugriff der oberen Schichten auf das Übertragungsmedium zuregeln, da normalerweise ein Medium nicht exklusiv dem Endgerät zugeteilt ist (und genau ausdiesem Grund kann die Schicht entfallen wenn ein Exklusiver Zugriff besteht). Aus diesemGrund ist es vonnöten, den Zugriff zu regeln, damit es nicht zu Kollisionen kommen kann.

Die obere Schicht wird als Logical Link Control (LLC) bezeichnet. Mit dieser Schicht kannman schon Datenübertragungen unabhängig von Medium realisieren, da diese nur noch ab-strakt für die LLC Schicht erscheint. Wenn aber Übertragungsfehler auf dem Mediumauftreten, gibt die P-Schicht diese Fehler ungefiltert an die LLC Schicht weiter. Diese hat danndie Aufgabe, diese Übertragungsfehler zu entdecken und diese Fehler zu korrigieren, d.h. denübergeordneten Schichten eine möglichst fehlerfreie Übertragung zur Verfügung zu stellen.Dies geschieht auf der D-Schicht indem sie Daten im sog. Rahmen einpackt, mit Header undTrailer. Der Trailer enthält z.B. eine Prüfsumme zur Verifikation der im Rahmen enthaltenenInformationen. Weiterhin werden die Rahmen auch mit Sequenznummern versehen, und even-tuelle fehlerhafte Pakete wieder anfordern zu können.

2.4.3 Die Vermittlungsschicht

Schicht 3, Network Layer, N

Die Vermittlungsschicht transportiert Datenpakete über Teilstrecken des Netzes von einemEndsystem zum anderen, dies ist das so genannte Routing. Für den Transport über ver-schiedene Knoten werden auf diesen so genannte Routingtabellen geführt. In diesen steht anwelchen Netzknoten das Paket als nächstes geschickt werden soll.

Nicht nur das Routing, sondern auch das Finden eines optimalen Weges durch das Netz istAufgabe der N-Schicht. Hier kann man auch nochmals zwischen der schnellsten Route oderder kürzesten Route unterscheiden, in der Regel wird aber in der Praxis immer nach derschnellsten Route gesucht, da man in der Telekommunikation lange Verzögerungen vermeidenwill.


32

2.4.4 Die Transportschicht

Schicht 4, Transport Layer, T

Die Transportschicht nimmt Anforderungen von Anwendungsprozessen an, stelltAnforderungen an darunterliegenden Schichten und gleicht eventuell ungenügende Leistungendieser Schichten aus. Sie hat daher eine ähnliche Ausgabe wie die D-Schicht, übernimmt dieFehlerkorrektur aber nicht von einem Netzknoten zu einem anderem, sondern stellt die ge-sicherte Übertragung der Daten zwischen zwei Endgeräten sicher.

Auch der Aufbau und Abbau von virtuellen Kanälen zwischen 2 Endgeräten wird über die T-Schicht gesteuert. Durch diese Steuerungsaufgabe hat sie die Möglichkeit, mehrere Sitzungenzwischen 2 Endgeräten auf einen virtuellen Kanal zu leiten, (upward Multiplexing) aber auchdas Verteilen von Daten einer Sitzung auf mehrere virtuelle Kanäle, um beispielsweise einehöhere Bandbreite zu erreichen (downward Multiplexing).

Auch die Aufgabe, dass der angebotene Dienst in der vereinbarten Güte erbracht wird (Qualityof Service, QoS) gehört zu der Transportschicht.

2.4.5 Die Sitzungsschicht

Schicht 5, Session Layer, S

Die Sitzungsschicht regelt den Gesprächswechsel und liefert Vorkehrungen für das Wiederan-laufen der Verbindungen nach Abbruch. Sie betrachtet die gesamte Kommunikation als Ein-heit, der Anfang und das Ende einer Sitzung werden als Hauptsynchronisationspunkte bezeich-net. Es gibt aber nicht nur diese zwei Punkte, sondern eventuell mehr, so genannte Nebensyn-chronisationspunkte. Dies hat den Vorteil, dass eine Kommunikation wieder aufgenommenwerden kann, wenn ein Abbruch vor dem Ende der eigentlichen Sitzung erfolgt ist.

2.4.6 Die Darstellungsschicht

Schicht 6, Presentation Layer, P

Die Darstellungsschicht stellt Ausdrucksmittel zur Verfügung, die es den Anwendungsinstan-zen ermöglichen, Datentypen zu definieren und legt die Regeln fest, nach denen die Informa-tionen auszutauschen sind. Dies beinhaltet in welcher Weise die übertragenen Informationenauf den jeweiligen Endgeräten dargestellt werden. Daher erhält in dieser Schicht auch dieQuellcodierung der Informationen tragende Bedeutung, denn die Codierung ist nichts anderes


33

als eine Abbildung von Informationseinheiten auf die jeweiligen Repräsentanten. Aber auchdie Datenkompression sowie die Kryptographie während der Kommunikation wird von der P-Schicht erledigt.

2.4.7 Die Anwendungsschicht

Schicht 7, Application Layer, A

Die Anwendungsschicht stellt Mittel für die Kooperation zwischen verteilten Anwendungs-prozessen zur Verfügung. Im OSI Modell finden dabei vornehmlich Protokolle für Dienste, diein Computernetzen vonnöten sind, Beachtung. Die bei diesen Protokollen mitgebracht Funk-tionalität bezüglich des Dateizugriffs und der Verwaltung (File Transfer, Access and Manage-ment, FTAM) stehen im Vordergrund. Meistens können diese Protokolle aber noch weit mehr.

Ein weiterer Dienst, der auf der A-Schicht angeboten wird, ist das so genannte virtuelle Termi-nal (VT), das es einem Benutzer ermöglicht, sich an entfernten Computern anzumelden unddort zu arbeiten, als säße er am lokalen Rechner.

Zu den wichtigsten Diensten der A-Schicht des OSI Modells gehören Hypertext Transfer Pro-tocol (HTTP), Simple Mail Transfer Protocol (SMTP), das File Transfer Protocol (FTP), Tel-net und SSH.

3 KANALCODIERUNG [3]

34

3 Kanalcodierung [3]Dieses Kapitel gibt eine kurze Einführung in die Codierung mit Faltungscodes. Dabei be-schränken wir uns auf den binären Fall, d.h. Codes über das Galois-Feld GF(2). Bild 3.1 zeigtdas allgemeine Übertragungssystem mit Codierung und Decodierung.

Bild 3.1: Einfaches Modell eines Codierungs-/Decodierungssystems

Eine Informationsquelle sendet eine Sequenz von binären Daten, die uncodierte Sequenz u.Diese Sequenz wird im Codierer in die codierte Sequenz x transformiert. Während der Über-tragung über den Kanal wird die codierte Sequenz x durch den Rauschvektor n verfälscht.Diese Annahme ist korrekt, solange die Störung von additiver Natur ist und keine Intersymbol-interferenz präsent ist. Aus der gestörten Sequenz y schätzt der Decodierer die am wahrschein-lichsten gesendete Datensequenz û.

Codearten

Im Allgemeinen unterscheidet man zwei Hauptarten von Codes, die Blockcodes und die Fal-tungscodes. Der Ausgang eines Blockcodierers teilt den Datenstrom in einzelne Blöcke undfügt zusätzliche Bits zur Fehlerkorrektur an. Dagegen erzeugt ein Faltungscodierer einen kon-tinuierlichen Datenstrom von theoretisch unendlicher Länge. Die Information zur Fehlerkor-rektur wird hier mit den eigentlichen Daten verrechnet.

Digitale Quelle Codierer

DecodiererDigitale Senke

Kanal

y

xu

û

Rauschen n


35

3.1 Faltungscodierung

Faltungscodes (convolutional codes) bieten neben der Gruppe der Blockcodes eine weitere Artder Fehlerkorrektur in der Kanalcodierung. Im Gegensatz zu Blockcodes besitzt der Encoderbei Faltungscodes ein Gedächtnis, d. h., dass ein Codeblock nicht nur vom aktuellen Informa-tionsblock abhängt, sondern auch von den vorhergehenden Blöcken. Faltungscodes lassen sichdurch eine lineare Abbildung einer Menge von Informationswörtern auf eine Menge vonCodewörtern beschreiben. Dabei werden die Codewörter durch Faltung einer Informationsse-quenz mit einem Satz von Generatorkoeffizienten gebildet. Im Folgenden beschränken wir unsauf binäre Faltungscodes. Die Informationssequenz durchläuft ein Schieberegister, welchesaus L k-Bit-Blöcken und n Exclusiv-Oder-Gliedern besteht, wie in Bild 3.2 gezeigt wird. DerStartzustand der Register ist immer Null. In jedem Zeittakt werden also k Bits in die Registergeschoben und n Bits bilden das zugehörige Ausgangscodewort. Daraus ergibt sich eineCoderate von R = k/n.

Bild 3.2: Faltungscodierer

Die Einflusslänge (constraint length) L beschreibt die „Länge“ des Faltungscodierers - sieentspricht die Anzahl der k-Bit-Blöcke. Nah verwandt mit dem Parameter L ist der Parameterm, der die Dauer beschreibt, wie lange ein Eingangsbit im Faltungscodierer verbleibt und fürdie weitere Codierung verwendet wird. Der Parameter m gibt somit die Gedächtnislänge(memory length) des Codierers an und ist mit der Einflusslänge über verknüpft. Umdie Struktur eines Faltungscodierers zu beschreiben, gibt man einen Satz von Generatorse-quenzen an, für jedes der n Exklusiv-Oder-Glieder jeweils eine. Die Generatorsequenz gibt an,welche der Registerblöcke mit dem zugehörigen Exklusiv-Oder-Glied verbunden sind.Eine Eins in der Generatorsequenz deutet auf eine Verbindung hin und eine Null bedeutet

1 2 ... k22 1 2 ... k22 1 2 ... k22

L k-Bit Blöcke

+ + + +

1 2 3 n

Codesequenz

Informationssequenz

L m 1+=

L k�


36

keine Verbindung. Bild 3.3 zeigt einen einfachen Faltungscodierer der Einflusslänge 3 und der

Coderate 1/3.

Bild 3.3: Einfacher Faltungscodierer mit L = 3, k = 1, n = 3

Die zugehörigen Generatorsequenzen lauten:

Die Generatorsequenzen werden in der Literatur meist in oktaler Schreibweise dargestellt. Fürdiesen Faltungscodierer erhalten wir dann die Form (4, 5, 7). Um einen Faltungscodierer dar-zustellen, gibt es weitere Möglichkeiten, die in den folgenden Abschnitten behandelt werden.

In dieser Diplomarbeit beschränken wir uns auf Codierer der Coderate 1/2.

3.1.1 Zustandsdiagramm

Das Zustandsdiagramm (state diagram) in Abbildung 3.4 stellt die Zusammenhänge bei einemFaltungscodierer als deterministischen Automaten (Mealy-Automat) dar. Die durchgehendenPfeillinien kennzeichnen Übergänge, die durch eine Eins als Eingabebit hervorgerufen werdenund die gestrichelten Pfeile stehen für Übergänge aus Null-Bit-Eingaben. Die zugehörigenAusgangscodewörter stehen neben den Pfeilen. Das Zustandsdiagramm beginnt und endet imAllgemeinen im Nullzustand. Die Schleife am Nullzustand für eine Null-Bit-Eingabe besitzenalle Diagramme von Faltungscodierern.

++

++

2

3

1

OutputInput

g1 100� �=

g2 101� �=

g3 111� �=


37

Bild 3.4: Zustandsdiagramm des Faltungscodierers aus Bild 3.3

3.1.2 Codebaum

Eine weitere Möglichkeit der Darstellung ist der Codebaum in Form eines Baumdiagramms(tree diagram). Mit ihm werden sämtliche Codesequenzen in Abhängigkeit der Eingangsfolgedargestellt. Bild 3.5 zeigt den Codebaum zum Faltungscodierer aus Bild 3.3.

Bild 3.5: Codebaum des Faltungscodierers aus Bild 3.3

Zustand01

Zustand00

Zustand11

Zustand10

011 100

011

011

010

000

101

110

000

111000

111

001

110

011

100

010

101

110

001

111

000

000

111

0

1


38

Der Weg der Eingangsfolge ist im Codebaum hervorgehoben und liefert die Aus-gangsfolge . Der Codebaum zeigt die Codegeneration in zeitlicher Abfolgeauf. Zu einem Zeitpunkt t besteht der Codebaum aus Knoten. Dies führt jedoch mit zuneh-mender Zeit zu einer Komplexität, die die Darstellung im Baumdiagramm unpraktikabelmacht.

In Bild 3.5 erkennt man, dass sich Teile des Codebaumes periodisch wiederholen. Knoten mitgleichem Zustand können zusammengefasst werden, weil von ihnen immer die gleichenZweige ausgehen. Dies führt zu der einfacheren Darstellungsform, zum so genanntenTrellisdiagramm.

3.1.3 Trellisdiagramm

Das Trellisdiagramm ist eine kompaktere Darstellungsart eines Faltungsdecodierer als derCodebaum. Periodisch wiederkehrende Teile des Codebaumes sind im Trellisdiagrammzusammengefasst. Diese Darstellung wird besonders bei der ML-Decodierung mittels Viterbi-Algorithmus verwendet. Das Diagramm zeigt die möglichen Pfadverläufe der Codewörter vonZustand zu Zustand über der Zeit. Die Anzahl der Zustände beträgt und entspricht der An-zahl der Zustände des Schieberegisters im Faltungscodierer. Ein Beispiel eines Trellisdia-gramms ist in Abbildung 3.6 zu sehen.

Bild 3.6: Trellisdiagramm des Faltungscodierers aus Bild 3.3

Pfade, welche von vom Eingangsbit Null herrühren werden im Diagramm mit einer durchge-zogenen Line dargestellt und gestrichelte Linien verdeutlichen eine Eins als Eingabebit. DasTrellisdiagramm beginnt gewöhnlich im Nullzustand. Auffallend ist das anfängliche expo-

u 010� �=v 000111001� �=

2kt

2L

000 000 000 000 000

111 111 111 111 111

101 101 101

011 011 011

001 001 001 001

110 110 110 110

010 010 010

100 100 100

000 000 000 000 000

111 111 111 111 111

101 101 101

011 011 011

001 001 001 001

110 110 110 110

010 010 010

100 100 100

Zustand 00

Zustand 01

Zustand 10

Zustand 11

t=0 t=1 t=2 t=3 t=4 t=5


39

nentielle Wachstum der Pfadanzahl mit der Zeit, welches zu Zeitpunkten konstant wird.In jedem Zustand nach der Aufbauphase beginnen und enden jeweils Pfade.

3.1.4 Polynominale Darstellung

Lineare Faltungscodes lassen sich durch Generatoren gj beschreiben. Sie werden in der Li-teratur meist in otkaler Schreiweise angegeben. Für die Einflusslänge Lc=3 und eine Rate vonR=1/2 sind nachfolgend zwei Generatoren angegeben.

(3.1)

(3.2)

Mit Hilfe der diskreten Faltung lässt sich aus der Eingangssequenz u und den Generatoren gjdie Codierung nach Gleichung (3.3) berechnen.

x1 = u * g1 und x2 = u * g2 (3.3)

Es gilt der allgemeine Zusammenhang nach Gleichung (3.4):

(3.4)

Die Signalfolgen und Generatoren lassen sich im Spektralbereich auch mit der Z-Transforma-tion beschreiben. Die Z-Transformation ist durch folgenden Zusammenhang gegeben:

(3.5)

In der Nachrichtentechnik verwendet man anstelle des z-1-Operators meist den Operator D(Delay). Damit lässt sich die Gleichung (3.5) auch als Gleichung (3.6) schreiben.

(3.6)

Die Generatoren werden dann folgendermaßen beschrieben:

(3.7)

t L�

2k

g1 g1 0� g1 1� g1 2�� 1 1 1� �� 78= = =

g2 g2 0� g2 1� g2 2�� 1 0 1� �� 58= = =

x� l� � g� ul i– mod2�

i 0=

m

�=

Z x� � x� z �–�

� 0=

�

�=

X D� � x� D��

� 0=

�

�=

G1 D� � g10 g11D g12D2+ + 1 D D2+ += =


40

(3.8)

Für das -te Polynom und die zugehörige Ausgangsfolge ergibt sich der allgemeineZusammenhang:

und (3.9)

Die gesamte codierte Sequenz kann in der Polynomschreibweise durch

(3.10)

mit der Generatormatrix dargestellt werden.

3.1.5 Katastrophale Faltungscodierer

Katastrophale Faltungscodierer sind in der Lage unendlich lange Sequenzen mit endlichemGewicht zu erzeugen. Diese kehren nicht wieder auf den Null-Pfad zurück. Dadurch kanndiese Art von Faltungscodierern bei endlich vielen Übertragungsfehlern unendlich viele Fehlernach der Decodierung mit dem Viterbi-Algorithmus erzeugen. Aufgrund dessen sind katastro-phale Faltungscodierer nicht zur sicheren Datenübertragung geeignet. Man erkennt katastro-phale Faltungscodierer an folgenden Eigenschaften:

• Alle Generatorpolynome besitzen einen gemeinsamen irreduziblen Faktor

• Im Zustandsdiagramm existiert eine geschlossene Schleife mit Gewicht Null außer demNullzustand

• Alle XOR-Glieder haben eine gerade Anzahl von Verbindungen (Die Schleife im Zustand1...1 besitzt Gewicht Null)

G2 D� � g20 g21D g22D2+ + 1 D2+= =

� X� D� �

G� D� � g� i D��

i 0=

m

�= X� D� � U D� � G� D� ��=

X D� � X1 D� � X2 D� � � Xn D� � U D� � G D� ��= =

G D� � G1 D� � G2 D� � � Gn D� �=


41

Abbildung 3.7 zeigt ein Beispiel für einen katastrophalen Faltungscodierer mit den Generator-en g1 = 58 und g2 = 38.

Bild 3.7: Katastrophaler Faltungscodierer

Abbildung 3.8 zeigt das zugehörige Zustandsdiagramm mit der charakteristischen Schleife imZustand 11.

Bild 3.8: Zustandsdiagramm des katastrophalen Faltungscodierers aus Abbildung 3.7

D Du

x1

x2

10 01

00

11

1/01

0/01

0/111/10

1/11 0/10

0/00

1/00


42

3.1.6 Endliche Faltungscodes

In der Theorie sind Faltungscodes unendlich lange Folgen. In der Praxis hingegen werdenmeist endliche Codesequenzen benutzt. Es existieren verschiedene Methoden endliche Codeszu übertragen. Nachfolgend wird daher die Terminierung, Truncation und das Tail-Biting be-handelt [29].

Truncation

Bei der Decodierung von Faltungscodes benötigt der Viterbi-Algorithmus die gesamte bzw.eine ausreichend lange Codesequenz. Lässt man die Informationssequenz unbestimmt enden,ist jeder Zustand am Ende des Trellisdiagramms möglich. Der Endzustand ist somit dem De-codierer nicht bekannt. Da sich die letzten Bits der Informationssequenz nur sehr wageschätzen lassen, bewirkt dies eine unsichere Decodierung der letzten Bits.

Terminierung

Bei der Terminierung fügt man am Ende der zu übertragenden Informationsbitfolge einevorher bestimmte Bitfolge an. Diese so genannte Terminierung bringt den Faltungscodierer amEnde der Informationssequenz in einen definierten Zustand. Mit der Kenntnis dieses End-zustandes ist der Empfänger in der Lage, mit Hilfe des Viterbi-Algorithmus die empfangeneCodesequenz richtig zu decodieren. Die Terminierungsbits werden meist zu Null gewählt, umam Ende der Informationssequenz in den Nullzustand zu gelangen. Die Länge der Termi-nierung sollte mindestens Bits betragen, wobei m die Gedächtnisordnung des Faltung-scodierers entspricht. Die Rate der terminierten Codes verringert sich geringfügig um den sogenannten Fractional-Rate-Loss K / (K + m). Die Coderate ergibt sich damit zu Gleichung(3.11).

(3.11)

K ist hierbei die Anzahl der codierten Informationsblöcke. Für den Fall, dass K sehr groß ist,ergibt sich .

Tailbiting

Heutige Datenübertragungssysteme erfordern oftmals eine sehr kleine Paketgröße. Das Anfü-gen von Terminierungsbits kann für derartige Systeme eine Verringerung der Datenrate zur

k m�

RTkK

n K m+� �---------------------- R K

K m+--------------= =

RT R�


43

Folge haben und das Verfahren ineffizient machen. Daher gibt es noch eine dritte Möglichkeit- das so genannte Tailbiting. Bei diesem Verfahren wird die zu sendende Informationsbitfolgecodiert und der Endzustand bestimmt. Anschließend wird der erhaltene Endzustand als An-fangszustand gewählt und die Informationsbitfolge erneut codiert [29].

3.1.7 Punktierte Faltungscodes

Um höhere Coderaten d.h. ein besseres Verhältnis von k zu n zu erreichen, werden Faltungs-codes gewöhnlich punktiert. Zu diesem Zweck werden Codebits zu jeweils Code-blöcken zusammengefasst. ist die so genannte Punktierungslänge. Man erhält punktierteCodes aus Faltungscodes der Rate , indem man aus dieser Gruppe der Ausgangscodeworte lBits ausgeblendet und nicht überträgt. Hierbei wird der ursprüngliche Code als Muttercodebezeichnet. Zur Decodierung muss dem Empfänger das Punktierungsschema selbstverständ-lich bekannt sein. Der Vorteil der Punktierung ist die einfache Anpassung der Coderate an dieaktuellen Übertragungsbedingungen.

Die Punktierung erfolgt normalerweise periodisch mit der Periode und lässt sich mit Hilfeeiner Punktierungsmatrix P beschreiben:

(3.12)

(3.13)

Jede Spalte von P enthält das Punktierungsschema für ein Codewort und besteht somit aus nElementen. Die Coderate nach der Punktierung ergibt sich aus der Anzahl der Infobits undder Anzahl der übertragenen Codebits zu

, (3.14)

unter der Bedingung das sein muss, um Coderaten kleiner eins zu erhalten. DieStruktur von P ist nur in den einfachsten Fällen trivial. So kann beispielsweise durch die Punk-tierung ein katastrophaler Code entstehen. In diesem Fall ist die Punktierung auf die jeweiligenGeneratoren abzustimmen. Numerisch optimierte Punktierungs-Schemata zeigen die Tabellen3.1 und 3.2. Verwendbare Punktierungsmasken erhält man durch systematische Suche.

nLP LP

LP 1n---

1n---

LP

P

p1 0� p1 1� � p1 LP�

p2 0� p2 1� � p2 LP�

� � � �pn 0� pn 1� � pn LP�

=

p0 p1 � pLP� � �� =

pi

LP

nLP l–

RPLP

nLP l–-----------------= RP

1n---� R=� �

l n 1–� �P�


44

Um punktierte Codes zu decodieren, fügt man im Viterbi-Algorithmus anstelle der nichtüber-tragenen Bits beliebige Bits ein, ohne sie bei der Berechnung der Hamming-Distanzen zuberücksichtigen.

Tabelle 3.1: Punktierungs-Schemata 1, [20], [30]

Tabelle 3.2: Punktierungs-Schemata 2, [20], [30]

Original-code

R = 2/3 R = 3/4 R = 4/5

m g(1), g(2)

P ,,

P , ,

P ,,

2 5, 7

1011

3, 1, 1 101110

3, 6, 15 10111100

2, 1, 1

3 15, 17

1110

4, 3, 10 110101

4, 29, 124 10111100

3, 5, 14

4 23, 35

1110

4, 1, 1 101110

3, 1, 1 10101101

3, 3, 11

5 53, 75

1011

6, 1, 3 100111

4, 1, 3 10001111

4, 7, 40

6 133, 171

1110

6, 1, 3 110101

5, 8, 42 11111000

4, 3, 12

7 247, 371

1011

7, 9, 47 110101

6, 36, 239 10101101

5, 20, 168

8 561, 753

1110

7, 3, 11 111100

6, 10, 52 11011010

5, 7, 31

Original-code

R = 5/6 R = 6/7 R = 7/8

m g(1), g(2)

P ,,

P , ,

P ,,

2 5, 7

1011111000

2, 2, 2 101111110000

2, 4, 5 10111111100000

2, 6, 8

3 15, 17

1010011011

3, 15, 63 100011111100

2, 1, 2 10000101111101

2, 2, 4

4 23, 35

1011111000

3, 5, 20 101010110101

3, 14, 69 10100111101100

3, 13, 49

dfreeAdfree

Bdfree

dfreeAdfreeBdfree

dfreeAdfree

Bdfree

dfreeAdfree

Bdfree

dfreeAdfreeBdfree

dfreeAdfree

Bdfree


45

= freie Distanz = Anzahl von Sequenzen bei der Mindestdistanz = Koeffizient zur Abschätzung der Bitfehlerwahrscheinlichkeit

5 53, 75

1000011111

4, 19, 100 110110101001

3, 5, 25 10111011100010

3, 9, 60

6 133, 171

1101010101

4, 14, 92 111010100101

3, 1, 5 11110101000101

3, 2, 9

7 247, 371

1110010011

4, 2, 7 101001110110

4, 11, 85 10101001101011

4, 26, 258

8 561, 753

1011011001

5, 19, 168 110110101001

4, 2, 9 11010111010100

4, 6, 70

Original-code

R = 5/6 R = 6/7 R = 7/8

dfree

Adfree

Bdfree


46

3.2 Viterbi-Algorithmus

Der Viterbi-Algorithmus findet Anwendung bei der Decodierung von Faltungscodes. Er arbei-tet nach dem Prinzip eines Maximum-Likelihood Sequence Estimators (MLSE), in dem er zuder empfangenen Codewortfolge eine möglichst ähnliche Codewortfolge sucht. Die Ähnlich-keit zweier Codewörter wird bei Hard-Decision-Decodierung über die Hamming-Distanz undbei Soft-Decision-Decodierung über die Euklidische Distanz bestimmt. Theoretisch müsste einDecodierer alle möglichen Codewortfolgen mit der empfangenen Codewortfolge vergleichen.Da die Anzahl der Codewortfolgen jedoch mit der Zeit exponentiell anwächst (siehe Code-baum zur Faltungscodierung), verwendet man den Viterbi-Algorithmus, um den Deco-dierungsaufwand gering zu halten. Dieser lässt sich am einfachsten am Trellisdiagramm nach-vollziehen.

Das folgende Beispiel soll die Viterbi-Decodierung verdeutlichen. Der Faltungscodierer ausAbbildung 3.3 wandelt die terminierte Info-Bit-Folge in die Codefolge

um. Durch Übertragungsfehler kommt am Empfänger die Code-folge an.

Die hier angewandte Metrik soll den Pfadkosten entsprechen, welche durch die Anzahl der un-terschiedlichen Bits einer Codefolge ausgedrückt werden. Die Decodierung beginnt üblicher-weise mit dem Zustand 00. Im ersten Schritt werden die Pfadkosten der Zustandsübergänge

und berechnet. Die Pfadkosten des Übergangs betragen 3, da sich daserste empfangene Codewort von dem Codewort des Zustandüberganges im Trellis

um 3 Bitstellen unterscheidet. Analog dazu erhält man für den Übergang Pfadkosten von 0. Abbildung 3.9 erläutert den ersten Schritt:

Bild 3.9: Schritt 1 der Viterbi-Decodierung

Im zweiten Schritt (Abbildung 3.10) steigt die Anzahl der möglichen Pfade auf das Doppelte.Die weiteren Pfadkosten setzen sich aus den neuen Kosten des Zustandübergangs vom Zeit-punkt zum Zeitpunkt und den im vorherigen Schritt berechneten Pfadkosten des

u 1 0 1 0 0� � � �� =v 111 001 100 001 011� � � �� =

y 111 101 000 001 001� � � �� =

00 00� 00 10� 00 00�

y0 111=c00 00� 000= 00 10�

000

111

Zustand 00

Zustand 01

Zustand 10

Zustand 11

t=0 t=1

Pfadkosten = 3

Pfadkosten = 0

000

111

Zustand 00

Zustand 01

Zustand 10

Zustand 11

t=0 t=1

Pfadkosten = 3

Pfadkosten = 0

t 1= t 2=


47

Vorgängerzustands zusammen. Die Pfadkosten aus Schritt 1 stehen in Klammern neben denzugehörigen Zuständen.


Im dritten Schritt hat das Trellis seine maximale Komplexität erreicht. Zu jedem Zustand umZeitpunkt führen nun zwei Pfade mit den zugehörigen Pfadkosten. Der Pfad mit den ge-ringsten Pfadkosten wird für die weiteren Berechnungen weitergeführt und der Pfad mit denhöheren Pfadkosten wird nicht mehr weiterverfolgt.


Im vierten Schritt (Abbildung 3.12) tritt ein Sonderfall in der Pfadentscheidung auf. Zu denZuständen 00 und 10 führen jeweils zwei Pfade mit der gleichen Metrik. In diesem Fall wirdeine Zufallsentscheidung getroffen, welcher Pfad weitergeführt werden soll.

000 000

111 111

001

110

Zustand 00

Zustand 01

Zustand 10

Zustand 11

t=0 t=1 t=2

Pfadkosten = 5

Pfadkosten = 1

Pfadkosten = 4

Pfadkosten = 2

(0)

(3)

t 3=

000 000 000

111 111 111

101

011

001 001

110 110

010

100

Zustand 00

Zustand 01

Zustand 10

Zustand 11

t=0 t=1 t=2 t=3

Pfadkosten = 3

Pfadkosten = 3

Pfadkosten = 2

Pfadkosten = 4

(5)

(1)

(4)

(2)


48


Im fünften Schritt (Abbildung 3.13) wurde die gesendete Datenfolge vollständig empfangen.Da die gesendete Datenfolge mit 00 terminiert wurde, lässt sich die ursprüngliche Datenfolgedecodieren, indem man den Pfad zurückverfolgt, welcher im Zustand 00 (entsprechend derTerminierung) endet.


000

111 111

101 101

011 011

001 001

110 110

010 010

100 100

Zustand 00

Zustand 01

Zustand 10

Zustand 11

t=0 t=1 t=2 t=3 t=4

Pfadkosten = 4

Pfadkosten = 3

Pfadkosten = 5

Pfadkosten = 5

(3)

(3)

(2)

(4)

Zufallsentscheidung!

000 000 000

111 111 111

101

011 011 011

001 001 001

110 110 110

010

100 100 100

Zustand 00

Zustand 01

Zustand 10

Zustand 11

t=0 t=1 t=2 t=3 t=4 t=5

Pfadkosten = 4

Pfadkosten = 5

Pfadkosten = 5

Pfadkosten = 6

(4)

(3)

(5)

(5)


49

3.3 Checksummen

Im Rahmen der Fehlererkennung hat der Empfänger die Aufgabe festzustellen, ob das gesen-dete Signal durch Störungen auf dem Übertragungsweg verfälscht wurde. Zu diesem Zweckberechnet der Sender über eine Funktion aus den Daten einen Wert, die so genannte Check-summe und fügt sie dem Datenpaket an. Auf der Empfangsseite wird mit der gleichen Funk-tion die Checksumme über die Daten berechnet und mit der angehängten Checksumme ver-glichen. Wenn die empfangseitig berechnete Checksumme mit der sendeseitigen Checksummeübereinstimmen, wird die Nachricht mit einer bestimmten Wahrscheinlichkeit als unverfälschtangenommen, andernfalls wurde die Nachricht wahrscheinlich fehlerhaft übertragen. Für denFall, dass die Nachricht fehlerfrei übermittelt wurde und nur die Checksumme Fehler enthält,werden die Daten ebenfalls für fehlerhaft gehalten, weil sich ein Fehler nicht lokalisieren lässt.

3.3.1 CRC - Cyclic Redundancy Checksums

Heute übliche Checksummen arbeiten mit dem CRC-Algorithmus [32]. Vereinfacht aus-gedrückt, behandelt er die zu sendenden Daten als eine lange binäre Zahl, die durch eine fest-stehende binäre Zahl dividiert wird. Der Divisionsrest ergibt die zugehörige Checksumme.

CRC-Algorithmen benutzten Modulo-2-Arithmetik und werden durch Generatorpolynomecharakterisiert. Die Addition und Subtraktion in der Modulo-2-Arithmetik entspricht dergewöhnlichen Bitaddition mit der Ausnahme, dass es keinen Übertrag gibt. Auf jede Bitstellewird eine Exklusiv-Oder-Operation angewendet. Ein Beispiel wird in Abbildung 3.14 gezeigt.

Bild 3.14: Beispiel einer Modulo-2 Addition und Subtraktion

Der divisions-ähnliche CRC-Algorithmus lässt sich folgendermaßen beschreiben. Sei c derGrad des Generatorpolynoms. Die Generatorbitfolge ist also c + 1 Bit lang. Dann werden cNullen den Daten angefügt und der CRC über die damit erweiterte Bitfolge berechnet.

Übernehme die höchstwertigsten c + 1 Bits der Datenfolge als den Rest in das Schieberegister.

Beginne mit dem höchstwertigsten Bit in der Orginaldatenfolge und betrachte für jede Bitposi-tion die c + 1 Bits des Restes. Wiederhole folgende Operationen bis letztes Bit der Datenfolgebearbeitet wurde:

Falls das höchstwertigste Bit des Restes eine Eins ist, wende eine XOR-Operation auf den

+01110111100001

1011010-01110111100001

1011010


50

Rest mit der Generatorbitfolge an, andernfalls wende eine XOR-Operation auf den Rest mit einer c + 1 langen Null-Bitfolge an.

Schiebe das Ergebnis dieser Berechnung um ein Bit nach links, sodass das höchstwertigste Bit entfällt und schiebe von rechts das nächste Bit der Datenfolge nach.

Der Rest nach der letzten Berechnung ergibt die Checksumme. Der Quotient bei diesem divi-sions-ähnlichen Algorithmus interessiert nicht. Da eine Bitfolge A bitweise mit einer Nullbit-folge exklusiv-geodert wieder die ursprüngliche Bitfolge A ergibt, kann man die XOR-Opera-tion bei einer Null als höchstwertigstem Bit im Rest überspringen. Ein Beispiel soll den CRC-Algorithmus verdeutlichen.

Bild 3.15: Beispiel des CRC-Algorithmus

Nach der CRC-Berechnung werden die hinzugefügten Nullbits am Ende der Datenfolge durchden CRC ersetzt und die gesamte Bitfolge übertragen. Der Empfänger berechnet über dieseBitfolge mit der gleichen Generatorbitfolge wieder einen CRC. Ist der Wert dieser Check-summe Null, wurde die Datenfolge mit hoher Wahrscheinlichkeit richtig übertragen, andern-falls wird sie als fehlerhaft angenommen.

Die CRC-Längen betragen meist 8, 16 oder 32 Bit. Das bedeutet, dass die GeneratorpolynomeLängen von 9, 17 oder 33 Bit haben. Für die Implementierung des Schieberegisters benötigtman jedoch nur die Länge des CRCs, weil das höchstwertigste Bit eines Generatorpolynomsimmer Eins ist und das höchstwertigste Bit nach der XOR-Operation immer Null ist. Daherlässt sich die CRC-Berechnung auch mit 8-, 16- oder 32-Bit-Register durchführen.

1110010100001101101111000001111011011010110000010110110111101011011000100000000100000000100

Teiler/Generatorpolynom:11011

Rest/CRC


51

Die zur CRC-Berechnung benötigten Parameter finden sich in Tabelle 3.3. Sie entsprechen in-ternationalen Standards, welche zum Teil vom CITT (Comité Consultatif International deTélégraphique et Téléphonique) genormt wurden.

Tabelle 3.3: Parameter zur CRC-Berechnung nach internationalen Standards [32, 33, 34]

Der Initialwert wird vor Beginn des CRC-Algorithmus in das Schieberegister geladen.

Mit dem XOR-Wert wird das Schieberegister nach Beendigung des CRC-Algorithmus exklusivverodert.

Der Reflect-Data- bzw. Reflect-Rest-Parameter gibt an, ob die Bitreihenfolge der Eingangs-bytes bzw. des Teilerrest-Bytes invertiert werden soll. Der Grund für diese Invertierung ist dieKompatibilität zu früheren UARTs (Universal Asynchronous Receiver Transmitter), welcheebenfalls mit invertierter Bitreihenfolge innerhalb eines Bytes arbeiteten.

Der Prüfwert kann als ein schwacher Indikator zur Implementierung eines CRC-Algorithmusbenutzt werden. Er gibt die resultierende Prüfsumme für den Fall an, dass der Algorithmus aufdie ASCII-Zeichenfolge “123456789” angewendet wird.

CRC-8 CITT CRC-16 CITT

CRC-16 CRC-32

Breite [Bit] 8 16 16 32

Generatorpolynom [HEX]

07 1021 8005 04C11DB7

Initialwert[HEX]

? FFFF 0000 FFFFFFFF

Letzter XOR-Wert [HEX]

? 0000 0000 FFFFFFFF

Reflect Data ? nein ja ja

Reflect Rest ? nein ja ja

Prüfwert [HEX] ? 29B1 BB3D CBF43926


52

3.4 Rahmensynchronisation

Die Rahmensynchronisation (frame synchronization) versucht, den Paketanfang in Zeitmulti-plexsystemen herauszufinden. Voraussetzung für eine Rahmensynchronisation ist eine er-folgreiche Bitsynchronisation. Eine mögliche Realisierung besteht in der Verwendung vonStartbits am Paketanfang. Jedes Mal, wenn der Empfänger diese Startbits erhält, detektiert erden Anfang eines neuen Datenpaketes.

Als Startbits eigenen sich besonders gut so genannte Barkersequenzen. Diese Bitfolgen habendie Eigenschaft, dass ihre Autokorrellationskoeffizienten für jede Taktverschiebung sehr kleinwerden.

Zur Detektion von Barkersequenzen verwendet man die Schaltung aus Abbildung 3.16. DieSchaltung detektiert die 7-Bit-lange Barkersequenz 1110010.

Bild 3.16: Schaltung zur Detektion von Barkersequenzen, [21]

Die Schaltung besteht aus einem Schieberegister mit der Länge der Barkersequenz. Die einzel-nen Schieberegister sind Flipflops mit jeweils zwei Ausgängen und (i=1...7). Die Aus-gänge der Flipflops sind über Vorzeichenglieder mit einem Summierglied verbunden. Am Aus-gang des Summierglieds liegt die Rahmeninformation an. Die Barkerdetektion lässt sich ver-stehen, wenn man folgendes Beispiel betrachtet:

Beispiel: Es wird von links nach rechts die Barkersequenz 1110010 durch das Registergeschoben. Zum Taktzeitpunkt n tritt die letzte Null der Barkersequenz an Stelle 1 des Regis-ters und es befinden sich im Schieberegister nur Nullen. Der zugehörige Korrelationskoeffi-zient beträgt in diesem Fall -1. Nun folgt zum Taktzeitpunkt n + 1 eine Eins in dasSchieberegister, wobei alle Bits um eine Stelle nach rechts rücken. Der zugehörige Ausgangnimmt den Wert +1 an. Alle weiteren Schritte lassen sich mit Tabelle 3.4 nachvollziehen. Es

+ - +- +- +-+ - + - + -

Summe

Eingang

Takt

Ausgang

Korrelationskoeffizient

Schieberegister

1 2 3 4 5 6 7

Q1 Q1 Q2 Q2 Q3 Q3 Q4 Q4 Q5 Q5 Q6 Q6 Q7 Q7

Qi Qi


53

fällt auf, dass zu allen Taktzeiten außer dem Zeitpunkt n + 6 die Ausgangswerte zwischen -1und +1 liegen. Zum Zeitpunkt n + 6 des vollständigen Eintritts der Barkersequenz ergibt sicheine Korrelationsspitze vom Wert +7. Nach dem Passieren der Barkersequenz geht das Aus-gangssignal wieder auf Werte zwischen -1 und +1 zurück. Anhand dieses kurzzeitigen Spitzen-werts lässt sich die Barkersequenz detektieren und somit einen Paketanfang feststellen.

Tabelle 3.4: Zwischenergebnisse der Schaltung aus Abbildung 3.16, [21]

Taktzeit Summe

n 0 1-1

0 1-1

0 1-1

0 1+1

0 1+1

0 1-1

0 1+1

-1

n + 1 1 0+1

0 1-1

0 1-1

0 1+1

0 1+1

0 1-1

0 1+1

+1

n + 2 0 1-1

1 0+1

0 1-1

0 1+1

0 1+1

0 1-1

0 1+1

+1

n + 3 0 1-1

0 1-1

1 0+1

0 1+1

0 1-1

0 1-1

0 1+1

+1

n + 4 1 0+1

0 1-1

0 1-1

1 0-1

0 1+1

0 1-1

0 1+1

-1

n + 5 1 0+1

1 0+1

0 1-1

0 1+1

1 0-1

0 1-1

0 1+1

+1

n + 6 1 0+1

1 0+1

1 0+1

0 1+1

0 1+1

1 0+1

0 1+1

+7

n + 7 0 1-1

1 0+1

1 0+1

1 0-1

0 1+1

0 1-1

1 0-1

-1

Q1 Q1 Q2 Q2 Q3 Q3 Q4 Q4 Q5 Q5 Q6 Q6 Q7 Q7


54

Einige mögliche Barkersequenzen gibt Tabelle 3.5 wieder. Barkersequenzen existieren nichtfür beliebige Stellenanzahlen, sondern nur für einige wenige. Weitere Barkersequenzen erhältman durch Bitinversion sowie durch Vertauschen der Bitreihenfolge von gültigen Barkerse-quenzen.

Tabelle 3.5: Barkersequenzen verschiedener Längen, [21]

3.4.1 Implementierung

Zur Programmierung der Schaltung aus Abbildung 3.16 sind folgende Vereinfachungen hilf-reich. Es gibt nur vier Möglichkeiten wie das Ausgangssignal eines Flipflops mit Vorzei-chengliedern zustande kommt. Das Register kann entweder den Zustand Eins oder Null anneh-men und es gibt nur zwei Möglichkeiten der Anordnung der Vorzeichenglieder. Bild 3.17 gibtdiese Kombinationen wieder.

Bild 3.17: Vier Möglichkeiten von Eingangssignal und Vorzeichenglieder-Anordnung eines Flipflops

m Barkersequenzen

3 1 1 0

4 1 1 0 1, 1 1 1 0

5 1 1 1 0 1

7 1 1 1 0 0 1 0

11 1 1 1 0 0 0 1 0 0 1 0

13 1 1 1 1 1 0 0 1 1 0 1 0 1

+ -

Q1 Q1

Input:1

Barker: 1

Output: +1

+ -

Q1 Q1

Input:0

Barker: 1

Output: -1

+ -

Q3 Q3

Input:1

Barker: 0

Output: -1

+ -

Q3 Q3

Input:0

Barker: 0

Output: +1


55

Eine logische Ersatzschaltung lässt sich durch die tabellarische Analyse der Eingangs- undAusgangssignale gewinnen. Tabelle 3.6 verdeutlicht diesen Sachverhalt.

Tabelle 3.6: Logische Analyse eines Flipflops mit Vorzeichengliedern

Die Vorzeichengliederanordnung ist direkt abhängig von der Stelle der Barkersequenz. Daherist in Tabelle 3.6 diese Abhängigkeit unter “Barker” vermerkt. Betrachtet man das Ausgangs-signal als ein logisches Signal, kann man den Wert -1 mit Null identifizieren. Mit dieserVereinfachung lässt sich das Ausgangssignal der Schaltung nach Gleichung (3.15) program-mieren.

(3.15)

Registerzustand R

BarkerB

AusgangA

1 1 1

0 1 -1 (0)

1 0 -1 (0)

0 0 1

A R B�=


56

3.5 Forward Error Correction

Die typische Anwendung der Forward Error Correction (FEC) liegt in einer sicheren Übertra-gung der Daten über einen Kanal durch Hinzufügen von redundanter Information. Das Hin-zufügen der redundanten Information wird auch Kanalcodierung genannt. Die zwei ge-bräuchlichsten Kanalcodierungsarten sind die Faltungs- und Blockcodierung. Faltungscodesverarbeiten die zu übertragende Information seriell mit einem oder wenigen Bits zur gleichenZeit. Blockcodes dagegen verarbeiten die Information in relativ großen Blocken, typischer-weise mehrere 100 Bytes. Es gibt eine Vielzahl von nützlichen Faltungs- und Blockcodes undeine Vielzahl von Decodier-Algorithmen, um die Information möglichst fehlerfrei zurück-zugewinnen. Faltungscodierung in Kombination mit Viterbi-Decodierung ist ein weit verbrei-tetes Verfahren bei Kanälen, die durch weißes Gaußrauschen (AWGN) gestört werden.

FEC und ARQ

Die typische Anwendung für Powerline-Modems ist die Datenübertragung zwischen zweiRechnern. Dabei sollen die Daten selbstverständlich unverfälscht beim Zielrechner ankom-men. In einem Powerline-Modem stellen zwei unabhängig voneinander arbeitende Mechanis-men die Datenintegrität sicher: Zuerst teilt das Modem die Daten in einzelne Pakete auf undfügt mittels der CRC zusätzliche Sicherungsbits in den Datenstrom ein. Diese zusätzlichenBits stellen sicher, dass der Empfänger Datenverfälschungen nicht nur erkennen, sondern - inbegrenztem Umfang - auch korrigieren kann. Je mehr Sicherungsbits eingefügt werden, destomehr Fehler können behoben werden.

Datenübertragung per Powerline setzt auf Forward Error Correction (FEC) und Wiederholungfehlerhaft empfangener Daten (ARQ, Automatic Repeat Request), wie es in Abbildung 3.18dargestellt wird.

Bild 3.18: Wiederholung fehlerhaft empfangener Daten mittels ARQ

Bei Musikübertragung an mehrere Empfänger ist ein Quittungsbetrieb jedoch hinderlich. DerVerzicht auf ARQ ermöglicht zudem einen höheren Durchsatz (Abbildung 3.19).


57

Bild 3.19: Datenübertragung bei echtzeitrelevanten Informationen

Der zweite Mechanismus zur Fehlervermeidung setzt auf der Empfängerseite an: Lief dieÜbertragung fehlerfrei - oder korrigiert dank FEC - ab, dann schickt der Empfänger eine Er-folgsmeldung zurück. Bei Datenverlusten setzt er jedoch eine negative Quittung ab und veran-lasst so den Sender, das defekt empfangene Paket noch einmal zu übermitteln; bei positiverRückmeldung gibt der Sender das nächste Paket auf die Leitung. Wird die Übertragung aufdem Spannungsnetz durch kurzzeitige Störungen beeinträchtigt, dann verringert sich zwar dieDatenübertragungsrate aufgrund von Paketwiederholungen, es gehen aber keine Daten ver-loren.

Bei der echtzeitfähigen Übertragung muss die Datensicherung anders erfolgen: Ein Übertra-gungsverfahren mit Quittierung ist praktisch nicht machbar. Ein Sender könnte zwar fehler-hafte Datenpakete an mehrere Dutzend oder Hunderte von Empfängern wiederholen, aber dasDatenmanagement und das ständige Umschalten des Übertragungskanals würden laufendeVerzögerungen verursachen. Eine störungsfreie Echtzeitübertragung wäre unmöglich.

Daher wurde in den Powerline-Modems speziell für die Echtzeitübertragung der Quittierungs-betrieb deaktiviert. Die Sicherung der Daten erfolgt nur noch mittels des eingebauten FEC-Mechanismus. Können die Empfänger-Modems sporadisch auftretende Fehler nicht beheben,dann werden die fehlerhaften Datenpakete verworfen.

4 POWERLINE-COMMUNICATION-CHIPSETS

58

4 Powerline-Communication-ChipsetsDieses Kapitel gibt einen Überblick über zurzeit verfügbare Powerline-Modems. Sie unter-scheiden sich hauptsächlich durch ihre Übertragungsrate und ihr Modulationsverfahren. DieÜbertragungsrate hängt wesentlich davon ab, für welche Normen die jeweiligen Modemskonzipiert wurden, da die Normen die für die Übertragung nutzbare Bandbreite festschreiben.

Im Rahmen des fächerübergreifenden Projektes wurden Powerline-Modems der Firmen Aus-tria Mikro Systeme (Abschnitt 4.1) und Intellon (Abschnitt 4.2) verwendet. Diese Modemswerden daher eingehender vorgestellt.

4.1 Austria Mikro Systeme

Austria Mikro Systeme bietet mit dem AS5501/02 ein Powerline-Modem an, welches denCENELEC EN50065-1 und FCC Standards entspricht. Es arbeitet mit Frequency Shift Keying(FSK) auf einer einstellbaren Frequenz zwischen 95 kHz und 140 kHz und erreicht damit eineDatenrate von 2,4 kbit/s. Die Evaluation-Kits dieser Firma bestehen aus zwei Boards mit zuge-höriger Evaluation Software.

Die wichtigsten technischen Merkmale des AS5501/02 lassen sich wie folgt zusammenfassen.

• Synchroner und Asynchroner Datentransfer

• Halb-Duplex, FSK-Modulation

• Programmierbare Bitrate 600, 1200, 2400 bit/s.

• Sendesignalamplitude 7 Vpp (AS5501) bzw. 14 Vpp (AS5502)

• Programmierbare Trägerfrequenz im Bereich von 95 kHz bis 140 kHz (standardmäßigeEinstellung ist 132,45 kHz)

• Trägererkennung (Carrier Detect)

• Referenzspannungs- und Master-Clock-Ausgänge

• Kompatibel mit dem CENELEC EN50065-1 und FCC-Standard (siehe Abschnitt 2.3)

• Schutz gegen Sendefehler (Dauerträger)

Konzipiert wurde das Powerline-Modem ursprünglich für folgende Anwendungen:

• Fernauslesung für Zähler (Automatic Meter Reading, AMR)


59

• Gebäudeautomation und Prozessleittechnik

• Alarm- und Sicherheitssysteme

• Industrielle Kontrollsysteme

Im Rahmen der vorliegenden Diplomarbeit wurde das Powerline-Modem zur Kommunikationeingesetzt. Seine Anwendung lag in der Übermittlung von Daten eines Chatprogramms. Zurbesseren Handhabung wurde das Modem in ein Gehäuse mit internem Netzteil eingebaut. DieKommunikation sowie die Energieversorgung des Modems kann somit über eine Leitung er-folgen. Die Datenkommunikation zum PC geschieht via serielle Schnittstelle. Über denParallelport lassen sich gegebenenfalls Modem-Einstellungen vornehmen. In Bild 1.1 wird einFoto des AS5501/02 wiedergegeben.

Bild 4.1: Powerline-Modem AS5501/02 von Austria Mikro Systeme

Ein Nachteil des Modems ist die fehlende Stummsschaltung der Datenübertragung an der seri-ellen Schnittstelle, wenn kein Träger im Stromnetz vorhanden ist. Das Modem sendet perma-nent Daten über die serielle Schnittstelle an den PC unabhängig davon, ob ein Träger anliegtoder nicht. Auch die Carrier-Detect-Signalisierung (CD) über die serielle Schnittstelle funk-tioniert nicht zuverlässig. Der Zeitpunkt des Einsetzens des CD-Signals stimmt nicht exakt mitdem Zeitpunkt eines Paketbeginns überein. Dadurch ist die softwareseitige Verwendung vonStartbits bzw. Barkersequenzen notwendig.


60

4.2 Intellon

Die Firma Intellon bietet mit dem INT5130 Chipsatz ein Hochgeschwindigkeitsmodem an,welches Datenraten bis zu 14 Mbit/s über die Stromleitung erlaubt. Die verwendete Modula-tionsart hierbei ist OFDM, welche sich dem gestörten Powerline-Kanal anpasst, um maxi-malen Durchsatz zu erzielen. Dieser Chipsatz wird in einem Evaluation-Kit für etwa 1000$ an-geboten. Intellons Technologie ist kompatibel zur HomePlug-Spezifikation 1.0 der PowerlineAlliance und unterstützt Quality-of-Service sowie eine 56-bit DES-Link-Verschlüsselung.MAC- und Physical-Layer sind bereits vollständig im Chipsatz integriert. Die PCI-Steckkartendes Evaluation-Kits basieren auf dem AMD79C972-Ethernet-Treiber und lassen sich praktischwie gewöhnliche Netzwerkkarten betreiben. Neben einer umfangreichen Dokumentation wirdauch ein Testprogramm mitgeliefert, um den Durchsatz einer Verbindung zu testen. WeitereEinzelheiten zum PowerPacket-Verfahren von Intellon, welches den Physical- und MAC-Lay-er reglementiert, ist Abschnitt 2.3.7 zu entnehmen.

Ein funktionales Blockdiagramm findet sich in Abbildung 4.2.

Bild 4.2: Funktionales Blockdiagramm des Chips INT5130


61

Eine schematische Ansicht der Evaluationkarte ist in Abbildung 4.3 abgebildet.

Bild 4.3: Blockschaltbild der EK5130-Evaluation-PCI-Karte


62

4.3 Echelon

Der PLT-22 Powerline Transceiver von Echelon [10] folgt dem CENELEC StandardEN50065-1 und den FCC-Standard (siehe Abschnitt 2.3). Er bietet eine Datenrate von 5,4 kbit/s bzw. 3,6 kbit/s im CENELEC-Band und verwendet zwei Trägerfrequenzen bei BPSK-Modu-lation. Die Trägerfrequenzen sind 132 und 115 kHz sowie 86 und 75 kHz. Bild 1.1 erläutertden Aufbau des PLT-22.

Bild 4.4: Blockdiagramm des PLT-22 von Echelon


63

4.4 Adaptive Networks

Adaptive Networks [6] bietet drei Powerline-Chipsets mit verschiedenen Datenübertragungs-raten an: Der AN1000-Chipset erlaubt eine Datenrate von 100 kbit/s (Raw-Datenrate 268,8kbit/s), der AN192-Chipset 19,2 kbit/s (Raw-Datenrate 134,4 kbit/s) und der AN48-Chipset4,8 kbit/s (Raw-Datenrate 23,75 kbit/s). Alle Chipsets halten eine Bit-Error-Rate von < 10-9

ein, unterstützen bis zu 65534 Powerline-Stationen pro Netzwerk und verwenden Spread-Spectrum Technik. Weitere Eigenschaften sind Token Passing MAC-Layer und eine integrierteForward Error Correction und Error Detection (FEC, Abschnitt 3.5).

Das gemeinsame Blockdiagramm der Chipsets von Adaptive Networks ist in Bild 4.5 darge-stellt.

Bild 4.5: Gemeinsames Blockdiagramm der Chipsets von Adaptive Networks


64

4.5 Itran Communications

Itran Communications [7] bietet das IT800 „SCP Ready“ Evaluation-Kit an. Ein Evaluation-Kit kostet 2500 US $ und beinhaltet zwei Evaluation Boards mit technischer Dokumentationund zugehöriger Software. Der IT800 moduliert die Signale mit DCSK (Differential CodeShift Keying) und verwendet Forward Error Correction (FEC). Die Aussendungen bes-chränken sich auf den Frequenzbereich 100-400 kHz nach den „USA FCC part 15 restric-tions“. Sie können allerdings auch auf die europäischen CENELEC A-Frequenzen (20-80 kHz,Outdoor) und CENELEC B-Frequenzen (95-125 kHz, Indoor) angepasst werden (siehe Ab-schnitt 2.3). Die verfügbare Datenrate beträgt 7,5 kbit/s.

Itrancomm bietet auch einen schnelleren Chip mit 2,5 Mbit/s an - den ITM1-B. Er arbeitet mitdem Adaptive Code Shift Keying (ACSK) Modulationsverfahren [8]. Ein Blockschaltbild wirdin Bild 4.6 gezeigt.

Bild 4.6: Blockdiagramm des ITM1-B von Itran Communications


65

4.6 Inari

Inari’s Technologie [5] verspricht 2 Mbit/s (später auch 12 Mbit/s) mit Quality-of-Service Un-terstützung für multimediale Anwendungen. Als 2 Mbit/s-Variante bietet Inari den ChipIPL0202 mit integriertem MAC/PHY-Controller an. Der IPL0202 ist über ein externes Power-line Frontend (PFE) mit der Energieversorgungsleitung verbunden. Siehe hierzu Abbildung8.1. Das System wird gesteuert durch einen internen 8051-Mikrocontroller, der den Code auseinem externen ROM ausführt. Daten werden über Energieversorgungskabel mit Hilfe vonvier modulierten Trägern in BPSK oder QPSK übertragen.

Bild 4.7: Blockdiagramm des IPL0202 von Inari

Von Inari wird ein Software Development Kit (SDK) angeboten, welches ein einfaches Appli-cation Programmer Interface (API) zur Verfügung stellt. Es erlaubt Entwicklern die schnelleProgrammierung von PC-Anwendungen.

Das Hardware Development Kit (HDK) besteht aus drei Boards konfiguriert als externe Pow-erline-Netzwerk-Adapter für PCs. Es beinhaltet weiterhin USB- und Parallelport-Treiber so-wie Software für alle Windows-Betriebssysteme. Die HDKs kosten je nach Leistungsumfang2000 US $ bzw. 3800 US $.


66

4.7 Cogency

Cogency bietet den so genannten Piranha-Chipsatz mit ähnlicher Leistung an wie Intellon. Erverspricht Datenraten von bis zu 14 Mbit/s und benutzt das OFDM-Modulationsverfahren mitFEC, um eine verlässliche Datenübertragung zu gewährleisten. Die FEC arbeitet mit Faltungs-codierung der Rate 1/2, die in guten Kanälen auf eine Rate von 3/4 punktiert werden kann.MAC- und Physical-Layer sind ebenfalls direkt im Chipsatz integriert. Die Kompatibilität zurHomePlug-Spezifikation v1.0 wird garantiert. Das funktionale Blockschaltbild findet sich inAbbildung 4.8 wieder.

Bild 4.8: Funktionales Blockschaltbild des Piranha-Chipsatzes


67

4.8 Überblick der Anbieter

Tabelle 4.1 gibt zusammenfassend wichtige technische Eckdaten der vorhin vorgestelltenChipsätze wieder.

Tabelle 4.1: Vergleich heutiger Anbieter von Powerline-Modems

Firma Chipsatz Modulation Datenrate Standard(siehe Abschnitt 2.3)

EVK-Preis

Austria Micro Systeme AS5501/02 FSK 2,4 kbit/s CENELEC/FCC

~400 Euro

Echelon PLT-22 Dual carrier 3 kbit/s CENELEC Lizenzen

Itran Communication IT800 DCSK 7,5 kbit/s CENELEC/FCC

2500$

ITM1-B ACSK 2,5 Mbit/s

Adaptive Networks AN48 Spread-Spectrum

4,8 kbit/s

AN192 Spread-Spectrum

19,2 kbit/s 134,4-403,2 kHz

AN1000 Spread-Specttrum

100 kbit/s

Inari IPL0202 DBSK, DQPSK

2 Mbit/s 2000$/3800$

angekündigt 12 Mbit/s

Intellon INT5130 OFDM 14 Mbit/s HomePlug 1.0

1000$

Cogency Piranha OFDM 14 Mbit/s HomePlug 1.0

5 PROGRAMMIERUNG DES PHY-LAYERS

68

5 Programmierung des PHY-Layers5.1 Aufgabenstellung

Im Rahmen des fächerübergreifenden Projektes „Chatroom over Powerline“ soll ein Physical-Layer als Schnittstelle zwischen Powerline-Modem und MAC-Layer erstellt werden. Die Pro-grammierung erfolgt unter MS Visual Studio 6.0 C++ als Konsolenanwendung. Der zu pro-grammierende Physical Layer (siehe Kapitel 2.4.1) soll folgende Aufgaben erfüllen:

• Anbindung an die serielle Schnittstelle des PCs

• Anbindung an den MAC-Layer

• Forward Error Correction mittels Faltungscodierung und Viteri-Algorithmus

• Variable Codierungsrate durch Punktierung

• Verifikation des Paket-Headers und der Payload durch Cyclic Redundancy Checksums

• Rahmensynchronisation

• Feststellen der Qualität der Verbindung

Die verwendete Hardware sind Powerline-Modems der Firma Austria Mikro Systeme. Eineausführliche Beschreibung dieser Modems befindet sich in Abschnitt 4.1.


69

5.2 Paketaufbau

Die Pakete bestehen aus einem Header- und einem Payload-Abschnitt. Der Header besitzt einefeste Länge von 10 Byte. Er beginnt mit einer 2-Byte-langen Barkersequenz zur Feststellungdes Paketbeginns aus dem laufenden Datenstrom. Im darauf folgenden Byte befindet sich dieInformation über die Punktierungsrate in den 3 höchstwertigsten Bit. In den restlichen 5 Bitwird die Längeninformation des Datenteils transportiert. Daraufhin folgt eine jeweils 2-Bytelange Ziel- und Absender-Adresse. Das nächste Byte beinhaltet MAC-Schicht relevante Infor-mationen. Abgeschlossen wird der Header durch eine Headerprüfsumme der Länge 1 Byte undeinem Terminierungsbyte, um einen definierten Endzustand im Viteri-Algorithmus zu erhalt-en.

Die Länge der Payload ist variabel zwischen 7 und 131 Byte. Daten werden in Bytelängen vonmindestens 4 Byte bis maximal 128 Byte transportiert, wobei die Datenlänge stets ein Viel-faches von 4 Byte betragen muss. Die restlichen 3 Byte der Payload entfallen auf die Prüf-summe der Daten sowie auf ein Terminierungsbyte. Eine anschauliche Darstellung des Pa-ketschemas zeigt Abbildung 5.1.

Bild 5.1: Paketschema

Nach der Faltungscodierung mit der Coderate 1/2 beträgt die Länge des gesamten Paketes dasDoppelte, wenn man von der Barkersequenz absieht, welche uncodiert bleibt. Dies ist in Ab-bildung 5.2 verdeutlicht.

Bild 5.2: Paketschema nach der Codierung (Rate: 1/2, unpunktiert)

8 16 24 32 Bit

32 Bit

Barkercode P Length Source Address

Source Address Destination Address MAC

CRC8 Termination1 Data

Data CRC16 Termination2

2 32-280 Byte

min. 32, max. 280 Byte

B Header Payload

18


70

• Barkercode: Enthält eine 13 Bit lange Barkersequenz zur Rahmensynchronisation. Die 3niederwertigsten Bit des 2. Byte werden mit Nullen aufgefüllt.

• P: 3 Bit: Gibt die Punktierung an zur Dekodierung der Daten (Payload)

• Length: 5 Bit: Übermittelt die Länge der Payload in einer linearen Schrittweite von 4Byte. Es gibt 25 = 32 Möglichkeiten der Paketgröße bei einer minimalen Anzahl derDatenbytes von 4 Byte bis zu der maximalen Datenlänge von 25*4 = 128 Byte.

• Source-/Destination Adress: Enthalten die eindeutigen Adressen für Sender undEmpfänger. Auch Multicast- und Broadcast-Adressen für Destination-Adress sindmöglich.

• MAC: Beinhaltet 8 Kontroll-Bits für die MAC-Schicht

• 1 Bit Retry Flag: Wird bei nochmaligem Senden des gleichen Pakets gesetzt, damit der Empfänger keine Duplikate erhält.

• 7 Bit Reserved: frei zur zukünftigen Verwendung

• CRC8: 8 Bit CRC über den Header (von Coderate bis MAC-CTRL)

• Termination1: 8 vordefinierte Bits zur Terminierung der Codierung

• Data: Enthält die Daten der KOM-Schicht. Die maximale Länge von 128 Bytes wird vonder COM Schicht sichergestellt.

• CRC16: 16 Bit CRC über die Datenbytes

• Termination2: 8 vordefinierte Bits für den Abschluss Codierung der Payload.

5.3 Schnittstelle PHY-/MAC-Layer

Die PHY-Schicht stellt dem MAC-Layer folgende Funktionen zur Verfügung:

• int PHY_init(int comport) Wird von der MAC-Schicht einmalig aufgerufen bei Programmstart. Übergibt die Nummer des COM-Ports und ruft die Empfangsroutine der PHY-Schicht auf.

• bool PHY_send(Header h, byte* payload, int size)

a) Gibt den Header h und die Payload payload der Größe size an die PHY-Schichtzum Senden weiter. Anschließend liefert die Methode einen Fehlercode zurück, 0 beifehlerfreier Ausführung.

b) Synchron, d.h. die Methode blockiert, bis das Paket gesendet wurde.

• boolean PHY_IsCarrier() Liefert true zurück, wenn der Bus belegt ist, ansonsten false.


71

Umgekehrt hält die MAC-Schicht folgende Funktionen für die PHY-Schicht bereit:

• int receive(Header* h, byte* payload, int *received)

a) Empfängt Header h und die Payload payload von der PHY Schicht. Die Größe derPayload wird in received zurückgeliefert. Liefert aufgetretene Fehleranzahl zurück, -1 bei fehlerfreier Ausführung (inactivity), 0..n:Anzahl aufgetretener Fehler (ermöglicht Anpassung der Kodierungsparameter)

b) Puffer wird von PHY Schicht allokiert.

• void CarrierStateChange(boolean carrierstate)

Wird von der PHY Schicht aufgerufen, wenn sich der Zustand des Carriersignals ändert.Übergibt true, wenn der Bus belegt ist, ansonsten false.

Diese Funktionen befinden sich in derselben Bibliothek wie die Funktionen des MAC-Layers.


72

5.4 Die serielle Schnittstelle

Die Programmierung der seriellen Schnittstelle in MS Visual C++ unter Windows erfordert dieKenntnis spezieller Funktionen. Empfehlenswert hierzu sind die Internetseiten des MSDN(Microsoft Developer Network) [17], speziell der Artikel “Serial Communication in Win32”[18].

Das Öffnen der seriellen Schnittstelle geschieht ähnlich dem Öffnen einer Datei mit der Funk-tion CreateFile(). Ebenso verhält es sich mit dem Schreiben bzw. Lesen der seriellenSchnittstelle. Man verwendet die Funktionen WriteFile() und ReadFile().

5.4.1 Overlapped/Nonoverlapped Modus

Grundsätzlich können alle Funktionen, die eine Aktion des Systems abwarten müssen, imOverlapped- oder Nonoverlapped-Modus aufgerufen werden:

Der Nonoverlapped-Ansatz ist programmiertechnisch sehr einfach, hat aber gewisse Nach-teile. Während der Abarbeitung eines Befehls, wie z. B. dem Schreiben auf die serielleSchnittstelle, wird der aufrufende Thread blockiert. Sobald die Funktion ausgeführt wurde,kehrt sie zum aufrufenden Thread zurück, der seine Arbeit dann fortführen kann. Diese Art,die Schnittstelle zu benutzen, ist nützlich bei Anwendungen mit mehreren Threads, weilwährend ein Thread aufgrund einer I/O-Operation blockiert ist, andere Threads weiterarbeitenkönnen. Die Zugriffssteuerung auf die Schnittstelle muss in diesem Fall vom Programm selbstübernommen werden. Wenn ein Thread durch eine I/O-Operation blockiert ist, wird in allenanderen Threads die Ausführung von I/O-Operationen ebenfalls blockiert, bis die ursprüng-liche Operation beendet ist. Zum Beispiel, wenn ein Thread auf die Beendigung der FunktionReadFile() wartet, werden I/O-Operationen in allen anderen Threads blockiert.

Der Overlapped-Ansatz ist etwas aufwendiger in der Programmierung, erlaubt aber größereEffizienz und Flexibilität. Ein für overlapped Operationen geöffneter Port erlaubt mehrerenThreads zur gleichen Zeit I/O-Operationen auszuführen, ohne Threads zu blockieren. Darüberhinaus erlaubt er einem einzelnen Thread mehrere unterschiedliche Anfragen auszuführen undwährend der Abarbeitung Hintergrundarbeit zu leisten.Overlapped I/O-Operationen bestehen aus zwei Teilen: der Erstellung einer Operation und derDetektion ihrer Beendigung. Um die Operation durchzuführen, wird eine Overlapped-Struc-ture, ein manual-reset Event zur Synchronisation sowie der Aufruf der entsprechenden Funk-tion (ReadFile(), WriteFile()) benötigt. Die Detektion der Beendigung einer I/O-Opera-tion erfordert das Warten auf einen Event-Handle, die Überprüfung des Operationsergebnissesund die Verarbeitung der Daten. Der Grund, warum eine Overlapped-Operation mehr Pro-grammieraufwand erfordert, liegt darin, dass es mehr Fehlerquellen geben kann. Wenn eine


73

Nonoverlapped Operation fehlschlägt, gibt die Funktion einen Error-Code zurück. Wenn eineOverlapped-Funktion fehlschlägt, kann sich ein Fehler bei der Erstellung der Operation oderwährend der Ausführung ereignen. Ebenfalls sollte man beim Warten auf die Beendigung einerI/O-Operation Time-Out-Kriterien verwenden.

In beiden Anwendungen, single-threaded als auch multi-threaded, muss eine Synchronisationzwischen den I/O-Operationen und der Verarbeitung der Daten stattfinden. Ein Thread mussblockiert werden bis ein Ergebnis der I/O-Operation verfügbar ist. Der Vorteil der overlapped-Operationen liegt darin, dass der Thread zwischen dem Aufruf und der Beendigung der I/O-Operation Hintergrundarbeit verrichten kann.

Wenn man sich zwischen Nonoverlapped und Overlapped Modus entscheiden muss, sollteman bedenken, dass Overlapped-Operationen auf den meisten Betriebssystemen nicht unter-stützt wird. In diesem Fall muss dem Nonoverlapped Modus unter Anwendung von Threadsden Vorzug gegeben werden.

5.5 Multithreading

Es gibt viele Situationen in einem Betriebssystem, die vorteilhaft geregelt werden können,wenn in einem Programm oder einem Prozess bestimmte Aktionen parallel ausgeführt werdenkönnen. Zu diesem Zweck verwendet man Multithreading.

Ein Thread (Kontrollfaden, Abarbeitungsfaden) kann somit eine sequentiell abzuarbeitendeBefehlsfolge innerhalb eines Programms oder Prozesses definieren.

Man spricht von Multithreading, wenn innerhalb eines Programms zwei oder mehr neben-läufige Befehlsfolgen abgearbeitet werden. Ein derartiges Programm wird als "nebenläufig"bezeichnet. Für die Programmierung von Threads gibt es spezielle Befehle oder Bibliotheks-funktionen innerhalb einer Programmierumgebung.

Bei Multithreading wird ein einzelnes Programm in mehrere Unterprogramme (= Threads)aufgeteilt, die sich gleichzeitig einen gemeinsamen Speicher teilen. Das Umschalten geschiehtweitgehend automatisch durch das System. Multithreading bietet eine sehr feinkörnige Paral-lelität. Innerhalb eines Programms sind die Interaktionen zwischen Threads auch sehr viel in-tensiver als zwischen zwei völlig verschiedenen Programmen. Da die Programmentwicklerden Überblick über das gesamte Programm haben, sind sie auch verantwortlich dafür, dass sichzwei Threads nicht gegenseitig beeinträchtigen.

Ein Programm ist hierbei ein Prozess, jeder Prozess hat einen Hauptthread (primary thread)und jeder Hauptthread kann untergeordnete Threads starten, die wiederum auch Threads star-


74

ten können. Windows teilt dabei jedem Thread Rechenzeit zu. Wenn diese Zeit verstrichen ist,wird dieser Thread angehalten und der nächste Thread wird ausgeführt. Dabei wechselt dasBetriebsystem so schnell, dass der Anwender glaubt, die Programme laufen gleichzeitig ab.

Vorteile von Threads:

• Je mehr Prozesse/Threads eine Anwendung hat, desto mehr Rechenzeit bekommt dieAnwendung vom Betriebsystem.

• Es können mehrere Programme gleichzeitig ausgeführt werden (Multitasking).

• Jedes Programm kann mehrere Arbeiten gleichzeitig ausführen.

Einen Thread erzeugt man dadurch, dass man die Funktion CreateThread() aufruft. Sie ist fol-gendermaßen definiert:

HANDLE CreateThread(

LPSECURITY_ATTRIBUTES lpThreadAttributes, DWORD dwStackSize, LPTHREAD_START_ROUTINE lpStartAdress, LPVOID lpParameter, DWORD dwCreationFlags,LPDWORD lpThreadID,

);

Parameter:

lpThreadAttributes

Zeiger auf die Sicherheitsattribute für den Thread. Der Standardwert ist NULL. Damit wird der Thread mit dem gleichen Sicherheitsprofil wie die Anwendung erzeugt. Der Standard-wert ist eigentlich zu bevorzugen.

dwStackSize

Stack-Größe, die für den neuen Thread bereitgestellt wird. Bei einer Angabe von 0 erhält der Thread die gleiche Stack-Größe wie der aufrufende Thread.

lpStartAdress

Hier wird die Adresse der Funktion angegeben, die der Thread beim Start aufrufen soll.

lpParameter

Zeiger auf eine 32-bit Parameter, der der Threadfunktion als Wert übergeben wird.

dwCreationFlags

Ein Flag zum Erzeugen des Threads. Dieses Flag kann einen von zwei Werten enthalten. Wenn man den Wert CREATE_SUSPENDED übergibt, wir der Thread in einem ange-


75

haltenen Zustand erzeugt. Der Thread startet erst dann, wenn die Funktion ResumeThread() für den Thread aufgerufen wird. Übergibt man den Wert 0 (der Standardwert), beginnt der Thread die Ausführung in dem Moment, zu dem er erzeugt wird.

lpThreadId

Zeiger auf eine 32-bit Variable, in der die Thread ID gespeichert wird.

Jeder Thread besitzt auch einen privaten Kontext, nämlich:

• seinen Registerstatus, insbesondere den Programmcounter,

• seinen Stack,

• seine Thread-ID,

• seine Priorität.

5.6 Synchronisation von Threads

In dem Maße wie die Synchronisierungsmechanismen für Threads dafür ausgelegt sind, denZugriff auf begrenzte Ressourcen zu steuern, sind sie auch dafür vorgesehen, unnötige Pro-zessorzeit in Threads zu unterbinden. Je mehr Threads gleichzeitig laufen, desto langsamerführt jeder einzelne Thread seine Aufgaben aus. Wenn ein Thread also nichts zu tun hat, blo-ckiert man ihn, und belässt ihn im Leerlauf. Damit erhalten andere Threads mehr Prozessorzeitund laufen deshalb schneller, bis die Bedingungen erfüllt sind, dass der Thread im Leerlauf et-was zu tun bekommt.

Aus diesem Grund verwendet man Ereignisse - um Threads den Leerlauf zu ermöglichen, bisdie Bedingungen erfüllt sind, dass sie etwas zu tun bekommen. Die Ereignisse zur Synchro-nisation von Threads arbeiten nicht nach den Mechanismen der Ereigniswarteschlangen. Statteine Nummer zu erhalten und dann darauf zu warten, dass diese Nummer an die Behandlung-sroutine von Windows übergeben wird, sind Ereignisse der Thread-Synchronisierung eigent-liche Objekte, die sich im Speicher befinden. Jeder Thread, der auf ein Ereignis warten muss,teilt dem Ereignis mit, dass er auf dessen Auslösung wartet, und nimmt dann einen Ruhe-zustand ein. Wird das Ereignis ausgelöst, geht ein Signal an jeden Thread, der dem Ereignisseinen Wartezustand bekannt gegeben hat. Die Threads nehmen die Verarbeitung genau andem Punkt auf, wo sie dem Ereignis die Warteabsicht mitgeteilt haben.


76

Die insgesamt vier Mechanismen zur Synchronisation von Threads sind:

Critical Sections

Mit Hilfe von kritischen Bereichen erreicht man einen wechselseitigen Ausschluss vonThreads, sodass bestimmte Programmabschnitte immer nur von einem Thread ausgeführt wer-den können. Ein oder mehrere andere Threads, die den kritischen Bereich betreten wollen,müssen warten bis der Thread den kritischen Bereich wieder verlässt, wie in Abbildung 5.3dargestellt.

Bild 5.3: Critical Section

Mutexe

Mutexe haben wie die im vorigen Abschnitt besprochenen Critical Sections die Aufgabe, ge-genseitigen Ausschluss (mutual exclusion) zu gewährleisten. Der Hauptunterschied zu denCritical Sections ist, dass Mutexe auch von Threads mehrerer Prozesse genutzt werden kön-nen.

Semaphore

Ein allgemeineres Konzept sind die so genannten Semaphoren (Signalmasten, Leuchttürme),die im Gegensatz zu Mutexen nicht nur die Zustände signaled und unsignaled einnehmen kön-nen, sondern beliebig viele (abzählbar viele). Es sind Zähler deren Werte erhöht oder herab-gezählt werden je nachdem welche Operation auf einen Semaphor einwirkt. Ist der interneZähler NULL muss ein Thread warten, wenn er mit seiner Operation den internen Zähler her-absetzen will.

Ereignisse

Events (Ereignisse) sind eine sehr einfache Form von Synchronisationsobjekten. Sie dienender Information über den Abschluss einer Operation. Die Art der Operation oder des Ereignis-


77

ses kann dabei beliebig sein, denn ein Event kann nur explizit von einem Programm ausgelöst,d. h. das entsprechende Objekt in den “signaled State” versetzt werden.

Bild 5.4: Ereignisse

Ein Ereignis kann in Windows NT zwei Zustände besitzen.

• signalisierend: Dieser Zustand bedeutet, dass ein Thread, der eine Anfrage stellt eine Ant-wort erhält und so der anfragende Thread sein Programm weiter ausführen kann.

• nicht signalisierend: dieser Zustand bedeutet, dass ein Thread, der eine Anfrage stellt keineAntwort erhält und so der anfragende Thread blockiert bis das das Ereignis in den Zustand sig-nalisierend wechselt.

Bei der Synchronisation mit Hilfe von Ereignissen muss man als erstes einen so genannten Er-eignis-Handler erstellen. Dies geschieht durch die Funktion CreateEvent(), welche auch beider Programmierung der seriellen Schnittstelle verwendet wurde:

HANDLE CreateEvent(

LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState, LPCTSTR lpName

);

Parameter:

lpEventAttributes

Ein Pointer auf SECURITY_ATTRIBUTES-Struktur. NULL kann eingesetzt werden wenn keine Sicherheitsaspekte berücksichtigt werden müssen.


78

bManualReset

Der Parameter bManualReset legt fest, um welche von zwei verschiedenen Arten von Event-Objekten es sich handeln soll: TRUE = Auto-Reset, FALSE = Manual-Reset

bInitialState

Diese Flag gibt den Anfangsstatus des Ereignisses an: TRUE = signalisierend, FALSE = nicht signalisierend.

lpName

Hier kann dem Ereignis ein Namen geben werden, damit auch andere Prozesse mit diesem Ereignis arbeiten können. Man muss allerdings beachten, dass der verwendete Name nicht bereits vergeben ist. Ereignisse, Mutex und Datei-Mapping-Objekte verwenden dabei denselben Namensbereich. Ist dieser Wert NULL so kann das Ereignis nur innerhalb des Prozesses verwendet werden. Als Rückgabewert dieser Funktion erhält man einen Handle auf das Ereignis oder NULL falls ein Fehler aufgetreten ist.

Bei einem Manual-Reset Event werden alle wartenden Threads geweckt, und das Event-Objektbleibt im Signalled State, bis es explizit - eben manuell - wieder in den Nonsignalled Stateversetzt wird.

Dagegen verhält sich ein Auto-Reset Event ähnlich wie ein Mutex: geht das Objekt in den Sig-nalled State, so wird ein Thread, der auf das Objekt wartet, geweckt, und das Event-Objektwird automatisch wieder in den Nonsignalled State zurückgesetzt. Wenn im Moment keinThread auf das Auto-Reset Event wartet, so bleibt dieses im Signalled State, bis ein Threadeine Wartefunktion für es beendet, und wird dann automatisch wieder in den NonsignalledState gesetzt.

Welche Art von Event-Objekt benötigt wird, hängt ganz von der Logik der Applikation ab.

Ein Synchronisationsobjekt befindet sich zu jedem Zeitpunkt in einem von zwei Zuständen:

• Signalled State

• Nonsignalled State

Die Bedeutung dieser beiden Zustände ist vom Typ des Objektes abhängig. Die Gemein-samkeit ist, dass ein Thread mit Hilfe der Wait Services des Objektmanagers darauf wartenkann, dass ein Objekt in den Signalled State übergeht. Solange das Objekt im NonsignalledState ist, ist der Thread blockiert. Sobald das Objekt in den Signalled State übergeht, weckt dasBetriebssystem einen oder alle (je nach Typ des Objekts) auf dieses Objekt wartenden Threadsauf.


79

5.7 Eventgesteuerte Threads

Um eine reibungslose Kommunikation über die serielle Schnittstelle zu gewährleisten, ver-wendet das Programm zwei Threads - einen für den Empfang und einen für die Aussendungvon Paketen. Diese nebenläufige Programmierung bietet eine ständige Empfangsbereitschaftbei gleichzeitiger Bereitschaft zur Aussendung von Paketen. Damit eine versehentliche Aus-sendung während des Empfangs eines Paketes ausgeschlossen wird, verwenden die beidenThreads Events. Durch Events wird der nebenläufige Programmablauf von Threads geregelt.In Abbildung 5.5 und 5.6 werden Ablaufdiagramme des Sende- und Empfangsthreads darge-stellt. Der Sendethread stellt hierbei den von Anfang an vorhandenen Hauptthread dar. Er star-tet in der Routine PHY_Init() den Empfangsthread und übernimmt anschließend selbst dieFunktion des Sendethreads.

Zur Synchronisation der Kommunikation in den Threads werden insgesamt fünf Events defi-niert.

• EventSendRoutineStart: Signalisiert den Aufruf der Sende-Routine

• EventSendRoutineEnd: Signalisiert die Beendigung der Sende-Routine

• EventCarrierDetect: Signalisiert wenn das Carrier-Detect-Signal anliegt

• EventReceive: Signalisiert das Ende des Lesens von der seriellen Schnittstelle

• EventSend: Signalisiert das Ende des Schreibens in die serielle Schnittstelle


80

Bild 5.5: Ablaufdiagramm des Haupt- bzw. Sendethreads

Die Events zur Signalisierung des Starts und des Endes der Sende-Routine sowie das Carrier-Detect-Event werden durch das Programm gesetzt bzw. zurückgesetzt. Bei den EventsEventSend und EventReceive handelt es sich um Events, welche nach der Ausführungder Funktionen WriteFile() und ReadFile() automatisch gesetzt und zurückgesetztwerden. Diese Events sind eine Folge der Programmierung der seriellen Schnittstelle im Over-lapped-Modus (siehe Kapitel 5.4.1).

StarteReceive-Thread

Warte aufSendebefehl

BeginnSendethread

Set EventSendRoutineStart

SendePaket

Set EventSendRoutineEnd

Receive Thread

Warte aufSende-Ende


81

Bild 5.6: Ablaufdiagramm des Empfangsthreads

Der Aufruf des Empfangsthreads erfolgt durch den Hauptthread. Der Empfangsthread wartetauf zwei Ereignisse. Wenn ein Träger signalisiert wird, liest er das ankommende Paket, de-codiert, überprüft und leitet es an die MAC-Schicht weiter. Falls ein zu sendendes Paket sig-nalisiert wird, wartet die Routine solange bis der Sendevorgang abgeschlossen ist und beginntvon vorne.

ResetSendRoutineStart

Warte auf

CD oderSendRoutineStart

Warte aufSendRoutineEnd

Reset EventCD

LesePaket

Warte aufLese-Ende

Aufruf vonSend-Thread

WelchesEvent?

CD-Event SendRoutine-Event

ResetSendRoutineEnd


82

5.8 Programmbeschreibung

Die Funktionen des Physical-Layers können auf zwei verschiedene Arten genutzt werden. Dieerste Nutzungungsmöglichkeit ist in Zusammenarbeit mit dem MAC-Layer. Der MAC-Layerruft die Funktionen des Physical-Layers eigenständig auf bzw. wird durch Funktionen desPhysical-Layers benachrichtigt, z. B. wenn ein neues Datenpaket empfangen wird.

Zu Test- und Demonstrationszwecken kann der Physical-Layer auch als eigenständig ange-sprochen werden. Hierzu ist der Aufruf der Routine main() notwendig. Das Programm kom-muniziert mit dem Benutzer über die Kommandozeilen-Konsole. Beim Start bietet es in einemHauptmenü verschiedene Möglichkeiten, die Datenübertragungsstrecke zu testen:

• Chatmodus

• Monitormodus

• Test-Sendemodus

• Test-Empfangsmodus

Im Chatmodus wird dem Benutzer die Möglichkeit gegeben, mit Benutzern anderer Terminalszu chatten. Es wird keine Information über die Kanalgüte und keine Fehlerstastatistik der Pa-kete angezeigt.

Im Monitormodus können ähnlich wie im Chatmodus Zeichenketten versendet werden. BeimAbsenden einer Nachricht werden zusätzliche Informationen wie Checksummen, Header so-wie Datenblock in hexadezimaler Schreibweise vor und nach der Faltungscodierung und dieLänge des Paketes in Bytes wiedergegeben. Gleiches gilt auch für den Fall eines empfangenenPaketes. Hier werden jedoch zusätzlich noch das original empfangene Paket und eventuelleFehler angezeigt. Angezeigte Fehler können sein:

• Checksummenfehler im Header oder Datenblock

• Paket, welches die Mindestpaketlänge unterschreitet oder Maximallänge überschreitet

• Fehlgeschlagene Rahmensynchronisation

Die Testmodi liefern eine ausführliche Fehlerstatistik über eine Vielzahl von Paketen, um dieStörungen eines Kanals und die Codierung beurteilen zu können. Ein solcher Test wird durch-geführt, indem genau eine Station in den Test-Sendemodus versetzt wird und alle anderen ver-bundenen Stationen in den Test-Empfangsmodus versetzt werden. Im Sendemodus kann einebestimmte Anzahl von Paketen festgelegt werden, die zu Testzwecken ausgesendet werdensollen. Die Länge und Punktierung der Pakete ist dabei stufenweise frei wählbar. Die gleichenAngaben müssen auch empfangsseitig eingestellt werden, damit dem Empfänger die Pakete


83

vorher bekannt sind und er eine genaue Fehlerstatistik erstellen kann. Auf der Sendeseite wirddie zu testende Rohbitfehlerrate eingegeben. Die Fehlerstatistik besteht aus:

• Rohbitfehlerrate

• Innere Bitfehlerrate

• Checksummen-Fehler im Header und Datenblock

• Paketlängenfehler

• Rahmensynchronisationsfehler

• Anzahl der empfangenen Pakete

• Anzahl der empfangenen Bytes

Messergebnisse über den Zusammenhang der Rohbitfehlerrate mit der inneren Bitfehlerratebei verschiedenen Punktierungen können dem Abschnitt 5.9 entnommen werden.


84

5.9 Test der Bitfehlerrate

Um die Bitfehlerrate des Powerline-Übertragungssystems zu messen, wurde der Versuchsauf-bau aus Abbildung 5.7 nachgebaut.

Bild 5.7: Versuchsaufbau zur Messung der Bitfehlerwahrscheinlichkeit

Mit dem Rauschgenerator sollte das Signal-Stör-Verhältnis auf der Übertragungsstrecke derartverändert werden, dass es durch Fehlentscheidungen in den PLC-Modems zu Bitfehlernkommt. Der Leistungsmesser diente der Bestimmung des Signal-Stör-Verhältnisses.

Wurde der Rauschanteil erhöht, kam es ab einem Schwellwert (Störleistungsdichte 2 mW/kHz,Signal 4 dB) zu nicht erkannten Paketen auf der Empfangsseite. Der Empfänger konnte keineBarkersequenz zur Rahmensynchronisation finden und lieferte somit keine Pakete zur Ermit-tlung der Bitfehlerwahrscheinlichkeit. Die Pakete, die empfangsseitig synchronisiert werdenkonnten, wiesen jedoch keine Rohbitfehler auf.

In einem zweiten Versuch wurden die PLC-Modems nur durch eine Zweidrahtleitung mitein-ander verbunden. Die Bitfehler wurden auf der Empfangsseite durch die Software hinzugefügt.Die Roh-Bitfehlerrate konnte als Parameter dem Physical-Layer vorgegeben werden, um dieAuswirkungen auf die innere Bitfehlerrate zu beobachten. Mit dieser Methode wurden mehr-ere Messreihen mit verschiedenartig punktierten Faltungscodes durchgeführt. Die Faltungs-codierung hatte folgende Eigenschaften:

• Rate 1/2

• Generatoren (133, 171)

• Einflusslänge 7

Die verwendeten Punktierungen können in Abschnitt 3.1.7 nachgeschlagen werden. DieErgebnisse dieser Messungen gibt Abbildung 5.8 wieder.

PLC-Modem

Rausch-generator

Leistungs-messer

PLC-Modem


85

Bild 5.8: Messung der Bit-Error-Rate in Abhängigkeit vom Signal-Stör-Verhältnis

Die BER (Bit Error Rate) gibt die innere Bitfehlerrate wieder und das Signal-Stör-Verhältnisentspricht der Roh-Bitfehlerrate. Die Umrechnung der Roh-Bitfehlerrate in das SNR erfolgtemit Hilfe des gaußschen Fehlerintegrals unter Matlab. Deutlich zu erkennen ist die niedrigereBitfehlerrate (BER) des unpunktierten Codes gegenüber den punktierten Codes. Die Bitfehler-raten der punktierten Codes liegen relativ dicht beieinander, so dass man für die Datenübertra-gung besser unterschiedlichere Punktierungsraten auswählt. Die Kurven entsprechen imWesentlichen dem Verhalten von Faltungscodes, wie es der Literatur beschrieben ist [3], [30].

Bei der Messung der inneren Bitfehlerrate wurde bei großen Roh-Bitfehlerraten 400 Paketemaximaler Länge ausgesendet und bei sehr kleinen Roh-Bitfehlerraten bis zu 40000 Paketemaximaler Länge. Dadurch wurde sichergestellt, dass genügend innere Bitfehler (>200)auftreten, um die innere Bitfehlerrate auch bei einer sehr kleinen Roh-Bitfehlerrate zuverlässigzu messen.


86

5.10 Übersicht der Funktionen

Die folgenden Funktionen stellen einen Physical-Layer bereit. Seine Funktionalität umfasstFEC mittels Faltungscodierung und Viteri-Decodierung, Prüfsummenberechnung, Paketauf-bau, Carrier-Detect, Rahmensynchronisation, Sende- und Empfangssteuerung, Errorhandlingund Bitfehlermessung.

5.10.1 CRC8( )

Diese Funktion berechnet die 8-Bit-Prüfsumme über die Headerdaten und liefert sie zurück.

unsigned char CRC8(

unsigned char pointer indata,

);

Parameter:

indata

Ein Pointer auf die Daten, über welche der CRC berechnet werden soll. In der Regel sollten diese Daten auf den Header des Pakets zeigen.

Rückgabewert:

8-Bit-Prüfsumme der Headerdaten.

Bemerkungen:

Die Angabe der Länge der Daten erübrigt sich bei dieser Funktion, da die Länge des Headerskonstant ist. Das Schieberegister wird mit Einsen initialisiert.


87

5.10.2 CRC16( )

Diese Funktion berechnet die 16-Bit-Prüfsumme über die Nutzdaten und liefert sie zurück.

unsigned short CRC16(

unsigned char pointer indata, int datalen,

);

Parameter:

indata

Ein Pointer auf die Daten, über welche der CRC berechnet werden soll. In der Regel sollten diese Daten auf die Nutzdaten des Pakets zeigen.

datalen

Länge der Nutzdaten in Byte.

Rückgabewert:

16-Bit-Prüfsumme der Headerdaten.

Bemerkungen:

Diese Routine arbeitet nach dem Standard CRC-16 der CCITT und verhält sich normgerecht.Überprüft wurde diese Routine durch die Zeichenkette „123456789“ mit anschließenden 16Nullbits. Der resultierende CRC-Wert entspricht dem in [35] genannten Wert 0xE5CC.

Das Schieberegister wird mit Einsen initialisiert.


88

5.10.3 FrameSync( )

Diese Funktion findet anhand einer definierten Barkersequenz den Beginn des gesendetenDatenpakets. Die per Pointer übergebenen Daten werden derart verschoben, dass der Pointerauf das erste Byte des gesendeten Datenpakets zeigt.

bool FrameSync(

unsigned char pointer data, int datal,

);

Parameter:

data

Ein Pointer auf die Empfangsdaten, welche ein Paket enthalten.

datal

Länge der Empfangsdaten in Byte.

Rückgabewert:

TRUE, falls Paketanfang gefunden wurde. FALSE, falls Barkersequenz nicht ermittelt werdenkonnte oder die Paketlänge die Mindestlänge unterschreitet.

Bemerkungen:

FrameSync() korrigiert dabei nicht nur byteverschobene Daten, sondern auch bitverschobeneDaten.


89

5.10.4 Encode( )

Diese Funktion faltungscodiert die übergebenen Daten.

void Encode(

unsigned char pointer indata, unsigned char pointer outdata, int length

);

Parameter:

indata

Ein Pointer auf die zu codierenden Daten.

outdata

Ein Pointer auf die codiererten Daten der Funktion.

length

Länge der zu codierenden Daten in Byte.

Rückgabewert:

kein Rückgabewert

Bemerkungen:

Diese Funktion gibt nicht die neue Länge der codierten Daten zurück, da sie leicht aus derCoderate zu berechnen ist.

Die verwendeten Generatoren sind in oktaler Schreibweise (133, 171) bei einer Einflusslängevon 7. Der Codierer hat somit die Rate 1/2.


90

5.10.5 Puncture( )

Diese Funktion punktiert die codierten Daten.

bool Puncture(

unsigned char pointer data, int pointer datalen, int mode,

);

Parameter:

data

Ein Pointer auf die codierten Daten, die punktiert werden sollen.

datalen

Länge der zu punktierenden codierten Daten in Byte.

Rückgabewert:

TRUE

Bemerkungen:

Diese Funktion benutzt folgende Punktierungen:

Tabelle 5.1: Verwendete Punktierungs-Schemata, [20], [30]

= freie Distanz = Anzahl von Sequenzen bei der Mindestdistanz = Koeffizient zur Abschätzung der Bitfehlerwahrscheinlichkeit

Original-code

R = 5/6 R = 6/7 R = 7/8

m g(1), g(2)

P ,,

P , ,

P ,,

6 133, 171

1101010101

4, 14, 92 111010100101

3, 1, 5 11110101000101

3, 2, 9

dfreeAdfree

Bdfree

dfreeAdfreeBdfree

dfreeAdfree

Bdfree

dfree

Adfree

Bdfree


91

5.10.6 Decode( )

Diese Funktion decodiert die codierten und eventuell auch punktierten Daten.

void Decode(

unsigned char pointer indata, unsigned char pointer outdata, int length, int mode

);

Parameter:

indata

Ein Pointer auf die codierten und eventuell auch punktierten Daten.

outdata

Ein Pointer auf die decodierten Daten.

length

Länge der decodierten Daten in Byte.

mode

Gibt die Art der Punktierung an. 0 - keine1 - Rate 5/62 - Rate 6/73 - Rate 7/8

Rückgabewert:

kein Rückgabewert

Bemerkungen:

Vor dem ersten Aufruf von Decode() muss einmalig die Routine GenerateTrellis() aufgerufenwerden, um die benötigten Trellisdaten zur Verfügung zu haben.


92

5.10.7 GenerateTrellis( )

Generiert die Trellisdatenstruktur insbesondere die Codewörter.

void GenerateTrellis(

void

);

Parameter:

keine

Rückgabewert:

kein Rückgabewert

Bemerkungen:

Wird nur einmal zum Programmstart aufgerufen und ist Vorraussetzung für die Routine De-code(). Die generierten Daten befinden sich in globalen Variablen, damit keine Argumenteübergeben werden müssen.


93

5.10.8 Distance( )

Diese Funktion gibt die Hamming-Distanz zwischen Codewort a und b unter Berücksichtigungder Punktierung zurück.

int Distance(

unsigned char a, unsigned char b, unsigned char puncmask

);

Parameter:

a

Erstes Codewort zur Distanzberechnung.

b

Zweites Codewort zur Distanzberechnung.

puncmask

Gibt an, welche Bits der Codewörter gewichtet werden sollen. Punkmask ist ein Ausschnitt aus der Punktierungsmaske. Eine Eins bedeutet, dass ein Bit an dieser Stelle des Codeworts gewichtet wird. Eine Null bedeutet, dass ein Bit an dieser Stelle des Codeworts nicht gewichtet wird.

Rückgabewert:

Rückgabewerte ist die Hamming-Distanz zwischen Codewort a und b unter Berücksichtigungder Punktierung.

Bemerkungen:


94

5.10.9 Compare( )

Diese Funktion vergleicht bitweise zwei Bytefolgen und gibt die Anzahl der unterschiedlichenBits zurück.

int Compare(

unsigned char a, unsigned char b, int length

);

Parameter:

a

Erste zu vergleichende Bytefolge.

b

Zweite zu vergleichende Bytefolge.

length

Gibt die Länge der Bytefolge in Bytes an.

Rückgabewert:

Rückgabewerte ist die Anzahl Bits, in denen sich die beiden Bytefolgen unterscheiden.

Bemerkungen:


95

5.10.10AddErrors( )

Diese Funktion generiert in eine Bytefolge Bitfehler nach einer vorgegebenen Bitfehlerwahr-scheinlichkeit.

int AddErrors(

unsigned char a, int length, double error_rate

);

Parameter:

a

Bytefolge, der Bitfehler hinzugefügt werden soll.

length

Länge der Bytefolge in Bytes.

error_rate

Gibt die Bitfehlerrate an. [0..1]

Rückgabewert:

Rückgabewerte ist die Anzahl der Bitfehler, die tatsächlich hinzugefügt wurden.

Bemerkungen:


96

5.10.11OpenComPort( )

Diese Funktion öffnet die angegebene serielle Schnittstelle.

void OpenComPort(

int comport

);

Parameter:

comport

Nummer der seriellen Schnittstelle, an der das Modem angeschlossen ist. Mögliche Werte sind [1, 2].

Rückgabewert:

kein Rückgabewert

Bemerkungen:


97

5.10.12PHY_Init( )

Diese Funktion wird als Initialisierungs-Routine vom MAC-Layer aufgerufen. Der MAC-Lay-er übergibt dabei den Port der seriellen Schnittstelle.

void PHY_Init(

int comport

);

Parameter:

comport

Nummer der seriellen Schnittstelle, an der das Modem angeschlossen ist. Mögliche Werte sind [1, 2].

Rückgabewert:

kein Rückgabewert

Bemerkungen:

Zu Beginn öffnet diese Funktion die serielle Schnittstelle, generiert die für die Decodierung er-forderlichen Trellisdaten und initialisiert den Zufallsprozess für den Viterbi-Algorithmus mitder aktuellen Systemzeit des Rechners. Der Zufallsprozess wird benötigt für den Fall, dass aneinen Knoten des Trellisdiagramms zwei Pfade gleicher Metrik reichen.

PHY_Init() stellt somit den Hauptthread dar, der anschließend den Empfangsthread durchden Aufruf der Funktion PHY_Receive() startet. PHY_Init() endet zu Demonstrations-zwecken in einer Warteschleife, welche auf Sendepakete von der Funktion KeyboardIn-put() wartet. Diese Warteschleife ist beim Einsatz der PHY-Funktionen durch den MAC-Layer überflüssig, da dieser eigenständig die Sende Pakete an die Funktion PHY_Send()übermittelt. Ein Ablaufdiagramm von PHY_Init findet sich in Abbildung 5.9.


98

Bild 5.9: Ablaufdiagramm der Funktion PHY_Init()

BeginnPHY_Init

ÖffneCOM-Port

GeneriereTrellisdaten

StarteEmpfangsthread

LeseSendedaten

StarteSende-Routine

InitialisiereZufallsgenerator

nur zurDemonstration


99

5.10.13PHY_Receive( )

Diese Funktion stellt den Empfangsthread dar. Er wartet auf empfangene Pakete, decodiert,überprüft und leitet sie an die MAC-Schicht weiter.

unsigned long _stdcall PHY_Receive(

void* pdata

);

Parameter:

pData

Pointer-Dummy.

Rückgabewert:

kein Rückgabewert

Bemerkungen:

PHY_Receive wird durch die Routine PHY_Init als Empfangsthread aufgerufen. Er mün-det in eine Warteschleife, die auf die Ereignisse CarrierDetect oder StartRoutine wartet. DieSynchronisation des Empfangsthreads mit dem Sendethread mittels Events wird in Kapitel 5.7ausführlich behandelt.

Abbildung 5.10 zeigt ein Ablaufdiagramm der Funktion PHY_Receive. Nach dem Empfangeines Paketes erfolgt zuerst eine Validierung bezüglich der Paketlänge. Darauf folgt die Rah-mensynchronisation durch die Erkennung eines Barkercodes. Nachdem der Paketanfang be-kannt ist, wird der Header decodiert und mit Hilfe der Header-Checksumme überprüft. Gleich-es geschieht anschließend mit dem Datenteil. Wenn alle Validierungen positiv verlaufen sind,wird das decodierte Paket an den MAC-Layer weitergereicht und die Routine wartet auf dasnächste Paket.


100

Bild 5.10: Ablaufdiagramm der Funktion PHY_Receive()

CD-ONMitteilung an MAC

LöscheEmpfangsbuffer

Warte aufLese-Ende

CD-OFFMitteilung an MAC

Frame-synchronisierung

Lese Paket

DecodierungHeader

OK?

HeaderCRC-Check

Warte auf CD

nein

DecodierungData

PaketlängeOK?

nein

ja

OK?

DataCRC-Check

ja

Paketübergabean MAC

ja

nein

OK?

ja

nein


101

5.10.14PHY_Send( )

Diese Funktion stellt den Sendethread dar. Er wartet auf die Sendeaufforderung durch denMAC-Layer bzw. durch den User, codiert die Daten und sendet das Paket aus.

void PHY_Send(

unsigned char* wheaderunsigned char* wdata

);

Parameter:

wheader

Pointer auf die zu sendenden Headerbytes ohne Barkercode, Terminierung und Check-summe. Die Länge der Headerdaten beträgt 5 Bytes. Das erste Byte gibt die Datenlänge und die Punktierung an. Danach folgen jeweils 2 Bytes für die Absender- und Zieladresse. Eine ausführliche Beschreibung des Paketaufbaus findet sich in Kapitel 5.2.

wdata

Pointer auf die zu sendenden Datenbytes ohne Terminierung und Checksumme. Die maxi-male Länge der Sendedaten wird durch die Konstante RECEIVELEN zu Programmbeginn festgelegt.

Rückgabewert:

kein Rückgabewert

Bemerkungen:

Die Hauptaufgabe der Funktion PHY_Send ist es, die übergebenen Daten mit einer Prüf-summe zu versehen und zu encodieren. Nachdem die Information fehlergesichert in ein Paketgepackt wurde, wird sie ausgesendet. Die Funktion PHY_Send wird nebenläufig zur FunktionPHY_Receive ausgeführt. Die Synchronisation des Empfangsthreads mit dem Sendethreadmittels Events wird in Kapitel 5.7 ausführlich behandelt.

Abbildung 5.10 zeigt ein Ablaufdiagramm der Funktion PHY_Send.


102

Bild 5.11: Ablaufdiagramm der Funktion PHY_Send()

Berechne/füge anHeader-CRC

EncodiereHeader

EncodiereData

PunktiereData

SendePaket

Berechne/füge anData-CRC

FügeBarkercode an

WarteSendepaket

LöscheSendebuffer

Warte aufSende-Ende

Terminierungan Header

Terminierungan Data


103

5.10.15PHY_IsCarrier( )

Mit Hilfe dieser Funktion kann der MAC-Layer feststellen, ob derzeit ein Träger detektiertwurde.

bool PHY_IsCarrier(

);

Parameter:

keine

Rückgabewert:

Der Rückgabewert ist Eins bei detektiertem Träger und Null, wenn kein Träger erkannt wurde.

Bemerkungen:

keine


104

5.10.16PHY_TestReceive( )

Diese Funktion stellt den Empfangsthread für den Test der Bitfehlerraten dar. Er wartet aufempfangene Pakete, decodiert, überprüft und zählt die Bitfehler. Am Ende einesTestdurchlaufs wird eine Fehlerstatistik erzeugt, die folgende Angeaben enthält:

• Roh-Bitfehlerrate

• innere Bitfehlerrate

• Fehlerhafte Pakete (CRC-Fehler, Synchronisationsfehler, zu kurze Pakete)

• Anzahl der empfangenen Roh- und Nutzdaten

Im Test-Empfangsmodus muss die gleiche Paketlänge und Punktierung angegeben werden wieauf der Sendeseite, damit dem Empfänger die ausgesendeten Pakete bekannt sind.

unsigned long _stdcall PHY_TestReceive(

void* pdata

);

Parameter:

pdata

Zeiger-Dummy.

Rückgabewert:

kein Rückgabewert

Bemerkungen:

PHY_Receive wird durch die Routine PHY_Init als Empfangsthread aufgerufen. Er mün-det in eine Warteschleife, die Ereignisse CarrierDetect oder StartRoutine wartet. Die Synchro-nisation des Empfangsthreads mit dem Sendethread mittels Events wird in Kapitel 5.7 ausführ-lich behandelt.


105

5.10.17PHY_TestSend( )

Diese Funktion stellt den Sendethread zum Test der inneren Bitfehlerrate dar. Er fragt nacheiner Anzahl von Paketen, die zu Testzwecken ausgesendet werden soll. Weitere Angaben bee-influssen die Paketlänge und Punktierung. Die Angaben müssen mit denen im Empfangsmo-dus auf der Empfangsseite übereinstimmen, damit dem Empfänger die ausgesendeten Paketebekannt sind und eine zuverlässige Fehlerstatistik aufstellen kann.

void PHY_TestSend(

unsigned char* wheaderunsigned char* wdata

);

Parameter:

wheader

Pointer auf die zu sendenden Headerbytes ohne Barkercode, Terminierung und Check-summe. Die Länge der Headerdaten beträgt 5 Bytes. Das erste Byte gibt die Datenlänge und die Punktierung an. Danach folgen jeweils 2 Bytes für die Absender- und Zieladresse. Eine ausführliche Beschreibung des Paketaufbaus findet sich in Kapitel 5.2.

wdata

Pointer auf die zu sendenden Datenbytes ohne Terminierung und Checksumme. Die maxi-male Länge der Sendedaten wird durch die Konstante RECEIVELEN zu Programmbeginn festgelegt.

Rückgabewert:

kein Rückgabewert

Bemerkungen:

Die Hauptaufgabe der Funktion PHY_Send ist es, die übergebenen Daten mit einer Prüf-summe zu versehen und zu encodieren. Nachdem die Information fehlergesichert in ein Paketgepackt wurde, wird sie ausgesendet. Die Funktion PHY_Send wird nebenläufig zur FunktionPHY_Receive ausgeführt. Die Synchronisation des Empfangsthreads mit dem Sendethreadmittels Events wird in Kapitel 5.7 ausführlich behandelt.


106

5.10.18MAC_CarrierStateChange( )

Mit Hilfe dieser Funktion kann der MAC-Layer feststellen, ob derzeit ein Träger detektiertwurde.

bool MAC_CarrierStateChange(

bool carrierstate

);

Parameter:

carrierstate

Dieser Parameter ist Eins, wenn ein Träger detektiert wird und Null wenn kein Träger anliegt.

Rückgabewert:

keiner

Bemerkungen:

Mit dieser Funktion teilt der Physical-Layer dem MAC-Layer aktiv mit, dass ein Träger-wechsel erfolgt. Normalerweise wird MAC_CarrierStateChange() vom MAC-Layerbereitgestellt und ist hier nur zu Demonstrationszwecken als Dummy-Funktion implementiert.


107

5.10.19MAC_Receive( )

Durch den Aufruf dieser Funktion wird das empfangene Paket an den MAC-Layer weiterge-leitet.

void MAC_Receive(

unsigned char* headerunsigned char* data

);

Parameter:

header

Pointer auf die decodierten Header-Daten des empfangenen Paketes. Die Headerlänge beträgt 5 Bytes. Der Header wird ohne Barkersequenz, Terminierung und Prüfsumme übergeben.

data

Pointer auf die decodierten Payload-Daten des empfangenen Paketes. Die Information über die Datenlänge der Payload ergibt sich aus dem ersten Byte der Headerdaten. Die Payload-daten werden ohne Terminierung und Prüfsumme übergeben.

Rückgabewert:

keiner

Bemerkungen:

Mit dieser Funktion übergibt der Physical-Layer dem MAC-Layer das empfangene und deco-dierte Paket. Normalerweise wird MAC_Receive() vom MAC-Layer bereitgestellt und isthier nur zu Demonstrationszwecken als Dummy-Funktion implementiert.

6 AUSBLICK

108

6 AusblickUm einen Ausblick zu geben, wie das Projekt „Chatroom over Powerline“ fortgeführt werdenkann, wird im folgenden Abschnitt eine mögliche Realisierung eines Powerline-Modems vor-gestellt.

6.1 Mögliche Realisierung eines Powerline-Modems

Am Lehrstuhl für Nachrichtentechnik der Universität Kaiserslautern laufen derzeit mehrereArbeiten zu einer OFDM-basierten Kommunikation über die Powerline. Die OFDM-Übertra-gungstechnik wird heutzutage in vielen Broadcastanwendungen wie beispielsweise im digi-talen terrestrischen Hörfunk DAB (Digital Audio Broadcasting) und im digitalen FernsehenDVB-T (Digital Terrestrial Video Broadcasting) verwendet. Auch für Kommunikationsanwen-dungen wie die Nachfolgegeneration UMTS (Universal Mobile Telecommunication System)wird OFDM als Übertragungsverfahren diskutiert. Die Powerline stellt daher nur ein Mediumunter vielen dar, für das ein OFDM-System entwickelt wird. Im Folgenden soll nun einemögliche Realisierung eines OFDM-basierten Powerline-Modems in Anlehnung an For-schungsarbeiten [22] des Instituts für Industrielle Informationstechnik der Universität Karlsru-he vorgestellt werden.

Das OFDM-Verfahren kann beispielsweise mit 256 Unterträgern realisiert werden, welche je-weils mit DQPSK moduliert werden. Bei dieser Modulationsart werden immer zwei Bits zueinem Symbol umgewandelt. Da bei DQPSK die Symbole alle eine gleiche Amplitude be-sitzen, wird die Information in der Phase übertragen. Hierbei zählt jedoch nicht die absolutePhase, sondern die Phasendifferenz zum vorhergehenden Symbol, da es sich um eine differen-zielle Modulationsart handelt. Dies hat den Vorteil, dass Störungen, welche sich auf mehrereaufeinander folgende Symbole auswirken, die Demodulation am Empfänger weniger beein-trächtigen als bei einer absoluten Modulationsart. Die Wahl von DQPSK geschieht auch auf-grund der Tatsache, dass niederwertige Modulationsverfahren sich robuster gegenüber Störein-flüsse verhalten als höherwertige Modulationsverfahren. Im Gegenzug ist die Datenrate jedochbei niederwertigerer Modulation geringer. Es lassen sich Netto-Datenraten bis zu 1 Mbit/sdurch diese Verfahren erreichen.

6 AUSBLICK

109

Vorgeschlagen wird die Entwicklung einer Platine mit einem integriertem DSP und einer USB-Schnittstelle zum Anschluss an einen Personal Computer. Die Platine gliedert sich in dreiHauptteile wie in Abbildung 6.1 zu erkennen ist.

Bild 6.1: Schematischer Aufbau eines OFDM-Powerline-Modems

Hauptplatine

Die Hauptplatine besteht aus einem USB-Mikrocontroller, der die Schnittstelle zum PC bereit-stellt. Neben dem USB-Mikrocontroller befindet sich noch ein DSP auf der Hauptplatine, derzur Kontrolle der AD/DA-Wandler zuständig ist sowie Aufgaben der digitalen Signalverarbei-tung wahrnimmt. Darunter fallen beispielsweise die Codierung und Decodierung des Daten-stromes, das Symbolmapping, die Synchronisation und die Modulation/Demodulation derOFDM-Unterträger durch die FFT bzw. IFFT.

AD-/DA-Platine

Auf der AD-/DA-Platine befindet sich ein FPGA, ein digitaler Empfangsprozessor und AD-/DA-Wandler. Ihre Aufgabe ist es, die komplexen digitalen Signale der Hauptplatine in diezugehörigen reellwertigen analogen Signale und umgekehrt umzuwandeln. Der Empfangs-prozessor wird durch den FPGA kontrolliert und entlastet den DSP in der digitalen Signalver-arbeitung. Der Sende- und Empfangspuffer wird ebenfalls durch den FPGA übernommen. DenTakt für die gesamte Schaltung stellt eine auf der AD-/DA-Platine vorhandene PLL-Schaltungbereit, welche mit dem DSP gesteuert werden kann. Die unterschiedlichen Frequenzen, die fürdie Hardwarekomponenten wie beispielsweise Empfangsprozessor und Abtastrate des Mo-dems auf der Platine benötigt werden, lassen sich mit Hilfe von Frequenzteilern im FPGA ein-stellen.

Analog-Frontend

Die Hauptaufgabe des Analog-Frontends besteht in der Ein- und Auskopplung des Signals inbzw. aus dem Stromnetz. Auf dieser Platine sind ebenfalls zwei analoge Filter zur Bandbegren-zung untergebracht, jeweils eines für Sende- und Empfangsbetrieb. Außerdem findet auf dieserPlatine die Mischung des Sendesignals in das gewünschte Übertragungsband statt. Für die not-wendige Signalleistung auf dem Übertragungsmedium sorgt eine einstellbare Endstufe. Auch

USBMikro-

controllerDSP

FPG

A

Empfangsprozessor

D/A

A/D

Signalkopplung,analoge Filterung,Mischerstufe

Analog-FrontendAD/-D/A-PlatineHauptplatine

PC Powerline

6 AUSBLICK

110

die Pegelanpassung für die Abtastung des empfangenen Signals ist in diesem Abschnitt un-tergebracht.

Zur Entwicklung eines solchen Powerline-Modems empfiehlt sich folgende Aufteilung:

• Entwicklung der einzelnen Hardwareeinheiten des Modems, der Hauptplatine, der AD/DA-Platine, des Analog-Frontends sowie des Netzteils

• Implementierung eines FPGAs und Umsetzung von Algorithmen zur digitalen Signalver-arbeitung

• Programmierung eines USB-Mikrocontrollers für die Anbindung an den Universal SerialBus eines PCs

• Programmierung eines DSPs zur digitalen Signalverarbeitung

• Entwicklung einer windows-basierten Kommunikationsschicht für die Steuerung desOFDM-Modems.

7 QUELLCODE FÜR DEN PHYSICAL-LAYER

111

7 Quellcode für den Physical-Layer

/* * D I P L O M A R B E I T * * * Denis Geiter * * Implementierung des Physical-Layers * (Kanalcodierung & Ansteuerung der seriellen Schnittstelle) * * * im Rahmen des * F‰cher¸bergreifenden Projekts * Powerline Communication * * * Sommersemester 2002 * */

#include "stdafx.h"#include <stdio.h>#include <stdlib.h>#include <time.h>#include <windows.h>#include <iostream.h>#include <sys/timeb.h>#include <math.h>#include <string.h>#include <conio.h> // getche

#define HEADERLEN 8 //L‰nge des Paketheaders in Byte mit CRC und Terminierung, ohne Barkercode(8), uncodiert#define PAYLOADLEN 131//L‰nge der Daten mit CRC16 und Terminierung#define MINPAKETLEN 26//Minimale Paketl‰nge (Barker+Header+Data, codiert, maximale Punktierung) (18Header+8Data)#define MAXPAKETLEN 280//Maximale Paketl‰nge (Barker+Header+Data, codiert)#define RECEIVELEN 4000//L‰nge des Lesepuffers

#define BARKERCODE 0xF9A8//Barkercode zur Rahmensyncronisation: 1111 1001 1010 1(000)#define BARKERDEPTH 40//Anzahl der zu durchsuchenden Bytes ab Anfang

#define TERMINIERUNG 0xFF//Terminierungsbyte f¸r Faltungscode#define CONSTRAINTLEN 7 //Einflu?l‰nge = Anzahl der Register+1#define N 2 //Anzahl der Generatorsequenzen#define STATES 1<<(CONSTRAINTLEN-1)//Anzahl der Zust‰nde

#define ERRORCHECKCOUNT 8//Anzahl der auszusendenden Testpakete#define ERRORCHECKCHAR 0x55//Testbyte mit aus dem die Daten bestehen

//Faltungscode K=7, G(133,171) 1011011, 1111001const int LEN=7; //Einflu?l‰ngeconst unsigned char GEN1=0xB6;//1011 0110 (octal 133)const unsigned char GEN2=0xF2;//1111 0010(octal 171)

struct statetable{ //Trelliszustandsvariablenint uppercode; //Codewort des oberen Pfadesint lowercode; //Codewort des unteren Pfades

};

struct pathtable{ //Trelliszustandsvariablenint prevstate;bool output; //wahrscheinliche Ausgangsfolgedoublepathcost; //Pfadkosten

};

struct stat{int packets_correct;int packets_lost_crc8;int packets_lost_crc16;int packets_lost_barker;int packets_lost_cut;int bit_errors_per_paket;

};

struct statetable state[STATES];


112

struct pathtable pathstate[RECEIVELEN][STATES];struct stat paketstat;

int verbosity=1; //"Geschw‰tzigkeit" der Ausgaben

HANDLE hCom; //Handle der seriellen SchnittstelleHANDLE FUPhThread=0; //Handle f¸r Read-ThreadHANDLE KeyPressThread=0; //Handle f¸r KeyPressBreakHANDLE FUPhandle[2]; //Handle-Array f¸r WaitForMultibleObjects-FunktionHANDLE EventSendRoutineStart;//Event wenn Sende-Routine aufgerufen wirdHANDLE EventSendRoutineEnd;//Event wenn Sende-Routine fertig istHANDLE EventKeyBreak; //Event wenn Tastendruck f¸r AbbruchOVERLAPPED EventCarrierDetect;//Event wenn Carrier Detect OVERLAPPED EventReceive; //Event wenn Lese-Vorgang zu EndeOVERLAPPED EventSend; //Event wenn Schreib-Vorgang zu Ende

//*********************************************************************************************void ErrorHandler(char *message, DWORD error){

//cout << "\nFEHLER -> "<< message << ", Fehlercode: " << error;}//*********************************************************************************************void OpenComPort(int comport){

DCB dcb;char comstring[6];

switch(comport){case 1:

strcpy(comstring,"COM1\0");break;

case 2:strcpy(comstring,"COM2\0");break;

}

hCom=CreateFile(comstring, GENERIC_READ|GENERIC_WRITE, 0, 0, OPEN_EXISTING, FILE_FLAG_OVERLAPPED,0); //*hComif(hCom==INVALID_HANDLE_VALUE)

ErrorHandler("CreateFile: COM-Port-Handler nicht erhalten",GetLastError());if(!GetCommState(hCom, &dcb))

ErrorHandler("GetCommState: COM-Status nicht erhalten",GetLastError());

dcb.BaudRate=2400;dcb.ByteSize=8;

if(!SetCommState(hCom, &dcb))ErrorHandler("SetCommState: Fehler beim ƒndern des COM-Status",GetLastError());

EscapeCommFunction(hCom,CLRRTS);//Setze Modem in Empfangsmodus }//*********************************************************************************************void CloseComPort(){

CloseHandle(hCom);}//*********************************************************************************************//Wartet auf Tastendruck und sendet Abbruchbefehlunsigned long _stdcall KeyPressBreak(void* pData){

char dummy;

dummy=getch();SetEvent(EventKeyBreak);return 0;

}//*********************************************************************************************int Compare(unsigned char* a, unsigned char* b, int length){

int i, j, biterrors=0;

/*printf("\n Compare A");for(i=0;i<length;i++)printf(" %2X",a[i]);printf("\n Compare B");for(i=0;i<length;i++)printf(" %2X",b[i]);

*/

for(i=0;i<length;i++)for(j=0;j<8;j++)

if( (a[i]&(1<<j)) != (b[i]&(1<<j)) )biterrors++;

return biterrors;}//*********************************************************************************************


113

int AddErrors(unsigned char* a, int strlength, double error_rate){int i, j=0, r, biterrors=0;double k;

// printf("\nOriginal:");// for(i=0;i<strlength;i++)printf(" %2X",a[i]);

for(i=0;i<strlength;i++)for(j=0;j<8;j++)

if( rand() <= (32767*error_rate) ){biterrors++;if( (a[i] & (1<<j)) > 0 )a[i]&=~(1<<j);else a[i]|=(1<<j);

}

// printf("\nerrorness:");// for(i=0;i<strlength;i++)printf(" %2X",a[i]);

// printf("\nbiterrors: %i", biterrors);// printf("\ntotalbits: %i", strlength*8);// printf("\nbiterrorrate: %f",((float)biterrors)/strlength/8);

return biterrors;}//*********************************************************************************************int Distance(unsigned char a, unsigned char b, unsigned char puncmask){

//puncmask: z.B. 1111101, wegen Punktierung wird ein Bit nicht ber¸cksichtigt bei der Berechnungint i, dist=0;

a&=puncmask; //Lˆsche Bits, die wegen Punktierung nicht ber¸cksichtigt werdenb&=puncmask;a^=b;for(i=0;i<8;i++)//Z‰hle Einsen

dist+=(a&(1<<i))>0;return dist;

}//*********************************************************************************************bool PHY_IsCarrier(){

DWORD lpModemStat;

GetCommModemStatus(hCom,&lpModemStat);

return lpModemStat&MS_RLSD_ON>0;}//*********************************************************************************************void MAC_CarrierStateChange(bool carierstate){}//Dummy-Funktion//*********************************************************************************************int MAC_Receive(unsigned char* header, unsigned char* data){return 0;}//Dummy-Funktion//*********************************************************************************************void GenerateTrellis(void){

unsigned char shiftreg=0;unsigned char temp;int j, k, isodd;

//Trellis-Codewˆrter ausrechnenfor(j=0;j<STATES;j++){

//Codewˆrter f¸r obere Zweige berechnenstate[j].uppercode=0;shiftreg=0;shiftreg=(char) ((j*2)%(STATES))<<(8-CONSTRAINTLEN);//Leite den Zustand des Registers aus der Zustandszahl abif(j>=(STATES)/2) //f¸r die ersten STATE/2 Zust‰nde 0, sonst 1

shiftreg|=0x80;

isodd=0;temp=shiftreg&GEN1; //Shiftregister AND Generatorpolynom1

for(k=0;k<CONSTRAINTLEN;k++)//Schleife ¸ber die relevanten Bits im Registerisodd^=(temp&(1<<(7-k)))>0;//XOR Bits aus vorheriger AND-Berechnung

if(isodd==1)state[j].uppercode|=0x80;//Falls XOR-Rechnung=1, dann setze 1.Bit in Ausgabedaten

elsestate[j].uppercode&=~0x80;//Falls XOR-Rechnung=0, dann lˆsche 1.Bit in Ausgabedaten

isodd=0;temp=shiftreg&GEN2;for(k=0;k<CONSTRAINTLEN;k++)

isodd^=(temp&(1<<(7-k)))>0;

if(isodd==1)state[j].uppercode|=0x40;//Falls XOR-Rechnung=1, dann setze 2.Bit in Ausgabedaten


114

elsestate[j].uppercode&=~0x40;//Falls XOR-Rechnung=0, dann lˆsche 2.Bit in Ausgabedaten

//printf("\nState:%i, Up:%X",j, state[j].uppercode>>6);

//Codewˆrter f¸r untere Zweige berechnenstate[j].lowercode=0;shiftreg=0;shiftreg=(char) ((j*2+1)%(STATES))<<(8-CONSTRAINTLEN);//Leite den Zustand des Registers aus der Zustandszahl abif(j>=(STATES)/2) //f¸r die ersten STATE/2 Zust‰nde 0, sonst 1

shiftreg|=0x80;

isodd=0;temp=shiftreg&GEN1; //Shiftregister AND Generatorpolynom1for(k=0;k<CONSTRAINTLEN;k++)//Schleife ¸ber die relevanten Bits im Register

isodd^=(temp&(1<<(7-k)))>0;//XOR Bits aus vorheriger AND-Berechnung

if(isodd==1)state[j].lowercode|=0x80;//Falls XOR-Rechnung=1, dann setze 1.Bit in Ausgabedaten

elsestate[j].lowercode&=~0x80;//Falls XOR-Rechnung=0, dann lˆsche 1.Bit in Ausgabedaten

isodd=0;temp=shiftreg&GEN2;for(k=0;k<CONSTRAINTLEN;k++)

isodd^=(temp&(1<<(7-k)))>0;

if(isodd==1)state[j].lowercode|=0x40;//Falls XOR-Rechnung=1, dann setze 2.Bit in Ausgabedaten

elsestate[j].lowercode&=~0x40;//Falls XOR-Rechnung=0, dann lˆsche 2.Bit in Ausgabedaten

//printf("\nState: %i, Low:%X",j, state[j].lowercode>>6);}

}//*********************************************************************************************void Encode(unsigned char* indata, unsigned char* outdata, int length){

//length: L‰nge der Eingangsdaten in Byte

unsigned char shiftreg=0x00;unsigned char temp;int i, j, isodd;

for(i=0;i<length*8;i++){shiftreg>>=1;if(indata[i/8]&(1<<(7-(i%8))))//Schiebe Datenbits von links ins Register nach

shiftreg+=0x80;

isodd=0;temp=shiftreg&GEN1; //Shiftregister AND Generatorpolynom1for(j=0;j<LEN;j++) //Schleife ¸ber die relevanten Bits im Register

isodd^=(temp&(1<<(7-j)))>0;//XOR Bits aus vorheriger AND-Berechnungif(isodd)

outdata[(i*2)/8]|=1<<(7-((i*2)%8));//Falls XOR-Rechnung=1, dann setze Bit in Ausgabedatenelse

outdata[(i*2)/8]&=~(1<<(7-((i*2)%8)));//Falls XOR-Rechnung=0, dann lˆsche Bit in Ausgabedaten

isodd=0;temp=shiftreg&GEN2;for(j=0;j<LEN;j++)

isodd^=(temp&(1<<(7-j)))>0;if(isodd)

outdata[(i*2+1)/8]|=1<<(7-((i*2+1)%8));else

outdata[(i*2+1)/8]&=~(1<<(7-((i*2+1)%8)));//Falls XOR-Rechnung=0, dann lˆsche Bit in Ausgabedaten}

}//*********************************************************************************************int Decode(unsigned char* indata, unsigned char* outdata, int length, int mode){

//lenght: l‰nge der codierten Daten in bytes, mode: Punktierungsrate//liefert Pfadkosten zur¸ckint i, j, bitcounter=0;double dist1, dist2;unsigned char temp, prev;float lenfactor=0;unsigned short puncmask;unsigned char masklen, punctemp;

//printf("\n[Decode] Punktierung: %i, ",mode);

//Auswahl der Punktierungsmaskeswitch(mode){


115

case 1:puncmask=0xE640; //1110011001(000000), Rate:5/6 masklen=10;break;

case 2:puncmask=0xE990; //111010011001(0000), Rate:6/7masklen=12;break;

case 3:puncmask=0xEA64; //11101010011001(00), Rate:7/8, masklen=14;break;

default:puncmask=0xFFFF; //1111111111111111masklen=16;break;

}

//Initialisierungfor(i=0;i<length/2;i++)outdata[i]=0;//Lˆsche Ausgangsdaten-Arraypathstate[0][0].pathcost=0; //Intitialisierung der Pfadkostenfor(i=1;i<(STATES);i++)pathstate[0][i].pathcost=999;

//Hauptschleife Viteri//printf("punctemp=");for(i=0;i<length*8;i+=2){ //Schleife ¸ber die decodierte L‰nge in Bit, Schrittweite 2 wegen Anzahl der Bits pro Codewort

punctemp=( (puncmask<<(i%masklen)) & 0xC000 )>>8;//Selektiere die 2 relevanten Bits aus Punktierungsmaske, konvertiere short in char//punctemp&=0xC0;//printf("\npunctemp %X, i%%masklen %i, (puncmask<<(i%%masklen))& 0xC000 %X",punctemp, i%masklen,(puncmask<<(i%masklen)) );

//Codebitsgewinnung aus Empfangsdaten mit und ohne Punktierungtemp=0;

//printf("\npunctemp= %X",punctemp);for(j=0;j<2;j++){ //Schleife ¸ber die Bits in einem Codewort

if( (punctemp & (1<<(7-j))) > 0){//‹berall wo in der Punktierungsmaske ein Bit gesetzt ist, f¸ge in temp ein Bit aus indata eintemp+= ( (indata[bitcounter/8] & (1<< (7-(bitcounter%8))) )>0 )<<(7-j);

//printf("\n bitcounter %i, indata[bitcounter/8] %X, (1<< (7-(bitcounter%8))) %X, (7-j) %i", bitcounter, indata[bitcounter/8],(1<< (7-(bitcounter%8))), (7-j));

bitcounter++;}

}//printf("\n temp= %X, punctemp= %X",temp, punctemp);//printf("\nDECO3 %i %i", length, i);//Add-Compare-Select-Schleife

for(j=0;j<STATES;j++){dist1=pathstate[i/2][(j*2 )%(STATES)].pathcost + Distance(temp,state[j].uppercode, punctemp);//bestimme Pfadmetrik des oberen Pfadesdist2=pathstate[i/2][(j*2+1)%(STATES)].pathcost + Distance(temp,state[j].lowercode, punctemp);//bestimme Pfadmetrik des unteren Pfades

if(dist1<dist2){pathstate[i/2+1][j].pathcost=dist1;pathstate[i/2+1][j].prevstate=(j*2)%(STATES);

}if(dist1>dist2){

pathstate[i/2+1][j].pathcost=dist2;pathstate[i/2+1][j].prevstate=(j*2+1)%(STATES);

}if(dist1==dist2){

if(rand()&1){pathstate[i/2+1][j].pathcost=dist2;pathstate[i/2+1][j].prevstate=(j*2+1)%(STATES);}

else{pathstate[i/2+1][j].pathcost=dist1;pathstate[i/2+1][j].prevstate=(j*2)%(STATES);}

}pathstate[i/2+1][j].output=(j>=((STATES)/2));

}}

//Ausgabebyte-Rekonstruktionprev=(STATES)-1; //festen Ausgangszustand annehmen, wegen Terminierungfor(i=length*8/2;i>0;i--){

outdata[(i-1)/8]+= pathstate[i][prev].output<<((length*8/2-i)%8);prev=pathstate[i][prev].prevstate;

}

//printf("End-Pfadkosten: %g",pathstate[length*8/2][(STATES)-1].pathcost);// printf("\nin decode:");//for(i=0;i<20;i++)printf(" %2X", outdata[i]);

return (int) pathstate[length*8/2][(STATES)-1].pathcost;}//*********************************************************************************************


116

unsigned char CRC8(unsigned char* indata){

const unsigned char gen=0x07;//Generatorpolynom f¸r CRCunsigned char shiftreg=0xff;int i, bittest;

for(i=0;i<(HEADERLEN-2)*8;i++){//Schleife nur ¸ber Headerdatenbittest=shiftreg&0x80; //Pr¸fe MSB auf 1shiftreg<<=1; //schiebe Bits um 1 nach links

if(indata[i/8]&(1<<(7-(i%8))))//Schiebe Datenbits ins Register nachshiftreg+=1;

if(bittest) //Falls MSB=1, dann XOR mit Generatorpolynomshiftreg^=gen;

}return shiftreg; //CRC zur¸ck

}//*********************************************************************************************//CRC16 arbeitet nach dem Standard CRC-16 der CCITT und verh‰lt sich normgerecht!unsigned short CRC16(unsigned char* indata,int datalen){

const unsigned short gen=0x1021;//Generatorpolynom f¸r CRC, gen=0x1021unsigned short shiftreg=0xffff;int i, bittest;

for(i=0;i<datalen*8;i++){bittest=shiftreg&0x8000; //Pr¸fe MSB auf 1shiftreg<<=1; //schiebe Bits um 1 nach links

if(indata[i/8]&(1<<(7-(i%8))))//Schiebe Datenbits ins Register nachshiftreg+=1;

if(bittest) //Falls MSB=1, dann XOR mit Generatorpolynomshiftreg^=gen;

}return shiftreg; //CRC zur¸ck

}//*********************************************************************************************//Erkennt am Barkercode den Anfang und am TERMINIERUNG das Ende. Gibt Daten ohne Barkercode mit TERMINIERUNG zur¸ckbool FrameSync(unsigned char* data, int datal){

//datal = L‰nge der Bytefolge dataint i,j,k, sum=0, ones=0, maximum=0, byteshift=0, bitshift=0, shiftcounter=0;unsigned short shiftreg=0; //LSB wird nicht beachtetunsigned short tmpreg=0;unsigned char tmpdata[RECEIVELEN];

//Finde Barkersequenzfor(k=0;k<BARKERDEPTH;k++) //¸ber alle zu untersuchenden Bits

for(j=0;j<8;j++){ //¸ber alle Bits im Byteshiftcounter++;shiftreg<<=1;shiftreg+=( (data[k]&(1<<(7-j)))>0 )<<1;//Schiebe Daten ins Registertmpreg=shiftreg^BARKERCODE;for(i=1;i<16;i++)ones+=(tmpreg&(1<<i))>1;//Z‰hle Einsensum=(15-ones)-ones;if(sum>maximum){ //Merke wahrscheinlichste Position der Barkersequenz

maximum=sum;bitshift=(shiftcounter+1)%8;byteshift=(shiftcounter-7)/8;//printf("\nMaximum bei: %X, Maximum: %i", shiftreg, maximum);

}//printf("\nSumme: %i \t ,bitshift: %i, byteshift: %i, maximum: %i, shiftcounter: %i", sum, bitshift, byteshift, maximum, shiftcounter);sum=0;ones=0;

}if(maximum<14){ //Schwelle, ab wann Pakete als nicht erkannt werden

paketstat.packets_lost_barker++;//Erhˆhe PaketLoss-Statistikreturn FALSE; //Fehler: Barkersequenz nicht gefunden

}

//Schneide Datenfolge ausfor(i=0;i<datal;i++)

tmpdata[i]=(unsigned char) (data[i+byteshift+1]<<bitshift) + (data[i+byteshift+2] >>(8-bitshift));i=0;

//printf("\nByteshift: %i, Bitshift: %i",byteshift, bitshift);for(i=0;i<datal;i++)data[i]=tmpdata[i];//Kopiere Daten zur¸ckreturn TRUE;

}//*********************************************************************************************


117

bool Puncture(unsigned char* data,//zu punktierenden Daten int* datalen, //L‰nge der Daten in Byte mit CRC und Terminierung nach Faltungscodierung int mode) //W‰hlt Punktierung aus

{int i, bitpos=0;unsigned short puncmask;unsigned char masklen;

switch(mode){ //Auswahl der Punktierungsmaskecase 1:

puncmask=0xE640;//1110011001(000000), Rate:5/6 (6 von 10 Bit werden ¸bertragen)masklen=10;break;

case 2:puncmask=0xE990;//111010011001(0000), Rate:6/7masklen=12;break;

case 3:puncmask=0xEA64;//11101010011001(00), Rate:7/8masklen=14;break;

default:return FALSE;

}

for(i=0;i<(*datalen * 8);i++)if(( puncmask & (1<<(15-i%masklen)) )>0){//Wird Bit ¸bertragen?

if(data[i/8] & (1<<(7-i%8)) ){data[bitpos/8] |= (1<<(7-bitpos%8));//Setze Datenbit, wenn 1 ¸bertragen werden soll

}else{

data[bitpos/8] &= (~(1<<(7-bitpos%8)));//Lˆsche Datenbit, wenn 0 ¸bertragen werden soll

}bitpos++;

}

*datalen=bitpos/8;if((bitpos%8) != 0) (*datalen)++;return TRUE;

}//*********************************************************************************************bool PHY_Send(unsigned char * wheader, unsigned char * wdata) {

DWORD bytes_written;int i;const stime=80;int wdatalen; //L‰nge der uncodierten Payload in Byte mit CRC16 und Terminierungunsigned short tmpcrc=0; //Hilfsvariable f¸r CRC-Berechnungunsigned char wbuffer[RECEIVELEN];//Gesamter Sendebuffer

if(verbosity>0)printf("\n-----------------------------------------------------------\n");

wdatalen=((wheader[0] & 0x1F)+1)*4;//Bestimme L‰nge der Daten

//if(verbosity>0)printf("\n[wdatalen] %i",wdatalen);/*if(verbosity>0){

printf("\n[soll gesendet werden] ");for(i=0;i<wdatalen;i++)

printf("%c",wdata[i]);printf("<-Ende");

}*/

//Vorbereitungenif(verbosity>0){

for(i=0;i<RECEIVELEN;i++)wbuffer[i]=0;printf("\nCRC Header: \t%X",CRC8(wheader));

}

//Setze Header zusammenwbuffer[0]=(unsigned char) ((BARKERCODE)>>8);//Setze Barkercode an den Anfangwbuffer[1]=(unsigned char) (BARKERCODE);wheader[6]=CRC8(wheader); //Errechne und setze CRC des Headerswheader[7]=TERMINIERUNG; //F¸ge Terminierung an den Header

Encode(wheader, &wbuffer[2],(HEADERLEN));//Codiere den Header

//Setze Payload zusammentmpcrc=CRC16(wdata,wdatalen);


118

if(verbosity>0)printf("\nCRC Daten: \t%X",tmpcrc);wdata[wdatalen]=(unsigned char) (tmpcrc>>8); wdata[wdatalen+1]=(unsigned char) tmpcrc;//F¸ge CRC16 einwdata[wdatalen+2]=TERMINIERUNG;//F¸ge Terminierung an die Daten

//Print Header vor Codierungif(verbosity>0){

printf("\n\n[Paket vor Codierung]\n\nHeader(%i):\t%2X %2X ",(HEADERLEN)+2, (unsigned char)((BARKERCODE)>>8), (unsigned char)(BARKERCODE));

for(i=0;i<(HEADERLEN);i++)printf("%2X ", wheader[i],i);}

//Print Daten vor Codierungif(verbosity>0){

printf("\nDaten(%i):\t",wdatalen+3);for(i=0;i<wdatalen+3;i++){

if((!(i%18))&&(i>20))printf("\n\t\t");printf("%2X ", wdata[i],i);

}}

Encode(wdata,&wbuffer[(HEADERLEN)*2+2],wdatalen+3);//Codiere die Daten

//Print Paket vor Punktierungif(verbosity>1){

printf("\n\n[Vor Punktierung]\n\nHeader(%i):\t",2+(HEADERLEN)*2);for(i=0;i<( 2+(HEADERLEN)*2+ 2*(wdatalen+3) );i++){

if( i==2+((HEADERLEN)*2) ) printf("\nData(%i): \t",2*(wdatalen+3));if((!(i%18))&&(i>20))printf("\n\t\t");printf("%2X ", wbuffer[i],i);

}}

wdatalen=(wdatalen+3)*2; //Neue L‰nge der Daten: (+CRC16, +Terminierung)*FaltungscodierungPuncture(&wbuffer[(HEADERLEN)*2+2],&wdatalen,wheader[0]>>5);//Punktiere die Daten

//Print zu sendendes Paketif(verbosity>0){

printf("\n\n[gesendetes Paket]\n\nHeader(%i): \t",2+(HEADERLEN)*2);for(i=0;i<( 2+(HEADERLEN)*2 + wdatalen );i++){

if( i==2+((HEADERLEN)*2) ) printf("\nData(%i): \t",wdatalen);if((!(i%18))&&(i>20))printf("\n\t\t");printf("%2X ", wbuffer[i],i);

}//printf("\n[wdatalen] \t%i",wdatalen);

}

//Bereite Senden vorSetEvent(EventSendRoutineStart); //Signalisiere Anfang der Send-Routine um Empfang auszusetzenEscapeCommFunction(hCom,SETRTS);//Setze Modem in SendemodusSleep(stime);if(!PurgeComm(hCom,PURGE_TXCLEAR)) ErrorHandler("PurgeComm in TX: error", GetLastError());//Lˆsche Sendebuffer

//Sende DatenWriteFile(hCom,wbuffer, 2 + ((HEADERLEN)*2) + wdatalen, &bytes_written, &EventSend);

if(WaitForSingleObject(EventSend.hEvent, 500)==WAIT_TIMEOUT)ErrorHandler("Wait_TimeOut in WaitForSingleObject nach WriteFile: ",GetLastError());

if(!GetOverlappedResult(hCom, &EventSend, &bytes_written, TRUE))ErrorHandler("GetOverlappedResult: ",GetLastError());

//Nachbereite Sendenif(verbosity>0){

printf("\n\nPaketlaenge: \t%i", bytes_written);printf("\n\n-------------------- PAKET GESENDET -----------------------\n");

}Sleep(stime);EscapeCommFunction(hCom,CLRRTS);//Setze Modem in EmpfangsmodusSetEvent(EventSendRoutineEnd); //Signalisiere Ende der Send-Routine

Sleep(500);return 1;

}//*********************************************************************************************//Liest von COM, Wartet auf Event RLSD, 4 Zeichen M¸ll zu Beginn, am Ende korrekt abgeschnitten, Bufferlˆschenunsigned long _stdcall PHY_Receive(void* pData){

DWORD dwEvtMask;DWORD lpModemStat;DWORD bytes_read;unsigned long dummy;int i, t=0, startpos=0, endpos=0;


119

int rdatalen;unsigned char rheader[RECEIVELEN];unsigned char rdata[RECEIVELEN];unsigned char rbuffer[RECEIVELEN];

//if(verbosity>0)printf("\nEmpfangsbereit im FUPreceive-Thread...\n");

//Initialisiere EventsEventCarrierDetect.hEvent=CreateEvent(NULL, TRUE, FALSE, NULL);//CD-EventEventReceive.hEvent=CreateEvent(NULL, TRUE, FALSE, NULL);//CD-EventEventSend.hEvent=CreateEvent(NULL, TRUE, FALSE, NULL);//Send-EventEventSendRoutineStart=CreateEvent(NULL, TRUE, FALSE, NULL);//EventSendRoutineEnd=CreateEvent(NULL, TRUE, FALSE, NULL);//FUPhandle[0]=EventCarrierDetect.hEvent;FUPhandle[1]=EventSendRoutineStart;

while(1){EscapeCommFunction(hCom,CLRRTS);//Setze Modem in Empfangsbereitschaft

//Warte auf EventsSetCommMask(hCom,EV_RLSD);WaitCommEvent(hCom, &dwEvtMask, &EventCarrierDetect );i=WaitForMultipleObjects(2,FUPhandle, FALSE, INFINITE);//Warte auf CD- oder Send-Event

if(i==1){ //Falls gesendet wird, warte aufs Ende des SendensResetEvent(EventSendRoutineStart);WaitForSingleObject(EventSendRoutineEnd, INFINITE);ResetEvent(EventSendRoutineEnd);continue;

}else{

ResetEvent(EventCarrierDetect.hEvent);GetCommModemStatus(hCom,&lpModemStat);//Frage nochmal CarrierDetect abif(!(lpModemStat & MS_RLSD_ON)) continue;//Falls kein Carrier, Event falsch ausgelˆst, springe zur¸ck

}

//Bereite Empfang vorMAC_CarrierStateChange(1); //Benachrichtigung an MAC-Layer ¸ber CarrierDetectif(verbosity>0)printf("\n\n\n\n----------- PAKET EMPFANGEN -------------\n");if(!PurgeComm(hCom,PURGE_RXCLEAR)) ErrorHandler("PurgeComm: error", GetLastError());//Lˆsche EmpfangsbufferGetCommModemStatus(hCom,&lpModemStat);//Frage nochmal CarrierDetect ab

//Empfangsschleifewhile(lpModemStat & MS_RLSD_ON){//Solange CD-Signal, lese byteweise

ReadFile(hCom, &rbuffer[t], 1, &bytes_read, &EventReceive);if(WaitForSingleObject(EventReceive.hEvent, 500)==WAIT_TIMEOUT)ErrorHandler("Wait_TimeOut in WaitForSingleObject nach

ReadFile: ",GetLastError());;if(!GetOverlappedResult(hCom, &EventReceive, &dummy, TRUE))ErrorHandler("GetOverlappedResult: ",GetLastError());

t++;if(t==RECEIVELEN){

printf("\n‹berlauf des Empfangbuffers!");break; //Empfangsbuffer darf nicht ¸berlaufen

}GetCommModemStatus(hCom,&lpModemStat);//CD-Signal noch vorhanden?

}

//Bereite Empfang nachMAC_CarrierStateChange(0); //Benachrichtigung an MAC-Layer ¸ber CarrierDetectif(t<(MINPAKETLEN)){

paketstat.packets_lost_cut++;printf("\nMindest-Paketl‰nge(%i) unterschritten! (%i Bytes) -> Abbruch",(MINPAKETLEN), t);continue; //Weniger als MINPAKETLEN Zeichen ist kein Paket -> weiter

}

//Print empfangene Bytesif(verbosity>0){

printf("\nByteanzahl:\t%i\n\n[Empfangenes Paket]\n\nPaket:\t\t",t);for(i=0;i<t;i++){

if((!(i%18))&&(i>2))printf("\n\t\t");printf("%2X ",rbuffer[i]);

}}

if(FrameSync(rbuffer, t)!=TRUE){printf("\nBarkercode nicht gefunden! -> Abbruch");t=0;continue; //Finde Paketanfang

}t=0; //Lˆsche L‰nge der empfangenen Bytes


120

//Header-Decodierung:Decode(&rbuffer[0], rheader, (HEADERLEN)*2, 0);

rdatalen=((rheader[0] & 0x1F)+1)*4+3;//if(verbosity>0)printf("\n[rdatalen] %i", rdatalen);

//Print Paket vor Decodierungif(verbosity>0){

printf("\n\n[Vor Decodierung]\n\nHeader(%i):\t",(HEADERLEN)*2);for(i=0;i<((HEADERLEN)*2+rdatalen*2);i++){

if( i==(HEADERLEN)*2 )printf("\nData(%i):\t", rdatalen*2);if((!(i%18))&&(i>20))printf("\n\t\t");printf("%2X ", rbuffer[i],i);

}}

//Print Headerif(verbosity>0){

printf("\n\n[Decodiertes Paket]\n\nHeader:\t\t");for(i=0;i<(HEADERLEN);i++) printf("%2X ", rheader[i]);

}

//Daten-Decodierung:Decode(&rbuffer[(HEADERLEN)*2], rdata, rdatalen*2, rheader[0]>>5);

//CRC8if(CRC8(rheader)==rheader[6]){

if(verbosity>0)printf("\nCRC Header:\tOK");}else{

paketstat.packets_lost_crc8++;printf("\nCRC Header:\tERROR (berechnet: %2X, empfangen: %2X) -> Abbruch", CRC8(rheader), rheader[6]);continue;

}

//Print Daten decodiert HEXif(verbosity>0){

printf("\nDaten:\t\t");for(i=0;i<rdatalen-3;i++){

if((!(i%18))&&(i>2))printf("\n\t\t");printf("%2X ", rdata[i]);

}}

//CRC16if( CRC16(rdata, rdatalen-3) == (((unsigned short) rdata[rdatalen-3]) <<8) + (unsigned short) rdata[rdatalen-2]){

if(verbosity>0)printf("\nCRC Daten:\tOK");}else{

paketstat.packets_lost_crc16++;printf("\nCRC Daten:\tERROR -> Abbruch");continue;

}

//Print Daten decodiert ASCIIif(verbosity>0)printf("\nMessage:\t");else printf("> ");for(i=0;i<rdatalen-3;i++)printf("%c", rdata[i]);if(verbosity>0)printf("\n\nEingabe der Sendezeichenfolge: ");else printf("\n");

MAC_Receive(rheader, rdata);//‹bergabe der decodierten Daten an MAC-Layer}

return 0;}//*********************************************************************************************int KeyboardInput(unsigned char * data, unsigned char * first_header_byte){

//Liefert 1 zur¸ck falls zur¸ck zum Hauptmen¸, sonst Nullchar string[150];int i;

//Einlesen des zu sendenden StringsSleep(100);if(verbosity>0)printf("\nEingabe der Sendezeichenfolge: ");gets(string); //String einlesen

if (string[0]=='q')return 1; //Falls Eingabe von q - Ende

*first_header_byte &= 0xE0; //Lˆsche alte Paketl‰ngeif(strlen(string)>0)


121

*first_header_byte += (strlen(string) -1)/4;//Paketl‰nge bestimmen und im 1. Byte vermerken

for(i=0;i<(RECEIVELEN);i++) //Lˆsche Daten aus vorheriger ‹bertragungdata[i]=' ';

for(i=0;i< (signed) strlen(string);i++)//Eingabestring in Schreibbuffer kopierendata[i]=(unsigned char) string[i];

//Einlesen der Punktierungif(verbosity>0){

printf("\nEingabe der Punktierung [0,1,2,3]: ");gets(string); //String einlesen

}if(verbosity==0) string[0]='0';

*first_header_byte &= 0x1F; //Lˆsche alte Punktierungsangabeswitch(string[0]){

case '1':*first_header_byte |= 0x20;//Punktierung setzenbreak;



}

return 0;}//*********************************************************************************************void PHY_Init(int comport){

unsigned long threadID=0;unsigned char header[RECEIVELEN];unsigned char data[RECEIVELEN];unsigned long ExitCode=0; //Thread Exit Codeint end=0;

//VorbereitungenOpenComPort(comport); //÷ffne Serial-PortGenerateTrellis(); //Bereche Trellissrand( (unsigned)time( NULL ) );//Initialisiere Zufallsprozess mit aktueller Zeit

//Rufe Empfangsthread aufFUPhThread=reinterpret_cast<HANDLE>(CreateThread(0,0,PHY_Receive,0,0,&threadID));GetExitCodeThread(FUPhThread, &ExitCode);

//Sendethreadwhile(end!=1){

end=KeyboardInput(data, &header[0]);//Lese Sendestring von Tastaturif(end==1){

CloseComPort();TerminateThread(FUPhThread, ExitCode);//Abbruchsthread beendenreturn;

}PHY_Send(header, data); //Rufe Senderoutine auf

}TerminateThread(FUPhThread, ExitCode);//Abbruchsthread beendenCloseComPort();

}//*********************************************************************************************void PHY_TestSend(int comport){

unsigned long threadID=0;unsigned char header[RECEIVELEN];unsigned char data[RECEIVELEN];int errormode,puncmode,i,j,packetlen, paketcount;char ;

//VorbereitungenOpenComPort(comport); //÷ffne Serial-Portsrand( (unsigned)time( NULL ) );//Initialisiere Zufallsprozess mit aktueller Zeitheader[0]= 0x00; //Lˆsche L‰ngen- und Punktierungsdatenfor(i=1;i<6;i++)header[i]=(ERRORCHECKCHAR);//Setze Headerbytes

printf("\nError-Check-Modus? [1,2,3,4]: ");//Frage Check-Mode abcin >> errormode;printf("\nPunktierung? [0,1,2,3]: ");//Frage Punktierung abcin >> puncmode;printf("\nPaketanzahl? [0-32000]: ");//Frage Paketanzahl abcin >> paketcount;


122

switch(puncmode){case 1:

header[0] |= 0x20; //Punktierung setzenbreak;

case 2:header[0] |= 0x40; //Punktierung setzenbreak;

case 3:header[0] |= 0x60; //Punktierung setzenbreak;

default:break;

}

//Auswahl des Errorcheckmodesswitch(errormode){

case 1:for(i=0;i<4;i++)data[i] =(ERRORCHECKCHAR);for(i=0;i<(paketcount);i++)PHY_Send(header, data);break;

case 2:header[0] |= 0x0F; //Paketl‰nge auf 64 Bytes setzenfor(i=0;i<64;i++)data[i] =(ERRORCHECKCHAR);for(i=0;i<(paketcount);i++)PHY_Send(header, data);break;

case 3:header[0] |= 0x1F; //Paketl‰nge auf 128 Bytes setzenfor(i=0;i<128;i++)data[i] =(ERRORCHECKCHAR);for(i=0;i<(paketcount);i++)PHY_Send(header, data);break;

default:for(i=0;i<paketcount;i++){

packetlen=(int) ((double) rand())/32767*31;//Bestimme Paketl‰nge durch Zufall (liefert Zahl zw. 0 und 31)header[0] += (char) packetlen;cout << "\nerrror4";for(j=0;j<(packetlen+1)*4;j++)data[j] =(char) (((double) rand())/32767*255);PHY_Send(header, data);//Sleep(100);

}break;

}CloseComPort();

}//*********************************************************************************************void PHY_TestReceive(int comport){

DWORD dwEvtMask;DWORD lpModemStat;DWORD bytes_read;unsigned long ExitCode=0; //Thread Exit Codeunsigned long dummy;unsigned long threadID=0;int i,j, t=0, startpos=0, endpos=0;

int rdatalen, HeaderErrors, DataErrors;unsigned char rheader[RECEIVELEN];unsigned char rdata[RECEIVELEN];unsigned char rbuffer[RECEIVELEN];

int errormode, error_len=0, puncmode,packetlen;float rawbiterrors=0; //Bitfehler eines Paketesfloat innerbiterrors=0; //innere Bitfehler eines Paketesfloat totalrawbiterrors=0;//Bitfehler aller Paketefloat totalinnerbiterrors=0;//innere Bitfehler aller Paketedouble error_rate=0;double inner_error_rate=0;unsigned char cbuffer[RECEIVELEN];//Gesamter Vergleichsbufferunsigned char cheader[RECEIVELEN];unsigned char cdata[RECEIVELEN];unsigned short tmpcrc=0;//Hilfsvariable f¸r CRC-Berechnungint cdatalen; //L‰nge der uncodierten Payload in Byte mit CRC16 und Terminierungint totalpacketlength=0;//Byteanzahl des aktuellen Paketsint totalinnerpacketlength=0;//Byteanzahl der Nutzbytes mit Headerint packetcount=0; //Paketz‰hlerfloat totalsendbytes=0; //Byteanzahl aller gesendeten Bytesfloat totalinnersendbytes=0;//Byteanzahl aller Nutzbytes

paketstat.packets_correct=0;paketstat.packets_lost_barker=0;paketstat.packets_lost_crc16=0;paketstat.packets_lost_crc8=0;


123

paketstat.packets_lost_cut=0;

printf("\nTestbetrieb Empfangsmodus... [Abbruch durch Tastendruck]\n");

//Initialisiere EventsEventCarrierDetect.hEvent=CreateEvent(NULL, TRUE, FALSE, NULL);//CD-EventEventKeyBreak = CreateEvent(NULL, TRUE, FALSE, NULL);//KeyBreak-EventFUPhandle[0]=EventCarrierDetect.hEvent;FUPhandle[1]=EventKeyBreak;

//Abfrage der Test-Parametercheader[0]= 0x00; //Lˆsche L‰ngen- und Punktierungsdatenfor(i=1;i<6;i++)cheader[i]=(ERRORCHECKCHAR);//Setze Headerbytes

printf("\nError-Check-Modus? \n[1] - minimale Paketlaenge\n[2] - mittlere Paketlaenge\n[3] - maximale Paketlaenge\n? ");//Frage Check-Mode abcin >> errormode;printf("\nPunktierung? \n[0] - keine\n[1] - Punktierung: 1110011001\n[2] - Punktierung: 111010011001\n[3] - Punktierung: 11101010011001\n? ");//Frage

Punktierung abcin >> puncmode;printf("\nBitfehler-Rate? [0-1]: ");cin >> error_rate;if(error_rate!=0){

printf("\nBarkersequenz fehlerfrei lassen? \n[0] - nein\n[1] - ja\n? ");cin >> error_len;

}

switch(puncmode){case 1:

cheader[0] |= 0x20; //Punktierung setzenbreak;

case 2:cheader[0] |= 0x40; //Punktierung setzenbreak;

case 3:cheader[0] |= 0x60; //Punktierung setzenbreak;

default:break;

}

//Auswahl des Errorcheckmodesswitch(errormode){

case 1:for(i=0;i<4;i++)cdata[i] =(ERRORCHECKCHAR);switch(puncmode){

case 0:totalpacketlength=32;totalinnerpacketlength=(HEADERLEN)+4+3;break;




default:break;

}break;

case 2:cheader[0] |= 0x0F; //Paketl‰nge auf 64 Bytes setzenfor(i=0;i<64;i++)cdata[i] =(ERRORCHECKCHAR);switch(puncmode){





124


default:break;

}break;

case 3:cheader[0] |= 0x1F; //Paketl‰nge auf 128 Bytes setzenfor(i=0;i<128;i++)cdata[i] =(ERRORCHECKCHAR);switch(puncmode){





default:break;

}break;

default:for(i=0;i<(ERRORCHECKCOUNT);i++){

packetlen=(int) ((double) rand())/32767*31;//Bestimme Paketl‰nge durch Zufall (liefert Zahl zw. 0 und 31)cheader[0] += (char) packetlen;cout << "\nerrror4";for(j=0;j<(packetlen+1)*4;j++)cdata[j] =(char) (((double) rand())/32767*255);//Sleep(100);

}break;

}

//Setze Header zusammencbuffer[0]=(unsigned char) ((BARKERCODE)>>8);//Setze Barkercode an den Anfangcbuffer[1]=(unsigned char) (BARKERCODE);cheader[6]=CRC8(cheader); //Errechne und setze CRC des Headerscheader[7]=TERMINIERUNG; //F¸ge Terminierung an den Header

Encode(cheader, &cbuffer[2],(HEADERLEN));//Codiere den Header

//Setze Payload zusammencdatalen=((cheader[0] & 0x1F)+1)*4;//Bestimme L‰nge der Datentmpcrc=CRC16(cdata,cdatalen);cdata[cdatalen]=(unsigned char) (tmpcrc>>8); cdata[cdatalen+1]=(unsigned char) tmpcrc;//F¸ge CRC16 eincdata[cdatalen+2]=TERMINIERUNG;Encode(cdata,&cbuffer[(HEADERLEN)*2+2],cdatalen+3);//Codiere die Daten

cdatalen=(cdatalen+3)*2; //Neue L‰nge der Daten: (+CRC16, +Terminierung)*FaltungscodierungPuncture(&cbuffer[(HEADERLEN)*2+2],&cdatalen,cheader[0]>>5);//Punktiere die Daten

//Print zu vergleichendes Paketif(verbosity>0){

printf("\n\n[Vergleichspaket]\n\nHeader(%i): \t",2+(HEADERLEN)*2);for(i=0;i<( 2+(HEADERLEN)*2 + cdatalen );i++){

if( i==2+((HEADERLEN)*2) ) printf("\nData(%i): \t",cdatalen);if((!(i%18))&&(i>20))printf("\n\t\t");printf("%2X ", cbuffer[i],i);

}}

//Abbruch per Tastendruck ¸berwachenKeyPressThread=CreateThread(0,0,KeyPressBreak,0,0,&threadID);GetExitCodeThread(KeyPressThread, &ExitCode);

while(1){

packetcount++;EscapeCommFunction(hCom,CLRRTS);//Setze Modem in Empfangsbereitschaft


125

//Warte auf EventsSetCommMask(hCom,EV_RLSD);WaitCommEvent(hCom, &dwEvtMask, &EventCarrierDetect );i=WaitForMultipleObjects(2,FUPhandle, FALSE, INFINITE);//Warte auf CD- oder Send-Event

if(i==1){ //Falls Tastendruck, Abbruch der FunktionResetEvent(EventKeyBreak);TerminateThread(KeyPressThread, ExitCode);//Abbruchsthread beendenbreak;

}else{

ResetEvent(EventCarrierDetect.hEvent);GetCommModemStatus(hCom,&lpModemStat);//Frage nochmal CarrierDetect abif(!(lpModemStat & MS_RLSD_ON)) continue;//Falls kein Carrier, Event falsch ausgelˆst, springe zur¸ck

}

//Bereite Empfang vorprintf("\n\n----------- PAKET EMPFANGEN -------------\n");if(!PurgeComm(hCom,PURGE_RXCLEAR)) ErrorHandler("PurgeComm: error", GetLastError());//Lˆsche EmpfangsbufferGetCommModemStatus(hCom,&lpModemStat);//Frage nochmal CarrierDetect ab

//Empfangsschleifewhile(lpModemStat & MS_RLSD_ON){//Solange CD-Signal, lese byteweise

ReadFile(hCom, &rbuffer[t], 1, &bytes_read, &EventReceive);if(WaitForSingleObject(EventReceive.hEvent, 500)==WAIT_TIMEOUT)ErrorHandler("Wait_TimeOut in WaitForSingleObject nach

ReadFile: ",GetLastError());;if(!GetOverlappedResult(hCom, &EventReceive, &dummy, TRUE))ErrorHandler("GetOverlappedResult: ",GetLastError());

t++;if(t==RECEIVELEN){

printf("\n‹berlauf des Empfangbuffers!");break; //Empfangsbuffer darf nicht ¸berlaufen

}GetCommModemStatus(hCom,&lpModemStat);//CD-Signal noch vorhanden?

}

//Bereite Empfang nachif(t<(MINPAKETLEN)){

paketstat.packets_lost_cut++;printf("\nMindest-Paketl‰nge(%i) unterschritten! (%i Bytes) -> Abbruch",(MINPAKETLEN), t);continue; //Weniger als MINPAKETLEN Zeichen ist kein Paket -> weiter

}

//Printe empfangene Bytesif(verbosity>0){

printf("\n\n[Empfangene Bytes]\n\nBytes(%i): \t",t);for(i=0;i<t;i++){

if((!(i%18))&&(i>2))printf("\n\t\t");printf("%2X ", rbuffer[i],i);

}}

//F¸ge Fehler ein (mit Barkersequenz)if((error_rate!=0) && (error_len==0)) AddErrors(rbuffer, t, error_rate);

//Framesynchronisierungif(FrameSync(rbuffer, t)!=TRUE){

printf("\nBarkercode nicht gefunden! -> Abbruch");t=0;continue; //Finde Paketanfang

}

//F¸ge Fehler ein (ohne Barkersequenz)if((error_rate!=0) && (error_len==1)) AddErrors(rbuffer, t, error_rate);

t=0;

//Printe empfangenes Paket nach AddErrorsif(verbosity>0){

printf("\n\n[Empfangene Paket nach Hinzufuegen von Fehlern]\n\nHeader(%i): \t",2+(HEADERLEN)*2);for(i=0;i<totalpacketlength;i++){

if( i==2+((HEADERLEN)*2) ) printf("\nData(%i): \t",cdatalen);if((!(i%18))&&(i>20))printf("\n\t\t");printf("%2X ", rbuffer[i],i);

}}

//Header-Decodierung:HeaderErrors=Decode(rbuffer, rheader, (HEADERLEN)*2, 0);

//printf("\nrbuffer:"); for(i=0;i<(HEADERLEN)*2;i++)printf(" %2X", rbuffer[i]);

if(CRC8(rheader)==rheader[6])


126

printf("\n[CRC8] okay");else{

paketstat.packets_lost_crc8++;printf("\n[CRC8] nicht okay -> Abbruch");

//printf("\nempfangener CRC %X, berechneter CRC %X", rheader[6], CRC8(rheader));

//Print zu vergleichendes Paket/*if(verbosity>0){

printf("\n\n[CRC8-Vergleich]\n\nHeader(%i): \t",2+(HEADERLEN)*2);for(i=0;i<( 2+(HEADERLEN)*2 + cdatalen );i++){

if( i==2+((HEADERLEN)*2) ) printf("\nData(%i): \t",cdatalen);if((!(i%18))&&(i>20))printf("\n\t\t");printf("%2X ", rbuffer[i],i);

}}

*/ //continue;}

//Daten-Decodierung:rdatalen=((rheader[0] & 0x1F)+1)*4+3;DataErrors=Decode(&rbuffer[(HEADERLEN)*2], rdata, rdatalen*2, rheader[0]>>5);if( CRC16(rdata, rdatalen-3) == (((unsigned short) rdata[rdatalen-3]) <<8) + (unsigned short) rdata[rdatalen-2])

printf("\n[CRC16] okay");else{

paketstat.packets_lost_crc16++;printf("\n[CRC16] nicht okay -> Abbruch");//continue;

}

//Vergleich der inneren Fehlernprintf("\ncheader"); for(i=0;i<(HEADERLEN);i++)printf(" %2X", cheader[i]);printf("\nrheader"); for(i=0;i<(HEADERLEN);i++)printf(" %2X", rheader[i]);printf("\ncdata"); for(i=0;i<totalinnerpacketlength-(HEADERLEN);i++)printf(" %2X", cdata[i]);printf("\nrdata"); for(i=0;i<totalinnerpacketlength-(HEADERLEN);i++)printf(" %2X", rdata[i]);

innerbiterrors=Compare(cheader, rheader,(HEADERLEN));innerbiterrors+=Compare(cdata, rdata, totalinnerpacketlength-(HEADERLEN));totalinnerbiterrors+=innerbiterrors;totalinnersendbytes+=totalinnerpacketlength;

//Z‰hle Raw-Bitfehlerrawbiterrors = Compare(rbuffer, &cbuffer[2], totalpacketlength-2);totalrawbiterrors += rawbiterrors;totalsendbytes += totalpacketlength;paketstat.packets_correct++;

printf("\n\nPaket %i korrekt empfangen! (Pfadkosten: Header: %i, Data: %i)", packetcount, HeaderErrors, DataErrors);

printf("\n\nBitfehler:\t\tAktuell:\tKumuliert:");printf("\nRoh-Bitfehler: \t\t%.f\t\t%.f", rawbiterrors, totalrawbiterrors);printf("\nInnere-Bitfehler: \t%.f\t\t%.f", innerbiterrors, totalinnerbiterrors);printf("\nGesendete Bytes: \t%i\t\t%.f", totalpacketlength, totalsendbytes);printf("\nRoh-Bitfehlerrate: \t%e\t%e", ((float) rawbiterrors)/((float) totalpacketlength)/8, ((float) totalrawbiterrors)/((float) totalsendbytes)/8);printf("\nInnere-Bitfehlerrate: \t%e\t%e", ((float) innerbiterrors)/((float) totalinnerpacketlength) /8, ((float) totalinnerbiterrors)/((float)

totalinnersendbytes)/8);}system("cls");printf("\n--------------------------FEHLER-STATISTIK--------------------\n");printf("\nRoh-Bitfehler: \t\t\t%.f", totalrawbiterrors);printf("\nInnere-Bitfehler: \t\t\t%.f", totalinnerbiterrors);printf("\nGesendete Bytes: \t\t%.f", totalsendbytes);printf("\nNutzbytes:\t\t\t%.f", totalinnersendbytes);printf("\nRoh-Bitfehlerrate: \t\t%e", ((float) totalrawbiterrors)/((float) totalsendbytes)/8);printf("\nInnere-Bitfehlerrate:\t\t%e\n", ((float) totalinnerbiterrors)/((float) totalinnersendbytes)/8);

printf("\n\nFehlerhafte Pakete:\nHeader-CRC:\t\t\t%i",paketstat.packets_lost_crc8);printf("\nDaten-CRC:\t\t\t%i",paketstat.packets_lost_crc16);printf("\nzu kurze Pakete:\t\t%i",paketstat.packets_lost_cut);printf("\nkeine Barkersequenz gefunden:\t%i",paketstat.packets_lost_barker);printf("\nkorrekte Pakete:\t\t%i",paketstat.packets_correct);printf("\n\n--------------------------------------------------------------\n");

TerminateThread(KeyPressThread, ExitCode);//Abbruchsthread beenden}//*********************************************************************************************

////////////////////////////////// Hauptprogramm////////////////////////////////void main(int argc, char* argv[]){


127

char mode;

//GenerateTrellis(); //Berechne Trellis//srand( (unsigned)time( NULL ) );//Initialisiere Zufallsprozess mit aktueller Zeit

system("cls"); //Lˆsche Bildschirmprintf("\n P O W E R L I N E C O M M U N I C A T I O N");printf("\n via AMS-Modem");printf("\n ");printf("\n Physical Layer Implementierung");printf("\n ");printf("\n Diplomarbeit");printf("\n von");printf("\n Denis Geiter");printf("\n (Oktober 2002)");

while(mode!='q'){

printf("\n\n[c] - Chatmodus\n[m] - Monitormodus\n[s] - Testbetrieb Sendemodus\n[e] - Testbetrieb Empfangsmodus\n[q] - Ende\n\nAuswahl?: ");cin >> mode;

//Auswahl des Betriebsmodusswitch(mode){

case 'c':system("cls"); //Lˆsche Bildschirmprintf("C H A T M O D U S\n\n[Return] - Absenden der Message\n[q + Return] - Zurueck zum Hauptmenue\n\n");verbosity=0;PHY_Init(2);system("cls"); //Lˆsche Bildschirmbreak;

case 'm':system("cls"); //Lˆsche Bildschirmverbosity=2;printf("M O N I T O R M O D U S\n\n[Return] - Absenden der Message\n[q + Return] - Zurueck zum Hauptmenue");PHY_Init(2);system("cls"); //Lˆsche Bildschirmbreak;

case 's':system("cls"); //Lˆsche Bildschirmverbosity=1;PHY_TestSend(2);CloseComPort();break;

case 'e':system("cls"); //Lˆsche Bildschirmverbosity=1;OpenComPort(2);PHY_TestReceive(2);CloseComPort();break;

case 'q':system("cls"); //Lˆsche Bildschirmprintf("P R O G R A M M E N D E \n\nBye!\n\n");break;

default:system("cls"); //Lˆsche Bildschirmprintf("C H A T M O D U S\n\n[Return] - Absenden der Message\n[q + Return] - Zurueck zum Hauptmenue\n\n");verbosity=0;PHY_Init(2);system("cls"); //Lˆsche Bildschirmbreak;

}}

}

8 LITERATURVERZEICHNIS

128

8 Literaturverzeichnis

[1] Poly-Trax, www.polytrax.de

[2] Cenelec, www.cenelec.org

[3] J.G. Proakis, “Digital Communications“, McGraw-Hill, 1995

[4] Cogency, www.cogency.com

[5] Inari, www.inari.com

[6] Adaptive Networks, www.adaptivenetworks.com

[7] Itran Communications Ltd., www.itrancomm.com

[8] ITM1-B, “Power Line Modem Product Brief”, ITM1B-DS-010-R1.3

[9] Austria Mikro Systeme, www.austriamicrosystems.com

[10] Echelon, www.echelon.com

[11] EN50065-1, “Signalübertragung auf elektrischen Niederspannungsnetzenim Frequenzbereich 3 bis 148 kHz”, CENELEC, Genf, Juli 1993

[12] J.G. Proakis, "Digital Communications", McGraw-Hill, 1995

[13] K. D. Kammeyer, “Nachrichtenübertragung”, B. G. Teubner Stuttgart, 1992

[14] K. Dostert, “Powerline Kommunikation”, Franzis’ Verlag, 2000

[15] S. Eiffes, “Wireless LAN - Beschreibung und Untersuchung der Übertragungseigenschaften eines Wireless LAN Systems aufbauend auf dem IEEE 802.11 Standard”, Universität Kaiserslautern, Juni 2000

[16] A. J. Viterbi, "Error Bounds for Convolutional Codes and an AsymptoticallyOptimum Decoding Algorithm", IEEE Transactions on Information Theory,April 1967

[17] Microsoft Developer Network (MSDN), www.microsoft.com/msdn

[18] A. Denver, “Serial Communication in Win32”, MSDN, Dezember 1995


129

[19] “Frequenzbereichszuweisungsplanverordnung - FreqBZPV”, Teil B: Nutzungsbestimmungen, www.bmwi.de/Homepage/download/telekommunikation_post/FreqBZPV-TeilB1.pdf

[20] D. Haccoun, G. Bégin, “High-Rate Punctured Convolutional Codes for Viterbi and Sequential Decoding”, IEEE Transactions on Communications,November 1989.

[21] Rupprecht, “Grundlagen der digitalen Signalverarbeitung”, 1975

[22] R. Bräumer, “USB-basierte Kommunikationsschnittstelle für ein OFDM-System zur schnellen Datenübertragung über Stromnetze”, Diplomarbeit am Institut für Industrielle Informationstechnik der Universität Karlsruhe, November 2000

[23] Intellon Corporation, “PowerPacket Primer”, White Paper

[24] D. Wenzel, “Digital Audio Broadcasting”, Elrad, 1996, Heft 2

[25] Heise-Newsticker, “EnBW startet Powerline auf Testmarkt”, 23.3.2001

[26] PolyTrax, “Technische Beschreibung PolyTrax -Verfahren“, Januar 2000

[27] D. Williams, “Turbo Product Code Tutorial“, Mai 2000,grouper.ieee.org/groups/802/16/tutorial/80216t-00_01.pdf

[28] P. Gerdsen, “Kommunikationssysteme 2”, Springer-Verlag, 1994

[29] M. Bossert, “Kanalcodierung”, Teubner-Verlag, 1998

[30] W. Henkel, “Theorie und Verfahren der fehlerkorrigierenden Kanalcodierung”, Universität Kaiserslautern, WS 1997/98

[31] PolyTrax, “Technische Beschreibung des PolyTrax Verfahren”, Januar 2000

[32] Ross N. Williams, „A painless guide to CRC error detection algorithms“,August 1993

[33] B. Friedrichs, „Kanalcodierung - Grundlagen und Anwendungen inmodernen Kommunikationssystemen“, November 1995


130

[34] Embedded Systems Programming, „Computational parameters for popular CRC standards“, www.embedded.com/internet/0001/0001contable1.htm

[35] J. Geluso, „CRC16-CCITT“, August 2001,www.joegeluso.com/software/articles/ccitt.htm

9 GLOSSAR

131

9 GlossarARQ - Automatic Repeat Request. Eine Art der Fehlerkontrolle, bei der Pakete mit fehler-hafeter Prüfsumme erneut angefordert werden.

BPSK - Binary Phase Shift Keying. Modulationsart mit reiner Urzeichenumtastung.

BER - Bit Error Rate - Bitfehlerrate

CENELEC - Commitee Europeenne de Normalisation Electrotechnique. Dieses europäischeKommitee für Normung in der Elektrotechnik fasst die diversen nationalen Normungsgremienzusammen. Es wurde 1973 unter belgischem Recht gegründet und verfolgt keine kom-merziellen Ziele.

COFDM - Coded Orthogonal Frequency Division Multiplexing. Kombination aus FEC undOFDM.

DSP - Digitaler Signalprozessor. DSPs verfügen über einen sehr kleinen Befehlssatz, könnendiesen aber auf einen fortlaufenden Datenstrom in Echtzeit anwenden. Sie werden unter ander-em zur Echtzeit-Manipulation von Audio- und Videodaten eingesetzt.

ETSI - Das European Telecommunications Standards Institute ist eine nicht-kommerzielle Or-ganisation, deren Aufgabe es ist, Telekommunikationsstandards aufzustellen, die dauerhaft ineuropäischen Ländern gelten.

FCC - Federal Communications Commission. Die FCC ist eine unabhängige amerikanischeRegulierungsbehörde, welche direkt dem amerikanischem Kongress unterstellt ist. Sie wurde1934 gegründet, um die nationale Kommunikation via Radio, Fernsehen, Kabel und Satellit zuregulieren. Ihre Regeln gelten in den 50 Bundesstaaten der USA, im Distrikt Columbia und inden U.S. Besitztümern.

FEC - Forward Error Correction. Fehlerkorrektur. Bei FEC werden im Gegensatz zu ARQkeine Pakete wiederholt. Die Anzahl korrigierbarer Fehler hängt von der Redundanz der ge-sendeten Information ab. Die FEC-Coderate ist gleich der Anzahl der Informations-Symbolevor der Encodierung geteilt durch die Anzahl der Kanal-Symbole nach der Encodierung.

HomePlug - Spezifikation der HomePlug Powerline Alliance, einer Gruppe von Firmen derNetzwerkbranche, für Powerline-Produkte.

MAC - Media Access Control. Zugriffssteuerung auf das Medium. Teil von OSI-Layer 2. DieMAC-Adresse (Quell- und Zieladresse) bei Ethernet nach IEEE 802 ist eine 48 Bit lange welt-weit eindeutige Netzwerkkartenadresse.

9 GLOSSAR

132

Mbit/s - Megabits per second. Maß für Datenübertragungsrate.

OFDM - Orthogonal Frequency Division Multiplex. Bei der orthogonalen Frequenzmultiplex-Technik handelt es sich um ein Verfahren, das mehrere Trägerfrequenzen für die Übertragungeines Digitalsignals benutzt. Diese Trägerfrequenzen werden allerdings nur mit einer ver-ringerten Übertragungsrate moduliert. Zu diesem Zweck wird bei OFDM das zur Verfügungstehende Frequenzband in mehrere Trägerbänder unterteilt.

PHY - Physical Layer. Die unterste Ebene im ISO-sieben-Ebenen-Modell. Es beinhaltet auchdie elektrischen und mechanischen Verbindungen. Beispiele eines Physical Layers sindCSMA-CD und Token-Ring.

PLC - Powerline Communications. Sammelbegriff für Techniken zur Datenübertragung viaStromversorgungsnetz.

PNC - Powerline Network Connection

PNR - Powerline Network Repeater

PNT - Powerline Network Termination

PNU - Powerline Network Unit

QAM - Quadrature Amplitude Modulation. Modulationsverfahren, das mehrere Bit mit einemSymbol übertragen kann. Bei n-QAM werden Phase und Amplitude verändert, sodass nZustände möglich sind.

QoS - Quality of Service - Bei Kommunikationsdiensten und -netzen bezeichnet es die re-levanten Güteparameter des betreffenden Dienstes oder Netzes.

QPSK - Quadrature Phase Shift Keying - Modulationsverfahren mit Sinus- und Cosinus-trägern. Enspricht 4-QAM.

Diplomarbeit - Lehrstuhl für...

Documents

Transcript of Diplomarbeit - Lehrstuhl für...