Datenübertragung

Überblick: Das Liefernetz von Food Now!

Worum es geht: Alle Stationen von Food Now! teilen sich einen gestörten Funkkanal → In sechs Kapiteln vereinbaren Sie gemeinsame Regeln und bauen eine Station, auf der alle Abteilungen aufbauen.

Leitfrage der Einheit

Wie können sich Zentrale, Kurierinnen und Kuriere, Kasse und Kundschaft über einen gemeinsamen, gestörten Funkkanal eindeutig und zuverlässig verständigen – und wer legt die Regeln dafür fest?

„Food Now!“ kennen Sie aus der objektorientierten Modellierung. Der Lieferdienst bekommt jetzt ein eigenes Liefernetz: Alle Stationen funken auf derselben Frequenz. In der Online-IDE ist diese Frequenz eine WebSocket-Sitzung – jede Nachricht einer Station kommt bei allen anderen Stationen der Sitzung an. Damit das funktioniert, braucht das Netz ein Protokoll.

Tabelle 0.1: Der gemeinsame Kern
KapitelProblem im LiefernetzErgebnis
1 FunkchaosAlle funken frei, Bestellungen gehen unterAnforderungen, eigenes Paketformat
2 Das PaketJede Gruppe spricht einen anderen „Dialekt“Standard FN/1, Klasse Paket
3 FunkenDas Programm hört nicht zu – und dann hört es allesereignisgesteuerte Station mit Adressfilter
4 Rauschen auf der Leitung„Hasestraße 72“ statt „12“Prüfsumme, NAK; Hamming als Alternative
5 Verloren und doppeltBestellung weg – oder doppelt geliefertACK, Timeout, Seq, Stop-and-Wait
6 Die Großbestellung137 Zeichen passen in kein PaketFragmentierung

Nach jedem Kapitel gibt es einen Checkpoint: eine lauffähige Datei mit dem Stand am Kapitelende. Wer hängt, lädt sie und arbeitet weiter. Danach arbeiten Sie in Abteilungen; alle bauen auf der Station aus diesem Kern auf.


Kapitel 1: Funkchaos

Worum es geht: Alle funken frei durcheinander → Sie leiten ab, was ein Protokoll regeln muss, und entwerfen ein eigenes Format.

Einstieg: Die erste Schicht im Liefernetz

Störung im Liefernetz (Plenum)

Freitag, 17 Uhr: Die erste Schicht im neuen Liefernetz beginnt. Jede Station hat ein Funkgerät, Regeln gibt es keine. „Das klappt schon“, meint Praktikant Till.

  1. Sie erhalten eine Rollenkarte und ein Rufzeichen mit genau sechs Zeichen (kürzere werden mit _ aufgefüllt, z. B. KUR10_). Geben Sie in der Online-IDE als Namen nur Ihr Rufzeichen ein.
  2. Starten Sie im Workspace Funkchaos.java und melden Sie sich mit dem Sitzungscode an, den die Lehrkraft nennt.
  3. Funkdisziplin: Funken Sie nur, was zu Ihrer Rolle gehört – keine Namen, keine privaten Nachrichten. Die Zentrale (Lehrkraft, CHAOS1) streut zusätzlich automatisch Funksprüche ein.
  4. Nach der Schicht wertet der Kurs aus: Welche Bestellung wurde von wem geliefert und bezahlt?
Tabelle 1.1: Rollenkarten
RolleRufzeichenAuftrag in der Schicht
KundschaftKUNDE1 … KUNDE4zwei Gerichte mit Adresse bestellen, nach der Lieferung bezahlen, nach vier Minuten ohne Lieferung beschweren
Kurier/inKURIR1 … KUR10_Aufträge übernehmen, Position und Auslieferung melden
KasseKASSE1jede Zahlung der richtigen Bestellung zuordnen
ZentraleCHAOS1Bestellungen annehmen und verteilen
Funkchaos.java ansehen (für die Aufgabe nicht nötig)
String session = Input.readString("Session-Code:", "FN-Q1-CHAOS");
String ruf = Input.readString("Rufzeichen:", "CHAOS1");
Chaosfunk funk = new Chaosfunk();
funk.open(session, ruf);
// ... die Lehrkraft (CHAOS1) sendet automatisch, alle anderen tippen:
while (true) {
   String t = Input.readString("Funkspruch:");
   funk.sendToAll(t, "TXT");
}

class Chaosfunk extends WebSocket {
   // wird automatisch aufgerufen, wenn ein Funkspruch eintrifft
   public void onMessage(WebSocketClient sender, String message,
                         String messageType) {
      println(sender.getNickname() + ": " + message, Color.yellow);
   }
}
Listing 1.1: Funk ohne Regeln (Auszug)

Das Rufzeichen vor einer Nachricht kommt von der Online-IDE (Nickname der Verbindung), nicht aus dem Funkspruch. Ein echter Funkempfänger kennt es nicht.

Leitfrage: Welche Bestellungen wurden sicher ausgeliefert und bezahlt – und warum wissen Sie es bei den anderen nicht?

Unser Plan

Sammeln Sie Ihre „Ich wusste nicht, …“-Sätze an der Tafel in drei Spalten: Problem → Idee → offene Frage. Legen Sie dann höchstens vier Arbeitsschritte fest.

  • Was weiß der Absender nicht, nachdem er gesendet hat?
  • Würde ein Programm diese Funksprüche verstehen? Was bräuchte es?

Nr.Plan-PunktAufgabe
1Einen Mitschnitt systematisch auf Unklarheiten untersuchen1.1 a
2Aus jeder Unklarheit eine Anforderung an Funksprüche ableiten1.1 b
3Ein Format entwerfen, das ein Programm eindeutig zerlegen kann1.2 a, b
4Prüfen, ob andere das Format ohne Rückfrage lesen können1.2 c

Aufgaben: Funkchaos auswerten

Werten Sie einen Mitschnitt der ersten Schicht aus und formulieren Sie Anforderungen an ein Protokoll.

Ihr Bearbeitungsfortschritt:0%
Aufgabe 1.1 (Partnerarbeit): Der Funkmitschnitt

Ein Funkempfänger hat 30 Sekunden der Schicht mitgeschnitten. Wer gesendet hat, steht nicht darin.

[17:02:11] Pizza Salami 2x Hasestr 12
[17:02:12] wer faehrt?
[17:02:14] ich
[17:02:15] ich auch
[17:02:19] Pasta Pesto Lotter Str. 5, bitte schnell
[17:02:20] OK
[17:02:22] Bestellung bezahlt 23,80
[17:02:25] wo bist du?
[17:02:26] Neumarkt
[17:02:27] Pizza Salami 2x Hasestr 12
[17:02:30] Schulfest GSG: 12x Margherita, 8x Salami, 5x To
[17:02:31] Hasestr 72 ist falsch, meinte 12
[17:02:33] ok bin unterwegs zur 72
Mitschnitt 1.1: Freitag, 17:02 Uhr

Markieren Sie alle Stellen, an denen ein Mensch oder ein Programm nicht sicher weiß, was gemeint oder zu tun ist. Notieren Sie zu jeder Stelle die offene Frage („Wer ist mit ‚ich‘ gemeint?“).

Hilfe 1: Lesen Sie den Mitschnitt aus Sicht der Kasse: Welche Bestellung wurde um 17:02:22 bezahlt?
Hilfe 2: Prüfen Sie jede Zeile mit diesen Fragen: Wer sendet? An wen? Worauf bezieht sich die Antwort? Neu oder Wiederholung? Vollständig? Richtig angekommen?
Hilfe 3: Es gibt mindestens sieben Stellen: 17:02:14/15, :20, :22, :25/26, :27, :30, :31/33.

Vor dem Vergleich: Welche Stelle haben Sie übersehen – und mit welcher Frage aus Hilfe 2 hätten Sie sie gefunden?

Musterlösung
Zeitoffene Frage
:14/:15Wer ist „ich“? Fahren jetzt zwei Kuriere?
:20Wer bestätigt was mit „OK“?
:22Welche Bestellung, wer zahlt? Alle hören den Betrag.
:25/:26Wer fragt wen, wer antwortet?
:27Neue Bestellung oder Wiederholung? Doppelte Lieferung droht.
:30Abgeschnitten – niemand merkt, dass etwas fehlt.
:31/:33Die Adresse kam verfälscht an, die Korrektur wurde wieder falsch verstanden.

Formulieren Sie mindestens sechs Anforderungen der Form „Jeder Funkspruch muss … enthalten, damit …“ oder „Es muss vereinbart sein, dass …, damit …“.

Hilfe 1: Jede offene Frage aus Teil a) wird zu einer Angabe im Funkspruch. Welche Angabe beantwortet „Wer hat gesendet?“
Hilfe 2: Trennen Sie Angaben über die Nachricht (wer, an wen, welche Art, welche Nummer, wie lang) von der Nachricht selbst (der Bestellung).
Hilfe 3: Ergänzen Sie: „Jeder Funkspruch muss den ____ enthalten, damit der Empfänger antworten kann.“ – „… eine laufende ____, damit Antworten zugeordnet und ____ erkannt werden.“ – „Es muss vereinbart sein, dass der Empfänger ____, damit der Sender weiß, dass …“

Vor dem Vergleich: Ordnen Sie jede Ihrer Anforderungen einer Zeile aus Teil a) zu. Bleibt eine Zeile ohne Anforderung?

Musterlösung
ProblemAnforderung
Ist das für mich?Empfänger angeben, Rundruf an alle möglich
Wem antworte ich?Absender angeben
Bestellung, Antwort, Zahlung?Art (Typ) angeben
„OK“ ohne Bezug, Doppeltelaufende Nummer; Antworten nennen die Nummer
abgeschnittenLänge bzw. „Teil x von y“ angeben
Tippfehler/VerfälschungKontrollwert mitschicken
Angekommen?Bestätigung vereinbaren, sonst erneut senden
Programm kann Freitext nicht zerlegenfestes, maschinenlesbares Format mit Kennung
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Sie haben aus dem Chaos Anforderungen an ein Protokoll abgeleitet.

Aufgaben: Ein eigenes Paketformat entwerfen

Ihre Gruppe (3–4 Personen) entwirft ein Format, das ein Programm eindeutig zerlegen kann. Jede Gruppe zieht eine Bedingungskarte.

Ihr Bearbeitungsfortschritt:0%
Aufgabe 1.2 (Gruppenarbeit): Unser Funkspruch-Format

Material: Bedingungskarte (Tabelle 1.2), Anforderungsliste aus Aufgabe 1.1 b, leere Funkzettel.

Tabelle 1.2: Bedingungskarten
KarteNameEntwurfsbedingung (zusätzlich zur Anforderungsliste)
AKurzfunkEin Funkzettel fasst insgesamt höchstens 24 Zeichen.
BAlles erlaubtDie Nachricht darf jedes Zeichen enthalten, auch Ihr Trennzeichen.
CRundrufDie Zentrale funkt an alle, Kuriere immer nur an eine Station.
DGroßbestellungBestellungen bis 150 Zeichen, ein Funkzettel fasst 50 Zeichen.
ERauschenJedes einzelne verfälschte Zeichen muss auffallen.
FViele SortenMindestens fünf Arten von Nachrichten müssen unterscheidbar sein.
GEilt!Eilbestellungen müssen sofort erkennbar sein.

Legen Sie fest, welche Angaben jeder Funkspruch enthält und in welcher Reihenfolge. Entscheiden Sie, woran ein Programm erkennt, wo eine Angabe endet. Begründen Sie mit Ihrer Bedingungskarte.

Hilfe 1: Wie haben Sie in der Codierungstheorie erreicht, dass eine Bitfolge eindeutig decodierbar ist?
Hilfe 2: Drei Wege: feste Länge (Nummer immer dreistellig 007), Trennzeichen (# zwischen den Angaben), Präfixfreiheit. Prüfen Sie für Ihre Karte: Was kostet jede Angabe an Platz? Was passiert, wenn das Trennzeichen in der Bestellung vorkommt?
Hilfe 3: Analysieren Sie diesen Entwurf: ZE>K3#B#012#1/1#2x Pizza Salami, Hasestr. 12#Prüfwert. Welche Anforderungen erfüllt er, welche nicht, und wo scheitert er an Ihrer Karte?

Vor dem Vergleich: Formulieren Sie in einem Satz, welche Abwägung Ihr Entwurf trifft (z. B. „kurz, aber …“).

Musterlösung
Kartetypische Entscheidung
Afeste, sehr kurze Felder (Z3B07…), wenig Platz für die Nachricht
BNachricht ans Ende, Längenangabe davor – dann muss nichts verboten werden
CEmpfänger-Feld mit festem Wert für „an alle“
DFelder „Teil“ und „Gesamt“
EKontrollwert, z. B. Summe der ASCII-Werte
F, GTypfeld mit festen Abkürzungen, ggf. Prioritätsfeld

Entwürfe sind verschieden; entscheidend sind Vollständigkeit und Begründung.

Beschreiben Sie Ihr Format als Tabelle Feld | Position bzw. Trennung | Länge | Bedeutung | Beispiel. Schreiben Sie drei Funksprüche aus dem Mitschnitt in Ihrem Format: die Salami-Bestellung an KURIR1, die Bestätigung von KURIR1 und die Position Neumarkt von KURIR2.

Hilfe 1: Die Tabelle muss so genau sein, dass eine fremde Person nur mit ihr jeden Funkspruch zerlegen kann.
Hilfe 2: Legen Sie fest: Zahlen mit führenden Nullen? Welches Trennzeichen genau? Wie wird „an alle“ geschrieben?
Musterlösung
Tabelle 1.3: Beispiel eines Entwurfs mit festen Breiten
FeldPositionLängeBedeutung
Absender0–56Rufzeichen, z. B. ZENTRA
Empfänger6–116Rufzeichen oder ALLE__
Art121B Bestellung, Q Quittung, P Position
Nummer13–153laufend, führende Nullen
Länge16–172Zeichen der Nachricht
Nachrichtab 18LängeText
ZENTRAKURIR1B012282x Pizza Salami, Hasestr. 12
KURIR1ZENTRAQ01200
KURIR2ZENTRAP03108Neumarkt

Zwei Personen schreiben drei neue Funksprüche nach Ihrer Tabelle, die anderen zerlegen sie ohne Rückfrage. Notieren Sie jede Stelle, an der jemand raten musste, und verbessern Sie die Tabelle zu Version 0.2.

Hilfe 1: Testen Sie Grenzfälle: leere Nachricht, Nachricht mit Ihrem Trennzeichen, sehr lange Nachricht, Adresse mit Ziffern.
Musterlösung

Typische Unklarheiten: Nummer ein- oder dreistellig? Gehört das Leerzeichen zum Feld? Wie heißt „an alle“? Wo endet die Nachricht, wenn sie das Trennzeichen enthält? Jede Unklarheit wird eine Regel in Version 0.2.

Erfüllen Sie zusätzlich die Bedingungen der Karten A und D: Wie viele Funkzettel braucht eine Bestellung mit 150 Zeichen in Ihrem Format? Welche Felder müssen Sie dafür kürzen?

Musterlösung

Beispiel: Absender und Empfänger je 2 Zeichen, Art 1, Nummer 2, Teil 1, Gesamt 1 → 9 Zeichen Kopf, 15 Zeichen Nachricht je Zettel → 150 / 15 = 10 Zettel. Teil und Gesamt müssen dann zweistellig sein (10) – der Kopf wächst auf 11 Zeichen, es bleiben 13 Zeichen, also 150 / 13 → 12 Zettel. Kurze Zettel kosten viel Verwaltung.

Ausgezeichnet – Alle Aufgaben abgeschlossen!

Ihr eigener Entwurf steht.

Sicherung

Definition: Protokoll

Ein Protokoll ist eine Vereinbarung zwischen Kommunikationspartnern. Es legt fest, in welchem Format Nachrichten übertragen werden und wie sich Sender und Empfänger verhalten (z. B. bestätigen, wiederholen, verwerfen).

Merke

Alle Stationen teilen sich einen Kanal. Damit ein Programm Funksprüche verarbeiten kann, braucht jeder Funkspruch neben der Nachricht Verwaltungsangaben.

Tabelle 1.4: Funktionen eines Kommunikationsprotokolls (aus der Codierungstheorie)
Funktionim Liefernetzkommt in
Codierungfestes Format, Kennung, LängeKap. 2
AdressierungAbsender, EmpfängerKap. 2, 3
FehlererkennungKontrollwert, Nummer, BestätigungKap. 4, 5
PriorisierungEilbestellungenAbteilung Zentrale
Verschlüsselung, AuthentifizierungZahlungen, echte AbsenderAbteilung Kasse
Plan-Check

Lesen Sie Ihre „Ich wusste nicht, …“-Sätze aus dem Einstieg. Welche davon beantwortet Ihr Format (Version 0.2)? Welcher bleibt offen?

Rückbezug: Die erste Schicht im Liefernetz

Mit Absender, Empfänger, Nummer und Bestätigung wäre klar gewesen, welcher Kurier welche Bestellung fährt. Die zweite Salami-Bestellung (17:02:27) wäre als Wiederholung erkennbar gewesen, die abgeschnittene Schulfest-Bestellung an der Länge. Offen bleibt in vielen Entwürfen: Was tut der Sender, wenn keine Bestätigung kommt?

Checkpoint

Kein Programm-Stand. Bewahren Sie Ihre Formattabelle (Version 0.2) und die drei Funkzettel auf – Sie brauchen sie im Einstieg von Kapitel 2.


Kapitel 2: Das Paket

Worum es geht: Sechs Gruppen, sechs Formate → ein gemeinsamer Standard FN/1 und eine Klasse Paket, die ihn umsetzt.

Einstieg: Sechs Gruppen, sechs Dialekte

Störung im Liefernetz (Gruppen, dann Plenum)

Ab Montag funkt die Zentrale mit allen Kurierinnen und Kurieren. Geben Sie Ihre drei Funkzettel aus Aufgabe 1.2 b ohne Formattabelle an die nächste Gruppe. Zerlegen Sie die Zettel, die Sie bekommen: Wer sendet an wen, welche Art, welche Nachricht? Erst nach zwei Minuten gibt es die Formattabelle dazu.

Leitfrage: Die Zentrale ist ein Programm. Wie viele Zerlege-Methoden bräuchte sie, wenn jede Station ein eigenes Format benutzt – und was folgt daraus?

Nebenfragen:

  1. Welcher Entwurf war ohne Tabelle am leichtesten zu zerlegen? Warum?

Unser Plan
  • Welche Entscheidung muss Food Now! treffen?
  • Ein Paket ist für ein Programm nur ein Text. Was muss das Programm damit tun, bevor es sendet, und nachdem es empfangen hat?

Nr.Plan-PunktAufgabe
1Ein gemeinsamer Standard für alle: FN/1Infobox unten
2FN/1 lesen und schreiben, mit dem eigenen Entwurf vergleichen2.1
3Klasse Paket: Funktext bauen (toString) und zerlegen (parse)2.2 a–c
4Ohne Netz testen: bauen → zerlegen → bauen ergibt denselben Text2.2 d
Infobox: Das Paketformat FN/1

Jedes Paket ist ein Text aus Feldern mit fester Breite. Zahlen stehen mit führenden Nullen. Gesendet wird mit dem messageType "FN1". Was in den Nutzdaten steht, legen später die Abteilungen fest.

Tabelle 2.1: Paketformat FN/1 (Kopf 28 Zeichen, Gesamtlänge 28 + L + 3)
FeldPos.LängeInhalt
Kennung0–23immer FN1
Absender3–86Rufzeichen, z. B. ZENTRA, KURIR1, KASSE1
Empfänger9–146Rufzeichen oder ALLE__ (an alle)
Typ15–173BST Bestellung
ACK Quittung
NAK negative Quittung
POS Position
KRT Karte
ZAH Zahlung
KEY Schlüssel
STA Status
Seq18–203laufende Nummer 000–999, nach 999 folgt 000
Teil21–222Nummer des Teilpakets 01 …
Gesamt23–242Anzahl der Teilpakete 01 …
Länge25–273Zeichen der Nutzdaten 000–060
Nutzdatenab 28Lhöchstens 60 Zeichen, nur ASCII 32–126 (keine Umlaute)
Prüfsummeletzte 33Summe der ASCII-Werte aller Zeichen davor mod 1000

Die Felder 0–27 bilden den Kopf, danach folgen die Nutzdaten und die Prüfsumme. Die laufende Nummer heißt Seq.

Aufgaben: FN/1 lesen und mit dem eigenen Entwurf vergleichen

Arbeiten Sie mit Tabelle 2.1 und Ihrer Formattabelle aus Kapitel 1.

Ihr Bearbeitungsfortschritt:0%
Aufgabe 2.1 (Partnerarbeit): Pakete von Hand

Ein Mitschnitt im Format FN/1:

(1) FN1ZENTRAKURIR1BST0070101015Pizza Salami x2198
(2) FN1KURIR1ZENTRAACK0070101000807
(3) FN1ZENTRAALLE__STA0130101020Schichtbeginn 17 Uhr669
(4) FN1KURIR2ZENTRAPOS0310101008Neumarkt687
(5) FN1KASSE1ZENTRAZAH0040101027Bestellung 12 bezahlt 23.80048

Zerlegen Sie die Pakete (2) bis (5) in ihre Felder. Beschreiben Sie in einem Satz, was in jedem Paket passiert.

Hilfe 1: Paket (1) ist im Paketstreifen unter Tabelle 2.1 schon zerlegt. Zählen Sie ab Position 0.
Hilfe 2: Schneiden Sie zuerst den Kopf ab (28 Zeichen) und die letzten drei Zeichen (Prüfsumme). Was dazwischen bleibt, sind die Nutzdaten – das Längenfeld sagt, wie viele es sein müssen.

Vor dem Vergleich: Prüfen Sie bei jedem Paket: Stimmt die Zahl im Längenfeld mit der Zahl Ihrer Nutzdatenzeichen überein?

Musterlösung

(1) Die Zentrale schickt Bestellung 7 an Kurier 1. (2) Kurier 1 bestätigt Paket 7. (3) Die Zentrale meldet allen den Schichtbeginn. (4) Kurier 2 meldet seine Position. (5) Die Kasse meldet eine Zahlung – lesbar für alle.

Schreiben Sie als FN/1-Pakete; für die Prüfsumme schreiben Sie ??? (sie folgt in Kapitel 4):

  1. Die Zentrale schickt Kurier 2 die Bestellung 1x Pasta Pesto, Lotter Str. 5 mit Seq 14.
  2. Kurier 2 bestätigt dieses Paket.
Hilfe 1: Wie viele Stellen hat das Feld Seq? Wie schreiben Sie dann die 14?
Hilfe 2: Zählen Sie die Nutzdaten genau, auch Leerzeichen und Satzzeichen. Eine Quittung hat keine Nutzdaten und trägt die Seq des bestätigten Pakets.
Musterlösung

Die Prüfsummen wären 290 und 806.

Vergleichen Sie FN/1 mit Ihrem Entwurf nach den Kriterien eindeutig zerlegbar, vollständig, Nutzanteil (Nachrichtenzeichen ÷ alle Zeichen), erweiterbar, für Menschen lesbar. Notieren Sie je einen Vorteil von FN/1 und von Ihrem Entwurf. Erfüllt FN/1 Ihre Bedingungskarte?

Hilfe 1: Wie groß ist der Nutzanteil von Paket (1)? Und von Ihrer Salami-Bestellung?
Hilfe 2: Prüfen Sie die Grenzen: Rufzeichen mit sieben Zeichen? 1000 Pakete? Bestellung mit 61 Zeichen? Ein # in der Bestellung?
Hilfe 3: Füllen Sie eine Tabelle mit den Spalten Kriterium | FN/1 | unser Entwurf; schreiben Sie in jede Zelle ein Stichwort.

Vor dem Vergleich: Markieren Sie die Zeile, in der Ihr Entwurf besser ist als FN/1.

Musterlösung
KriteriumFN/1typischer Trennzeichen-Entwurf
zerlegbarjede Position bekannt; Längenfeld erlaubt jedes Zeichen in den Nutzdatennur, wenn das Trennzeichen in der Nachricht verboten ist
vollständigKennung, Adressen, Typ, Seq, Teil/Gesamt, Länge, Prüfsummeoft ohne Kennung, Länge oder Kontrollwert
Nutzanteil31 Verwaltungszeichen; Paket (1): 15/46 ≈ 33 %meist höher
erweiterbarharte Grenzen (6, 999, 60); neue Version über Kennung FN2Felder beliebig lang
lesbarmühsamgut

Karte A (24 Zeichen) erfüllt FN/1 nicht, schon der Kopf hat 28 Zeichen. B: durch das Längenfeld. D: durch Teil/Gesamt. E: durch die Prüfsumme. F: durch das Typfeld.

Ausgezeichnet – Alle Aufgaben abgeschlossen!

Sie können FN/1-Pakete lesen und schreiben.

Aufgaben: Die Klasse Paket

Sie programmieren die Klasse Paket und testen sie ohne Netz.

Ihr Bearbeitungsfortschritt:0%

Material: Workspace „FN-Kern“ mit Paket.java (Gerüst) und PaketTest.java. Starten Sie PaketTest.java nach jedem Teil: ✓ = klappt, ✗ = offen. Die Tests zu TODO 3 und 5 bleiben bis Kapitel 4 ✗. Pair Programming: Wechseln Sie alle 15 Minuten.

Gerüst Paket.java anzeigen (Auszug)
class Paket {

   private String kennung;
   private String absender;
   private String empfaenger;
   private String typ;
   private int seq;
   private int teil;
   private int gesamt;
   private int laenge;
   private String nutzdaten;
   private int pruefsumme;

   public Paket(String absender, String empfaenger, String typ,
                int seq, int teil, int gesamt, String nutzdaten) {
      this.kennung = "FN1";
      this.absender = absender;
      this.empfaenger = empfaenger;
      this.typ = typ;
      this.seq = seq;
      this.teil = teil;
      this.gesamt = gesamt;
      this.nutzdaten = nutzdaten;
      this.laenge = nutzdaten.length();
      this.pruefsumme = berechnePruefsumme(ohnePruefsumme());
   }

   // TODO 1: Zahl mit führenden Nullen als Text.
   //   mitNullen(7, 3) -> "007", mitNullen(15, 2) -> "15"
   public String mitNullen(int zahl, int stellen) {
      return "" + zahl;
   }

   // TODO 2: alle Felder bis einschließlich Nutzdaten hintereinander,
   //   Zahlenfelder mit mitNullen auf feste Breite.
   //   Beispiel: "FN1ZENTRAKURIR1BST0070101015Pizza Salami x2"
   public String ohnePruefsumme() {
      return "";
   }

   // TODO 3 (Kapitel 4)
   public int berechnePruefsumme(String s) {
      return 0;
   }

   // fertig: Funktext = ohnePruefsumme() + Prüfsumme (3-stellig)
   public String toString() {
      return ohnePruefsumme() + mitNullen(pruefsumme, 3);
   }

   // TODO 4: Funktext mit substring zerlegen (Aufgabe 2.2 c)
   public static Paket parse(String text) {
      return null;
   }

   // TODO 5 (Kapitel 4)
   public boolean istGueltig() {
      return false;
   }

   // fertig: Ziffernfolge -> Zahl, -1 bei einer Nicht-Ziffer
   private static int zahlAus(String s) {
      int wert = 0;
      for (int i = 0; i < s.length(); i++) {
         char c = s.charAt(i);
         if (c < '0' || c > '9') {
            return -1;
         }
         wert = wert * 10 + ((int) c - 48);
      }
      return wert;
   }

   // ... beschreibung() und Getter (fertig)
}
Listing 2.1: Gerüst der Klasse Paket
Warum? Eine eigene Methode zahlAus statt Integer.parseInt

Integer.parseInt liest in der Online-IDE "4x" ohne Fehler als 4. Ein verfälschtes Zahlenfeld fiele dann nicht auf. zahlAus arbeitet nur mit charAt und ASCII-Werten und liefert bei jeder Nicht-Ziffer −1.

Aufgabe 2.2 (Partnerarbeit): Pakete bauen und zerlegen

TODO 1

Ziel: mitNullen(7, 3) liefert "007". Fertig, wenn: die vier Tests zu TODO 1 ✓ zeigen.

Hilfe 1: Was liefert "" + 7? Wie lang ist das, und wie lang soll es werden?

Hilfe 2: Ergänzen Sie das Struktogramm:

s ← „“ + zahl
solange ____
s ← ____
gib s zurück
Struktogramm 2.1: mitNullen(zahl: Ganzzahl, stellen: Ganzzahl): Zeichenkette

Hilfe 3:

s ← „“ + zahl
solange Länge von s < stellen
s ← „0“ + s
gib s zurück
Struktogramm 2.2: mitNullen(zahl: Ganzzahl, stellen: Ganzzahl): Zeichenkette

Vor dem Vergleich: Was liefert Ihre Methode für mitNullen(1234, 3)? Ist das sinnvoll?

Musterlösung
public String mitNullen(int zahl, int stellen) {
   String s = "" + zahl;
   while (s.length() < stellen) {
      s = "0" + s;
   }
   return s;
}

mitNullen(1234, 3) liefert "1234" – die Methode kürzt nicht. Das Feld wäre dann zu breit; deshalb begrenzt FN/1 die Werte (Seq bis 999, Länge bis 60).

TODO 2

Ziel: ohnePruefsumme() setzt die Felder nach Tabelle 2.1 zusammen. Fertig, wenn: der Test „Kopf + Nutzdaten richtig zusammengesetzt“ ✓ zeigt. toString() hängt vorerst 000 an.

Hilfe 1: Welche Felder sind Zahlen und brauchen deshalb mitNullen?
Hilfe 2: Feldbreiten: Seq 3, Teil 2, Gesamt 2, Länge 3. Die Felder werden mit + verkettet.

Hilfe 3:

return kennung + absender + empfaenger + typ
       + mitNullen(seq, 3) + /* Teil, Gesamt, Länge */ + nutzdaten;
Musterlösung
public String ohnePruefsumme() {
   return kennung + absender + empfaenger + typ
          + mitNullen(seq, 3) + mitNullen(teil, 2)
          + mitNullen(gesamt, 2) + mitNullen(laenge, 3) + nutzdaten;
}

TODO 4

Ziel: parse schneidet die Felder mit substring heraus, wandelt Zahlen mit zahlAus um und erzeugt ein Paket. Danach übernimmt es Kennung, Länge und Prüfsumme so, wie sie angekommen sind. Texte unter 31 Zeichen ergeben null. Ob das Paket fehlerfrei ist, prüft erst istGueltig() in Kapitel 4. Fertig, wenn: alle Tests zu TODO 4 ✓ zeigen (außer „Prüfsumme 198 übernommen“).

BasisErgänzen Sie:
public static Paket parse(String text) {
   if (text == null || text.length() < 31) {
      return null;
   }
   int n = text.length();
   String abs = text.substring(3, 9);
   String emp = // TODO: Positionen 9 bis 14
   String typ = // TODO
   int seq = zahlAus(text.substring(18, 21));
   int teil = // TODO
   int gesamt = // TODO
   // Nutzdaten: alles zwischen Kopf und Prüfsumme
   String daten = text.substring(28, n - 3);
   Paket p = new Paket(abs, emp, typ, seq, teil, gesamt, daten);
   p.kennung = // TODO: wie angekommen
   p.laenge = zahlAus(text.substring(25, 28));
   p.pruefsumme = // TODO: letzte drei Zeichen, wie angekommen
   return p;
}
ChallengeSchreiben Sie parse ohne Gerüst und begründen Sie, warum parse Kennung, Länge und Prüfsumme nach dem Konstruktor überschreiben muss.
Hilfe 1: Welche Zeichen liefert "FN1ZENTRA".substring(3, 9)? Ist Position 9 dabei?
Hilfe 2: substring(a, b) liefert Position a bis vor b. Feld „Empfänger“ (9–14) → substring(9, 15). Bestimmen Sie so die Grenzen aller Felder aus Tabelle 2.1; die Prüfsumme steht in substring(n - 3, n).
Hilfe 3 Challenge: Der Konstruktor berechnet Länge und Prüfsumme aus dem, was jetzt im Paket steht. Was würde istGueltig() dann bei einem verfälschten Paket feststellen?

Vor dem Vergleich: Ihre Lösung liest die Nutzdaten mit substring(28, n - 3) und nicht mit substring(28, 28 + laenge). Was wäre bei einem verfälschten Längenfeld 099 passiert?

Musterlösung
public static Paket parse(String text) {
   if (text == null || text.length() < 31) {
      return null;
   }
   int n = text.length();
   Paket p = new Paket(text.substring(3, 9), text.substring(9, 15),
                       text.substring(15, 18),
                       zahlAus(text.substring(18, 21)),
                       zahlAus(text.substring(21, 23)),
                       zahlAus(text.substring(23, 25)),
                       text.substring(28, n - 3));
   p.kennung = text.substring(0, 3);
   p.laenge = zahlAus(text.substring(25, 28));
   p.pruefsumme = zahlAus(text.substring(n - 3, n));
   return p;
}

Mit 28 + laenge käme es bei 099 zu einem Laufzeitfehler (Index hinter dem Textende). Begründung (Challenge): Der Konstruktor setzt FN1, berechnet Länge und Prüfsumme neu – jedes empfangene Paket sähe „richtig“ aus. Nur mit den angekommenen Werten kann istGueltig() vergleichen.

Ergänzen Sie in PaketTest.starte() zwei Tests mit pruefe(bedingung, text): Paket (4) aus Aufgabe 2.1 und eine Quittung ohne Nutzdaten. Erklären Sie, warum der Test „parse und toString passen zusammen“ besonders aussagekräftig ist.

Hilfe 1: Paket pos = Paket.parse("FN1KURIR2ZENTRAPOS0310101008Neumarkt687"); – was muss danach für pos gelten?
Hilfe 2: Bei diesem Test wird zerlegt und wieder gebaut. Welche Art Fehler fällt nur dabei auf?
Musterlösung
Paket pos = Paket.parse("FN1KURIR2ZENTRAPOS0310101008Neumarkt687");
pruefe(pos != null && pos.getAbsender().equals("KURIR2")
       && pos.getSeq() == 31 && pos.getNutzdaten().equals("Neumarkt"),
       "Position Neumarkt");
Paket quit = Paket.parse("FN1KURIR1ZENTRAACK0070101000807");
pruefe(quit != null && quit.getNutzdaten().equals("")
       && quit.getLaenge() == 0, "Quittung ohne Nutzdaten");

Der Test zeigt, ob toString und parse zueinander passen: Jede Position, die beim Zerlegen anders gezählt wird als beim Bauen, verändert den Text. Genau das brauchen zwei Stationen, um sich zu verstehen.

Zeichnen Sie das Struktogramm zu zahlAus (Listing 2.1) und erklären Sie, warum (int) c - 48 den Ziffernwert liefert.

Musterlösung
wert ← 0
für i von 0 bis Länge von s − 1
c ← Zeichen an Position i von s
c < ‚0‘ oder c > ‚9‘wahrfalsch
gib −1 zurück
–
wert ← wert · 10 + (ASCII-Wert von c − 48)
gib wert zurück
Struktogramm 2.3: zahlAus(s: Zeichenkette): Ganzzahl

Die Ziffern 0–9 haben die ASCII-Werte 48–57. Zieht man 48 ab, erhält man den Ziffernwert. wert · 10 schiebt die bisherigen Ziffern eine Stelle nach links.

Ausgezeichnet – Alle Aufgaben abgeschlossen!

Die Klasse Paket kann Funktexte bauen und zerlegen.

Sicherung

Definition: Interoperabilität

Verschiedene Programme können zusammenarbeiten, weil beide dieselbe Vereinbarung (dasselbe Protokoll) genau gleich umsetzen.

Merke

Ein Paket besteht aus Kopf, Nutzdaten und Prüfsumme. In FN/1 haben alle Kopffelder eine feste Breite, die Länge der Nutzdaten steht im Kopf. Deshalb genügen length, charAt und substring zum Zerlegen, und die Nutzdaten dürfen jedes Zeichen enthalten. Senden: Objekt → Text (toString). Empfangen: Text → Objekt (parse).

Plan-Check

Vergleichen Sie Ihre Vermutung aus dem Einstieg: Wie viele Zerlege-Methoden braucht die Zentrale jetzt? Welche Eigenschaft Ihres eigenen Entwurfs fehlt FN/1?

Rückbezug: Sechs Gruppen, sechs Dialekte

Mit sechs Formaten bräuchte die Zentrale sechs Zerlege-Methoden – und jede neue Station eine weitere. Mit FN/1 genügt eine Klasse Paket für alle Stationen. Die Dialekte waren einzeln sinnvoll, aber nicht zueinander kompatibel. Was FN/1 nicht kann (z. B. kurze Pakete wie Karte A), ist der Preis des Standards.

Checkpoint

Checkpoint_Kap2_Paket.java (TODO 1, 2, 4 gelöst, TODO 3 und 5 offen). Regel: Zeigt PaketTest nach längerer Fehlersuche noch ✗ bei TODO 4, laden Sie den Checkpoint und suchen Sie den Unterschied zu Ihrem Code.


Kapitel 3: Funken

Worum es geht: Ihr Programm soll zuhören, während es auf Eingaben wartet – und dabei nur auf Pakete reagieren, die für Ihre Station bestimmt sind.

Einstieg: Funkspruch während der Eingabe

Störung im Liefernetz (Plenum)

Ihre Klasse Paket funktioniert, jetzt geht sie auf Sendung. Das Hauptprogramm Ihrer Station sieht so aus:

while (true) {
   String ziel = Input.readString("Empfänger:");
   String text = Input.readString("Bestellung:");
   station.sende(ziel, "BST", text);
}
Listing 3.1: Eingabeschleife der Station

1. Vorhersage (allein): Ihr Programm wartet in Input.readString auf Ihre Eingabe. Genau jetzt funkt die Zentrale eine Bestellung an Sie. Was passiert?
(A) Der Funkspruch geht verloren. (B) Er erscheint, sobald Sie die Eingabe abschicken. (C) Er erscheint sofort, obwohl das Programm wartet.

2. Beobachten: Öffnen Sie Station.java, tragen Sie Ihr Rufzeichen und den Sitzungscode der Lehrkraft ein, setzen Sie demo = false und starten Sie. Geben Sie nichts ein. Die Zentrale funkt einige Bestellungen an verschiedene Kuriere, eine Statusmeldung an alle und eine Zahlung der Kasse. Zählen Sie mit: Wie viele Pakete erscheinen bei Ihnen? Wie viele waren für Ihr Rufzeichen bestimmt?

Leitfrage: Wie kann ein Funkspruch erscheinen, während Ihr Programm in Input.readString wartet – wer hat den Code ausgeführt, der ihn anzeigt?

Nebenfragen:

  1. Was soll Ihre Station mit Paketen tun, die nicht für sie bestimmt sind?
Unser Plan
  • Vergleichen Sie: Wer klingelt an Ihrer Haustür – und müssen Sie dafür ständig an der Tür stehen?
  • Wo im Programm entscheidet sich, ob ein Paket „für mich“ ist?

Nr.Plan-PunktAufgabe
1Klären, wer empfange aufruft und warum das während der Eingabe geht3.1 a
2Senden verstehen: Seq, Rundruf, Grenzen3.1 b
3Adressfilter: nur Pakete an das eigene Rufzeichen oder ALLE__ verarbeiten3.2 gA / 3.3 eA
4Klären, wer im Netz welche Daten über uns erfährt3.1 c

Aufgaben: Senden und Empfangen verstehen

Ein ausgearbeitetes Beispiel zeigt, welchen Weg ein Paket nimmt. Danach erklären Sie Ihre Beobachtung aus dem Einstieg.

Ihr Bearbeitungsfortschritt:0%

Beispiel: Der Weg eines Pakets. KURIR1 meldet der Zentrale seine Position. Ein Sequenzdiagramm (Zeit-Weg-Diagramm) zeigt den Ablauf: Die Stationen stehen nebeneinander, die Zeit läuft nach unten.

Abbildung 3.1: Der Weg eines Pakets (gA) KURIR1 Kanal ZENTRA KURIR2 Zeit 1–4 sende → zerlege → sendeZuverlaessig → funk.senden FN1KURIR1ZENTRAPOS031… 5 sendToAll 5 sendToAll 6–8 onMessage → empfange → verarbeite 6–7 onMessage → empfange → nicht für mich
Abbildung 3.1: Der Weg eines Pakets (gA)
Tabelle 3.1: Die Schritte im Einzelnen
SchrittWo?Was passiert?Wer ruft auf?
1Hauptprogramm KURIR1station.sende(„ZENTRA“, „POS“, „Neumarkt“)Ihr Programm
2Station KURIR1zerlege baut ein Paket mit der nächsten SeqIhr Programm
3Station KURIR1sendeZuverlaessig(p) → funk.senden(p.toString())Ihr Programm
4Funkgerät KURIR1Text durch den StoerKanal, dann sendToAll(text, "FN1")Ihr Programm
5Online-IDEüberträgt an alle anderen Stationen der SitzungSystem
6Funkgerät ZENTRA (und KURIR2 …)onMessage(sender, text, "FN1") startet, in einem eigenen ThreadSystem
7Funkgerät ZENTRAstation.empfange(text)Funkgerät
8Station ZENTRAparse, Adressfilter, verarbeiteIhre Station

eA Ihre Station ist selbst das Funkgerät: Die Schritte 4, 6 und 7 laufen in Ihrer Klasse Station extends WebSocket.

Aufgabe 3.1 (Partnerarbeit): Wer ruft wen auf?

Erklären Sie mit Tabelle 3.1, warum der Funkspruch im Einstieg erschien, obwohl Ihr Programm in Input.readString wartete. Welche Methoden ruft Ihr Programm selbst auf, welche werden „von außen“ aufgerufen?

Hilfe 1: In welcher Spalte von Tabelle 3.1 steht „System“? In welchem Thread läuft Schritt 6?
Hilfe 2: Zwei Threads laufen gleichzeitig: Der eine wartet in Input.readString, der andere …

Vor dem Vergleich: Welche Antwort (A, B, C) hatten Sie vorhergesagt? Was genau war an Ihrer Begründung richtig oder falsch?

Musterlösung

(C) ist richtig. sende ruft Ihr Programm selbst auf (Schritte 1–4). onMessage und damit empfange ruft die Online-IDE auf, sobald etwas ankommt – jedes Mal in einem eigenen Thread (Schritte 6–8). Der Haupt-Thread wartet weiter in Input.readString, der Empfangs-Thread zeigt das Paket an. So eine Methode heißt Ereignismethode: Man schreibt sie, ruft sie aber nie selbst auf – wie eine Türklingel, die Sie ruft, statt dass Sie an der Tür warten.

Beantworten Sie mit Listing 3.2 (unten im gA-Gerüst; im eA-Gerüst ist sende fast gleich):

  1. Welche Seq bekommen die ersten drei Pakete einer Station? Welche das Paket nach Seq 999?
  2. Was passiert anders, wenn der Empfänger ALLE__ ist?
  3. Sagen Sie vorher: Was passiert mit einer Bestellung aus 137 Zeichen? Ist das noch FN/1?
Hilfe 1: Sehen Sie sich in zerlege die Zeile mit % 1000 an.
Hilfe 2: Welches Feld von FN/1 hat höchstens den Wert 060?
Musterlösung
  1. Seq 0, 1, 2 (000, 001, 002); nach 999 folgt 0 (Ring).
  2. Rundrufe gehen ohne sendeZuverlaessig direkt ans Funkgerät; sie werden später nicht quittiert.
  3. Das vorläufige zerlege packt alles in ein Paket mit Länge 137. Das verletzt FN/1 (höchstens 60) – Thema von Kapitel 6.

Die Online-IDE liefert zu jeder Station der Sitzung nicht nur getNickname(), sondern auch getFirstName(), getLastName() und getUserName() des angemeldeten Kontos. Ihre Station schreibt außerdem jedes gehörte Paket ins Logbuch (eine Datenbank). Wer kann was über Sie erfahren? Vereinbaren Sie drei Regeln für den Kurs.

Hilfe 1: Denken Sie an ein fremdes Programm in derselben Sitzung, das gar nicht zum Liefernetz gehört.
Hilfe 2: Rufzeichen sind Pseudonyme. Wer kennt die Zuordnung Rufzeichen → Person?
Musterlösung

Jedes Programm in der Sitzung kann die Klarnamen aller anderen lesen, auch ein reines „Lausch-Programm“. Das Logbuch speichert jedes Paket mit Zeit, Absender, Empfänger und Nutzdaten – bei jeder Station, auch fremde Zahlungen im Klartext. Ein Rufzeichen ist ein Pseudonym – nicht anonym. Regeln z. B.: Nickname = Rufzeichen; Klarnamen-Methoden nie aufrufen, anzeigen oder speichern; keine echten Adressen oder Telefonnummern in Nutzdaten; Logbuch nach dem Projekt löschen.

Ausgezeichnet – Alle Aufgaben abgeschlossen!

Sie wissen, wie ein Paket durch das Netz läuft.

Aufgaben: Empfangen mit Adressfilter gA

Sie verbinden Ihre Klasse Paket mit dem fertigen Funkgeraet zu einer Station.

Ihr Bearbeitungsfortschritt:0%

Material: Workspace mit Paket.java (Ihre Lösung oder Checkpoint), StoerKanal.java, Funkgeraet.java, Logbuch.java, Station.java (Gerüst). Das Funkgerät schickt jeden Text über den StoerKanal an alle anderen Stationen und ruft bei Empfang von sich aus station.empfange(text) auf.

Gerüst Station.java anzeigen (Auszug)
// ---- Einstellungen ----
String rufzeichen = "ZENTRA";   // genau 6 Zeichen
String session = "LOOPBACK";    // im Netz: Code der Gruppe
String datenbank = "";          // Logbuch-Datenbank oder ""
boolean demo = true;

Station station = new Station(rufzeichen, datenbank);
StoerKanal kanal = station.getFunk().getKanal();
kanal.setVerlust(0);            // Kapitel 5
kanal.setFehler(0);             // Kapitel 4
kanal.setVerzoegerung(0);
station.starte(session);
// ... Demo bzw. Eingabeschleife (Listing 3.1)

class Station {
   // ... Attribute, Konstruktor, starte, getFunk

   // fertig: zerlegen, dann jedes Paket senden
   public boolean sende(String empfaenger, String typ,
                        String text) {
      DynArray pakete = zerlege(empfaenger, typ, text);
      for (int i = 0; i < pakete.getLength(); i++) {
         Paket p = (Paket) pakete.getItem(i);
         if (empfaenger.equals("ALLE__")) {
            funk.senden(p.toString());
         } else if (!sendeZuverlaessig(p)) {
            println("Abbruch: " + empfaenger, Color.red);
            return false;
         }
      }
      return true;
   }

   // vorläufig (TODO 4, Kapitel 5): nur senden
   public boolean sendeZuverlaessig(Paket p) {
      funk.senden(p.toString());
      return true;
   }

   // vorläufig (TODO 5, Kapitel 6): alles in EIN Paket
   public DynArray zerlege(String empfaenger, String typ,
                           String text) {
      DynArray liste = new DynArray();
      liste.append(new Paket(rufzeichen, empfaenger, typ,
                             naechsteSeq, 1, 1, text));
      naechsteSeq = (naechsteSeq + 1) % 1000;
      return liste;
   }

   // TODO 1 (Aufgabe 3.2 a)
   public void empfange(String text) {
      println("empfangen: " + text, Color.gray);
   }

   // hier kommt später die Logik Ihrer Abteilung hin
   private synchronized void verarbeite(Paket p, String text) {
      println("<= " + p.getTyp() + " von " + p.getAbsender()
              + ": " + text, Color.yellow);
   }
}
Listing 3.2: Station (gA), Gerüst für Kapitel 3
Aufgabe 3.2 (Partnerarbeit): Die Station geht auf Sendung

TODO 1

Ziel: empfange zerlegt den Funktext; bei null Abbruch. Pakete, die weder an das eigene Rufzeichen noch an ALLE__ gehen, werden ignoriert, ebenso Quittungen (ACK, NAK – die legt das Funkgerät für später ab). Alle anderen gehen an verarbeite(p, p.getNutzdaten()). Fertig, wenn: die Funkprobe in Teil b) klappt.

Hilfe 1: Ein Paket ist für Sie, wenn sein Empfänger einer von zwei Werten ist. Welcher Getter liefert den Empfänger?

Hilfe 2: Ergänzen Sie:

p ← Paket.parse(text)
p = nullwahrfalsch
Abbruch der Operation // kein FN1-Paket
–
an ← Empfänger von p
____wahrfalsch
Abbruch der Operation // nicht für mich
–
Typ von p = „ACK“ oder Typ von p = „NAK“wahrfalsch
Abbruch der Operation // Quittung
–
verarbeite(p, Nutzdaten von p)
Struktogramm 3.1: empfange(text: Zeichenkette)
Hilfe 3: Die Lücke: an ≠ rufzeichen und an ≠ "ALLE__", in Java !an.equals(rufzeichen) && !an.equals("ALLE__").

Vor dem Vergleich: Warum steht in der Bedingung && und nicht ||? Probieren Sie beide Varianten gedanklich mit an = "ALLE__" aus.

Musterlösung
public void empfange(String text) {
   Paket p = Paket.parse(text);
   if (p == null) {
      return;
   }
   String an = p.getEmpfaenger();
   // nicht für mich?
   if (!an.equals(rufzeichen) && !an.equals("ALLE__")) {
      return;
   }
   // Quittungen erledigt das Funkgerät
   if (p.getTyp().equals("ACK") || p.getTyp().equals("NAK")) {
      return;
   }
   verarbeite(p, p.getNutzdaten());
}

Mit || wäre die Bedingung immer wahr (kein Text ist gleichzeitig ZENTRA und ALLE__), die Station würde alles ignorieren.

  1. Allein: session = "LOOPBACK", demo = true. Die Demo sendet an das eigene Rufzeichen. Ändern Sie dann ein Ziel auf ein fremdes Rufzeichen. Was erwarten Sie?
  2. In der Gruppe: Sitzungscode Ihrer Gruppe, demo = false, jede Person mit eigenem Rufzeichen. Senden Sie an einzelne Stationen und an ALLE__. Kommt alles genau bei den richtigen Stationen an?
Hilfe 1: Im LOOPBACK-Modus kommt jedes gesendete Paket bei Ihnen selbst an. Was entscheidet dann über die Anzeige?
Hilfe 2: Wenn nichts ankommt: Ist der Sitzungscode bei allen exakt gleich? Hat jedes Rufzeichen genau 6 Zeichen? Sind alle in der Online-IDE angemeldet? Ist demo = false?
Musterlösung

LOOPBACK: Pakete an das eigene Rufzeichen erscheinen, an fremde nicht. Gruppe: Bestellungen erscheinen nur beim adressierten Kurier, Rundrufe bei allen anderen – nicht beim Sender, denn sendToAll erreicht nur die anderen.

Ihre Station soll für jedes gehörte Paket (auch fremde) mitzählen, wie viele Pakete jeder Absender gesendet hat, und die Liste mit zeigeStatistik() ausgeben. Nutzen Sie eine DynArray mit Objekten einer kleinen Klasse Zaehler (Rufzeichen, Anzahl).

Musterlösung

In empfange direkt nach der null-Prüfung: den Zaehler mit getRufzeichen().equals(p.getAbsender()) suchen (Schleife über getItem), sonst neu anlegen und mit append anfügen; dann anzahl++. Ausgabe in einer Schleife. Die Zählung vor dem Adressfilter zeigt: Jede Station kennt den Funkverkehr aller.

Ausgezeichnet – Alle Aufgaben abgeschlossen!

Ihre Station funkt.

Aufgaben: Die Station wird selbst zum Funkgerät eA

Ihre Station erbt von WebSocket und ist damit selbst das Funkgerät. Sie sendet über ihren StoerKanal (kanal.uebertrage(text)), der sendToAll(text, "FN1") aufruft bzw. im LOOPBACK-Modus onMessage(null, text, "FN1").

Ihr Bearbeitungsfortschritt:0%

Material: Workspace mit Paket.java, StoerKanal.java, Logbuch.java, Station.java (eA-Gerüst) – ohne Funkgeraet.java.

Aufgabe 3.3 (Partnerarbeit): Vererbung im Funknetz

Erläutern Sie an Abbildung 3.3: Welche geerbten Methoden ruft Station selbst auf? Welche überschreibt sie, damit die Online-IDE sie aufruft? Warum führt ein Tippfehler wie onOtherClientDisConnected zu keiner Fehlermeldung, aber zu falschem Verhalten?

Hilfe 1: Sortieren Sie die Methoden von WebSocket in zwei Spalten: „Ich rufe auf“ und „Ich werde aufgerufen (on…)“.
Hilfe 2: Was entsteht, wenn Sie eine Methode mit einem neuen, leicht anderen Namen schreiben?
Musterlösung

Selbst aufgerufen: open, sendToAll (über den Störkanal). Überschrieben: onMessage (Pflicht), optional onOpen, onOtherClientConnected, onOtherClientDisconnected – die Online-IDE ruft sie bei Ereignissen auf. Ein Tippfehler erzeugt eine neue Methode. Sie ist erlaubt, wird aber nie aufgerufen; die geerbte, leere Methode bleibt wirksam.

TODO 1

Ziel: Bei "LOOPBACK" den Kanal mit kanal.setLoopback(true) umschalten, sonst open(sessionCode, rufzeichen) – Nickname = Rufzeichen. (Den Timer aus dem Kommentar ergänzen Sie erst in Kapitel 5.)

Hilfe 1: Strings vergleichen Sie mit equals, nicht mit ==.
Musterlösung
public void verbinde(String sessionCode) {
   if (sessionCode.equals("LOOPBACK")) {
      kanal.setLoopback(true);
   } else {
      // Nickname = Rufzeichen, nie der Klarname
      open(sessionCode, rufzeichen);
   }
}

TODO 2

Ziel: onMessage überschreiben: Nur messageType "FN1" beachten; den Text zuerst an empfange geben, danach ins Logbuch schreiben (logbuch.schreibe("EIN", message)). In empfange den Adressfilter ergänzen (wie Hilfe 2 zu Aufgabe 3.2 a). onOtherClientConnected zeigt das Rufzeichen jeder neuen Station.

Hilfe 1: Die Signatur muss exakt stimmen: public void onMessage(WebSocketClient sender, String message, String messageType). Im LOOPBACK ist sender gleich null – benutzen Sie ihn nicht.
Hilfe 2: Der Adressfilter: weiter nur, wenn der Empfänger rufzeichen oder "ALLE__" ist.

Vor dem Vergleich: Warum erst empfange, dann Logbuch? (Tipp: Ein Datenbankzugriff dauert pro Paket spürbar.)

Musterlösung
public void onMessage(WebSocketClient sender, String message,
                      String messageType) {
   if (!messageType.equals("FN1")) {
      return;
   }
   empfange(message);
   logbuch.schreibe("EIN", message);
}

public void onOtherClientConnected(WebSocketClient c) {
   // nur das Rufzeichen, keine Klarnamen
   println("+ " + c.getNickname() + " ist auf Sendung.");
}

// in empfange nach der null-Prüfung:
String an = p.getEmpfaenger();
if (!an.equals(rufzeichen) && !an.equals("ALLE__")) {
   return;
}

Erst verarbeiten, dann protokollieren: Ab Kapitel 5 muss eine Quittung schnell beim Sender sein. Wartet sie auf die Datenbank, läuft beim Sender die Wartezeit ab.

Testen Sie wie in Aufgabe 3.2 b) – erst LOOPBACK, dann in der Gruppen-Sitzung, gern zusammen mit einer gA-Station. Begründen Sie, warum sich beide verstehen, obwohl die Programme verschieden aufgebaut sind.

Hilfe 1: Was haben beide Programme gemeinsam – im Code oder auf dem Kanal?
Musterlösung

Beide halten sich an FN/1 (gleiche Funktexte, messageType "FN1"). Wie eine Station intern gebaut ist, spielt keine Rolle: Interoperabilität.

Führen Sie eine DynArray mit den Rufzeichen aller verbundenen Stationen: onOtherClientConnected fügt an, onOtherClientDisconnected (kleines c!) entfernt mit delete. Eine Methode zeigeTeilnehmer() gibt die Liste aus.

Musterlösung

Beim Entfernen die Liste mit getItem(i) durchsuchen, bei Gleichheit delete(i) und abbrechen. Hinweis: Wer sich ohne Abmeldung trennt (Browser zu), bleibt eventuell in der Liste – das Netz kennt keinen sicheren Abmeldezeitpunkt.

Ausgezeichnet – Alle Aufgaben abgeschlossen!

Ihre Station funkt als eigene WebSocket-Unterklasse.

Sicherung

Definition: Ereignismethode

Eine Ereignismethode schreibt man selbst, aufgerufen wird sie aber vom System, wenn ein Ereignis eintritt (Callback). In der Online-IDE läuft jeder Aufruf von onMessage in einem eigenen Thread – das Hauptprogramm läuft weiter.

Merke

Der Funkkanal ist ein geteiltes Medium: Jede Nachricht erreicht alle. Adressierung im Kopf und ein Adressfilter in jeder Station sorgen dafür, dass nur die richtige Station ein Paket verarbeitet. Ein Rundruf geht an ALLE__.

Achtung

Ein Adressfilter ist kein Schutz. Jede Station kann alle Pakete lesen und einen beliebigen Absender eintragen. Vertraulichkeit und Echtheit brauchen Kryptologie (Abteilung Kasse).

Plan-Check

Lesen Sie Ihre Vorhersage aus dem Einstieg. War sie richtig? Formulieren Sie in einem Satz, was ein Konsolenprogramm von einer Station mit Ereignismethode unterscheidet.

Rückbezug: Funkspruch während der Eingabe

Der Funkspruch erschien sofort (C), weil nicht Ihr Hauptprogramm ihn abholte, sondern die Online-IDE onMessage in einem eigenen Thread aufrief. Von allen Paketen, die bei Ihnen ankamen, waren nur wenige für Ihr Rufzeichen bestimmt; die Kuriere aus der ersten Schicht hätten mit dem Adressfilter nur noch ihre eigenen Aufträge gesehen.

Checkpoint

Checkpoint_Kap3_Station_gA.java bzw. Checkpoint_Kap3_Station_eA.java (empfangen mit Adressfilter). Läuft Ihre Funkprobe nach längerer Fehlersuche nicht: Checkpoint laden und mit dem eigenen Code vergleichen.


Kapitel 4: Rauschen auf der Leitung

Worum es geht: Verfälschte Bestellungen führen Kuriere in die Irre → Ihre Station prüft die Prüfsumme und reklamiert. Sie testen, was die Prüfsumme kann und was nicht – und ob Korrigieren besser wäre.

Einstieg: Hasestraße 72

Störung im Liefernetz (Plenum)

Mitschnitt von gestern Abend, Gewitter über Osnabrück:

gesendet von ZENTRA:
FN1ZENTRAKURIR1BST01201010282x Pizza Salami, Hasestr. 12181
empfangen bei KURIR1:
FN1ZENTRAKURIR1BST01201010282x Pizza Salami, Hasestr. 72181
<= BST von ZENTRA: 2x Pizza Salami, Hasestr. 72

Kurier 1 fährt zur Hasestraße 72. Dort hat niemand bestellt. Die Station von KURIR1 hat die mitgeschickte Prüfsumme gar nicht beachtet.

Leitfrage: Erkennt die FN/1-Prüfsumme jede Verfälschung? Legen Sie sich fest: Ja oder Nein – mit einem Beispiel.

Nebenfragen:

  1. Was soll eine Station mit einem verfälschten Paket tun?
  2. Könnte der Empfänger den Fehler auch selbst beheben, statt nachzufragen?
Unser Plan
  • Erinnern Sie sich an Paritätsbit und EAN-Prüfziffer: Was wird berechnet, was mitgeschickt, was geprüft?
  • Wie können Sie Ihre Festlegung überprüfen, ohne zu programmieren?

Nr.Plan-PunktAufgabe
1Prüfsumme von Hand rechnen, Festlegung an verschiedenen Fehlerarten testen4.1
2Ausprobieren, ob Korrigieren mit dem Hamming-Code besser wäre4.2
3berechnePruefsumme und istGueltig programmieren4.3 a, b
4Verfälschte Pakete nicht verarbeiten, sondern reklamieren; messen4.3 c, d

Aufgaben: Die Prüfsumme auf dem Prüfstand

Erst auf Papier: Was erkennt die Prüfsumme, was nicht?

Ihr Bearbeitungsfortschritt:0%
Aufgabe 4.1 (Partnerarbeit): Prüfsumme von Hand

Die FN/1-Prüfsumme ist die Summe der ASCII-Werte aller Zeichen vor ihr, mod 1000, dreistellig.

Tabelle 4.1: ASCII-Werte (Ausschnitt)
ZeichenASCIIZeichenASCII
0 … 948 … 57A65
149C67
250K75
755Leerzeichen32

Berechnen Sie die Prüfsumme der Quittung FN1KURIR1ZENTRAACK0070101000???. Gegeben: FN1 = 197, KURIR1 = 446, ZENTRA = 468.

Hilfe 1: Es fehlen die Blöcke ACK und 0070101000. Wie viele Nullen stecken im zweiten Block?
Hilfe 2: Eine Ziffer d hat den ASCII-Wert 48 + d. Zehn Ziffern also 10 · 48 + Summe der Ziffern.
Musterlösung
BlockSumme
FN1197
KURIR1446
ZENTRA468
ACK65 + 67 + 75 = 207
007010100010 · 48 + 7 + 1 + 1 = 489
gesamt1807 → mod 1000 = 807

Gesendet wurde FN1ZENTRAKURIR1BST01201010282x Pizza Salami, Hasestr. 12181 (Prüfsumme 181). Bestimmen Sie für jede empfangene Variante nur, wie sich die Summe ändert, und ob der Empfänger den Fehler bemerkt.

Tabelle 4.2: Empfangene Varianten
Nr.empfangen (veränderter Teil)Fehlerart
(1)… Hasestr. 72 … 181ein Zeichen verfälscht
(2)…KURIR2… … 181ein Zeichen im Kopf verfälscht
(3)… Hasestr. 21 … 181zwei Zeichen vertauscht
(4)… Hasestr. 12 … 131Prüfsumme verfälscht
Hilfe 1: Bei (1) wird aus 1 (49) eine 7 (55). Um wie viel ändert sich die Summe?
Hilfe 2: Bei (3) kommen dieselben Zeichen vor, nur in anderer Reihenfolge. Was bedeutet das für eine Summe?

Vor dem Vergleich: Passt das Ergebnis zu Ihrer Festlegung aus dem Einstieg?

Musterlösung
Nr.Änderungneu berechneterkannt?
✓ (1)+6187 ≠ 181ja
✓ (2)+1182 ≠ 181ja – sonst nähme Kurier 2 die Bestellung an
✗ (3)±0181 = 181nein: Hausnummer 21
✓ (4)Summe gleich, Prüffeld falsch181 ≠ 131ja – Paket wird unnötig verworfen, aber kein falscher Auftrag

Formulieren Sie: Welche Fehler erkennt die FN/1-Prüfsumme sicher, welche nie, welche manchmal? Begründen Sie mit den Zahlen aus Teil b).

Hilfe 1: Ein einzelnes Zeichen ändert sich höchstens von ASCII 32 auf 126 oder umgekehrt. Kann die Summe sich dabei um 0 oder um 1000 ändern?
Hilfe 2: Was passiert, wenn aus 1 eine 0 und aus 2 eine 3 wird?
Musterlösung

Sicher erkannt wird jedes einzelne verfälschte Zeichen, auch im Kopf und in der Prüfsumme: Die Summe ändert sich um höchstens ±94, nie um 0 oder ein Vielfaches von 1000. Nie erkannt werden Vertauschungen (gleiche Zeichen, gleiche Summe). Manchmal übersehen werden mehrere Fehler, die sich aufheben (12 → 03: −1 + 1 = 0).

Ausgezeichnet – Alle Aufgaben abgeschlossen!

Sie wissen, was die FN/1-Prüfsumme leistet.

Aufgaben: Korrigieren statt reklamieren?

Eine Prüfsumme kann nur reklamieren. Der Hamming-Code aus der Codierungstheorie kann einzelne Bitfehler korrigieren. Lohnt sich das im Liefernetz? (Papier, ohne IDE)

Ihr Bearbeitungsfortschritt:0%
Aufgabe 4.2 (Partnerarbeit): Hamming für die Hasestraße

Material: Hamming(7,4) wie im Abitur: Reihenfolge p0 p1 d0 p2 d1 d2 d3, gerade Parität. Das Zeichen 1 hat den ASCII-Wert 49 = 0011 0001; jedes Halbbyte wird ein Codewort.

Tabelle 4.3: Welche Stellen prüft welches Prüfbit?
PrüfbitStellen (1–7)Bits
p01, 3, 5, 7p0, d0, d1, d3
p12, 3, 6, 7p1, d0, d2, d3
p24, 5, 6, 7p2, d1, d2, d3

Das erste Halbbyte 0011 ergibt das Codewort 1000011. Kodieren Sie das zweite Halbbyte 0001.

Hilfe 1: d0 d1 d2 d3 = 0 0 0 1. Jedes Prüfbit macht die Anzahl der Einsen in seiner Gruppe gerade.
Hilfe 2: p0 = d0 + d1 + d3 (mod 2) = 0 + 0 + 1 = 1. Rechnen Sie p1 und p2 genauso.
Musterlösung

p0 = 1, p1 = 0 + 0 + 1 = 1, p2 = 0 + 0 + 1 = 1 → p0 p1 d0 p2 d1 d2 d3 = 1101001.

Beim Kurier kommt für das zweite Halbbyte 1101101 an. Finden Sie das gekippte Bit, korrigieren Sie es und bestimmen Sie das Zeichen. Was hätte der Kurier ohne Korrektur gelesen?

Hilfe 1: Prüfen Sie jede Gruppe aus Tabelle 4.3: Ist die Anzahl der Einsen gerade?
Hilfe 2: Die Nummern der Prüfbits mit ungerader Gruppe ergeben addiert die Fehlerstelle: s0 · 1 + s1 · 2 + s2 · 4.
Musterlösung
GruppeBits (Stellen)Einsens
p01, 0, 1, 1 (1, 3, 5, 7)31
p11, 0, 0, 1 (2, 3, 6, 7)20
p21, 1, 0, 1 (4, 5, 6, 7)31

Fehlerstelle 1 + 4 = 5 (d1). Korrigiert 1101001 → Daten 0001 → 0011 0001 = 1. Ohne Korrektur: Daten 0101 → 0011 0101 = 53 = 5, also „Hasestr. 52“.

Vergleichen Sie den Aufwand: Hamming braucht für jedes Zeichen 14 statt 8 Bit, die FN/1-Prüfsumme 3 Zeichen je Paket. Wann lohnt sich Korrigieren statt Reklamieren?

Hilfe 1: Berechnen Sie die Informationsrate 4/7. Wie groß ist bei Paket (1) aus Aufgabe 2.1 (46 Zeichen) der Anteil der Prüfzeichen?
Hilfe 2: Wie lange dauert eine Rückfrage im Liefernetz – und wie lange bei einer Raumsonde?
Musterlösung

Hamming: Rate 4/7 ≈ 57 %, fast die Hälfte der Bits ist Schutz. Prüfsumme: 3 von 46 Zeichen ≈ 7 %. Korrigieren lohnt, wenn Rückfragen teuer oder unmöglich sind (lange Laufzeiten, Rundfunk ohne Rückkanal, viele Einzelbitfehler). Im Liefernetz ist eine Rückfrage billig, deshalb reklamiert FN/1. Die Abteilung Funkstrecke eA baut Hamming ein.

Aus 1 (0011 0001) wird im Einstieg 7 (0011 0111): Im zweiten Halbbyte kippen zwei Bits. Kodieren Sie, verfälschen Sie die beiden Bits und wenden Sie das Korrekturverfahren an. Was liest der Kurier?

Musterlösung

1101001 mit gekippten d1 und d2 → 1101111. Gruppen: p0 → 1, p1 → 1, p2 → 0, Fehlerstelle 1 + 2 = 3. „Korrigiert“ wird d0 → 1111111 → Daten 1111 → 0011 1111 = ?. Bei zwei Fehlern korrigiert Hamming(7,4) falsch – der Mindestabstand 3 reicht nur für einen Fehler.

Ausgezeichnet – Alle Aufgaben abgeschlossen!

Sie kennen Stärken und Grenzen beider Verfahren.

Aufgaben: Prüfen und reklamieren

Jetzt im Code: Die Station soll verfälschte Pakete erkennen und reklamieren.

Ihr Bearbeitungsfortschritt:0%

Material: Ihre Paket.java (TODO 3 und 5) und Ihre Station.java.

Aufgabe 4.3 (Partnerarbeit): Die Prüfsumme im Programm

TODO 3 (Paket)

Ziel: Summe der ASCII-Codes aller Zeichen von s, mod 1000. Fertig, wenn: in PaketTest die Tests mit 197, 198 und 807 ✓ zeigen.

Hilfe 1: Wie haben Sie in zahlAus Zeichen für Zeichen durch einen Text gegangen? Den ASCII-Wert liefert (int) s.charAt(i).

Hilfe 2: Ergänzen Sie:

summe ← 0
für i von 0 bis ____
summe ← ____
gib summe mod 1000 zurück
Struktogramm 4.1: berechnePruefsumme(s: Zeichenkette): Ganzzahl
Musterlösung
public int berechnePruefsumme(String s) {
   int summe = 0;
   for (int i = 0; i < s.length(); i++) {
      summe = summe + (int) s.charAt(i);
   }
   return summe % 1000;
}

TODO 5 (Paket)

Ziel: istGueltig() liefert nur true, wenn

  1. die Kennung FN1 ist,
  2. seq ≥ 0 und 1 ≤ teil ≤ gesamt gilt (Nicht-Ziffern ergaben −1),
  3. laenge zur Länge der Nutzdaten passt und höchstens 60 ist,
  4. die mitgeschickte Prüfsumme gleich der neu berechneten ist.

Fertig, wenn: alle Tests zu TODO 5 ✓ zeigen. Lesen Sie die „Beobachtung“ am Ende von PaketTest.

Hilfe 1: Prüfen Sie die vier Bedingungen nacheinander; sobald eine verletzt ist, return false.
Hilfe 2: Neu berechnet wird über den Text ohne Prüfsumme: berechnePruefsumme(ohnePruefsumme()).

Vor dem Vergleich: Ein Paket wurde unterwegs abgeschnitten. An welcher Ihrer Bedingungen scheitert es?

Musterlösung
public boolean istGueltig() {
   if (!kennung.equals("FN1")) {
      return false;
   }
   if (seq < 0 || teil < 1 || gesamt < 1 || teil > gesamt) {
      return false;
   }
   if (laenge != nutzdaten.length() || laenge > 60) {
      return false;
   }
   return pruefsumme == berechnePruefsumme(ohnePruefsumme());
}

Ein abgeschnittenes Paket hat weniger Nutzdaten, als das Längenfeld angibt (Bedingung 3); meist stimmt auch die Prüfsumme nicht. Die „Beobachtung“: Salmai statt Salami gilt als gültig – die Vertauschung aus Aufgabe 4.1 b (3).

gA: TODO 2 eA: TODO 3

Ziel: Ist ein Paket (nach dem Adressfilter) ungültig, wird es nicht verarbeitet. Die Station zählt es (defekt++) und schickt – wenn es an das eigene Rufzeichen ging und selbst keine Quittung ist – mit der fertigen Methode quittiere(p, "NAK") eine negative Quittung mit derselben Seq an den Absender.

Hilfe 1: In welcher Reihenfolge prüfen Sie? Lesbar? → an mich? → gültig? → Quittung? → verarbeiten.
Hilfe 2: Warum kein NAK auf eine defekte Quittung? Stellen Sie sich zwei Stationen vor, die jede Quittung mit einer Quittung beantworten. Und warum kein NAK auf Rundrufe?

Hilfe 3:

boolean istQuittung = p.getTyp().equals("ACK")
                      || p.getTyp().equals("NAK");
if (!p.istGueltig()) {
   defekt++;
   if (an.equals(rufzeichen) && !istQuittung) {
      // ...
   }
   return;
}

Vor dem Vergleich: Was passiert, wenn Sie das NAK vor dem Adressfilter senden?

Musterlösung
public void empfange(String text) {
   Paket p = Paket.parse(text);
   if (p == null) {
      return;
   }
   String an = p.getEmpfaenger();
   if (!an.equals(rufzeichen) && !an.equals("ALLE__")) {
      return;
   }
   boolean istQuittung = p.getTyp().equals("ACK")
                         || p.getTyp().equals("NAK");
   if (!p.istGueltig()) {
      defekt++;
      println("   defekt: " + text, Color.lightcoral);
      // nie auf Quittungen, nie auf Rundrufe
      if (an.equals(rufzeichen) && !istQuittung) {
         quittiere(p, "NAK");
      }
      return;
   }
   if (istQuittung) {
      return;
   }
   verarbeite(p, p.getNutzdaten());
}

Ohne Adressfilter davor würden alle Stationen fremde defekte Pakete reklamieren. Antworten auf Quittungen lösen ein endloses „Quittungs-Pingpong“ aus, auf einen Rundruf antworteten alle gleichzeitig.

Stellen Sie kanal.setFehler(30) ein (eA: station.getKanal().setFehler(30)) und testen Sie mit LOOPBACK und demo = true. Vergleichen Sie mit station.zeigeStatistik(): Wie viele Pakete hat der Kanal verfälscht, wie viele hat die Station als defekt erkannt? Kam eine verfälschte Bestellung unerkannt durch?

Hilfe 1: Der Störkanal kippt in einem Zeichen ein Bit (Bit 0 bis 4). Um wie viel ändert sich der ASCII-Wert? Was folgt mit Aufgabe 4.1 c?
Musterlösung

Die Zahl „defekt empfangen“ stimmt mit den verfälschten Paketen überein. Unerkannt kommt keines durch: Ein gekipptes Bit ändert den ASCII-Wert um 1, 2, 4, 8 oder 16 – ein einzelner Zeichenfehler wird immer erkannt. Vertauschungen erzeugt der Störkanal nicht. Der Sender bekommt das NAK, tut aber noch nichts damit: Die Bestellung fehlt.

Schreiben Sie in Paket eine Methode gewichtetePruefsumme(String s): \( \sum_i (i+1)\cdot \text{ASCII}(s_i) \bmod 997 \). Zeigen Sie mit zwei Tests in PaketTest, dass Salami und Salmai jetzt verschiedene Werte ergeben. Warum mod 997 und nicht mod 1000? Warum dürfen Sie FN/1 trotzdem nicht einfach im eigenen Programm ändern?

Musterlösung

Für FN1ZENTRAKURIR1BST0070101015Pizza Salami x2 ergibt sich 193, mit Salmai 181: Vertauschte Zeichen stehen an Stellen mit anderem Gewicht. Mit mod 1000 kann ein Einzelfehler verschwinden: Gewicht 40 und Änderung 25 (A → Z) ergibt 1000 ≡ 0. 997 ist eine Primzahl größer als alle Gewichte und Änderungen, deshalb ist (Gewicht · Änderung) nie durch 997 teilbar. FN/1 ist eine Vereinbarung: Rechnet eine Station allein anders, hält sie jedes fremde Paket für verfälscht und umgekehrt. Nötig ist eine neue Version (Kennung FN2), die alle umsetzen.

Ausgezeichnet – Alle Aufgaben abgeschlossen!

Ihre Station erkennt verfälschte Pakete und reklamiert sie.

Sicherung

Definition: Prüfsumme

Eine Prüfsumme ist ein Kontrollwert, den der Sender aus den übertragenen Zeichen berechnet und mitschickt. Der Empfänger berechnet ihn neu; stimmen beide nicht überein, ist das Paket verfälscht. Eine negative Quittung (NAK) meldet dem Sender das.

Merke

Die Prüfsumme erkennt Fehler, sie korrigiert sie nicht. Sie erkennt nicht jeden Fehler (Vertauschungen nie). Sie schützt nicht vor absichtlicher Fälschung – wer fälscht, rechnet die Prüfsumme einfach neu. Ein fehlerkorrigierender Code wie Hamming(7,4) spart Rückfragen, kostet aber viel mehr Prüfbits.

Plan-Check

Lesen Sie Ihre Festlegung aus dem Einstieg (Ja/Nein mit Beispiel). Stimmt sie? Ergänzen Sie ein Beispiel, das die Prüfsumme sicher erkennt, und eines, das sie nie erkennt.

Rückbezug: Hasestraße 72

Die Antwort lautet Nein. Kurier 1 hätte bei „Hasestr. 72“ die Prüfsumme 187 statt 181 berechnet, das Paket verworfen und mit NAK reklamiert. Bei „Hasestr. 21“ (Vertauschung) wäre er trotzdem falsch gefahren. Mit Hamming hätte er ein einzelnes gekipptes Bit selbst korrigiert, aber 1 → 7 kippt zwei Bits in einem Codewort – das korrigiert Hamming falsch.

Checkpoint

Checkpoint_Kap4_Paket.java (vollständige Klasse Paket) und Checkpoint_Kap4_Station_gA.java bzw. Checkpoint_Kap4_Station_eA.java (mit NAK). Ab hier rechnen alle mit derselben, vollständigen Klasse Paket.


Kapitel 5: Verloren und doppelt

Worum es geht: Pakete verschwinden spurlos, Wiederholungen führen zu doppelten Lieferungen → Quittung, Timeout, Wiederholung und Duplikaterkennung (Stop-and-Wait).

Einstieg: Die verschwundene Bestellung

Störung im Liefernetz (Plenum, dann Dreiergruppen)

Dienstag, am Stadtrand reißt die Funkverbindung immer wieder ab: Jedes vierte Paket kommt gar nicht an. Aus den Logbüchern von ZENTRA und KURIR1:

Tabelle 5.1: Logbuch-Ausschnitt (Funktext gekürzt)
ZeitStationEreignisFunktext
17:40:02ZENTRAAUSBST 040 Pizza Tonno, Iburger Str. 4
✗ –KURIR1kein Eintrag, kein NAK, keine Antwort–
17:58:30–Anruf von KUNDE3: „Wo bleibt meine Pizza?“–
17:58:41ZENTRAAUS (von Hand wiederholt)BST 040 Pizza Tonno, Iburger Str. 4
17:58:41KURIR1EINBST 040 Pizza Tonno, Iburger Str. 4
18:01:15ZENTRAAUS („sicherheitshalber“ noch einmal)BST 040 Pizza Tonno, Iburger Str. 4
✗ 18:01:15KURIR1EIN → liefert zwei Pizzen TonnoBST 040 Pizza Tonno, Iburger Str. 4

Leitfrage: Wie kann die Zentrale sicher erfahren, ob ihre Bestellung angekommen ist – ohne dass Kurier 1 doppelt liefert?

Nebenfragen:

  1. Warum hat die NAK-Regel aus Kapitel 4 hier nicht geholfen?

Rollenspiel (Dreiergruppen): Zentrale, Kanal (würfelt: bei einer 1 geht der Zettel verloren – auch ein Antwortzettel) und Kurier. Spielen Sie drei Bestellungen mit Ihrer Idee durch. Was passiert, wenn die Antwort verloren geht?

Unser Plan
  • Was soll der Empfänger nach jedem gültigen Paket tun? Was der Sender, wenn keine Antwort kommt?
  • Woran erkennt der Kurier, dass ein Paket nur eine Wiederholung ist?

Nr.Plan-PunktAufgabe
1Abläufe mit Verlust als Sequenzdiagramm durchspielen, den Sender als Automaten beschreiben5.1, 5.2
2Empfänger: jedes gültige Paket mit ACK quittieren, Duplikate erkennen5.3
3Sender: auf ACK warten, nach Timeout oder NAK wiederholen, nach 5 Versuchen aufgeben5.4 gA / 5.5 eA
4Mit Verlust und Fehlern testen5.4 c / 5.5 d

Aufgaben: Abläufe beschreiben

Die Regeln von FN/1: Der Empfänger bestätigt jedes gültige Paket an ihn mit einer Quittung ACK mit derselben Seq. Der Sender wartet höchstens 2000 ms. Kommt bis dahin kein passendes ACK (Timeout) oder kommt ein NAK, sendet er dasselbe Paket erneut, höchstens fünfmal.

Ihr Bearbeitungsfortschritt:0%
Abbildung 5.1: Sequenzdiagramm, Normalfall ZENTRA KURIR1 Zeit BST 40 gültig, neu → verarbeiten ACK 40 ACK 40 passt → fertig
Abbildung 5.1: Sequenzdiagramm, Normalfall
Tabelle 5.2: Normalfall als Tabelle
ZeitZENTRA (Sender)KanalKURIR1 (Empfänger)
0 mssendet BST 40, wartet→
30 msgültig, neu → verarbeiten, ACK 40
60 msACK 40 passt → fertig←
Aufgabe 5.1 (Partnerarbeit): Sequenzdiagramme

Zeichnen Sie die Abläufe; als Tabelle wie Tabelle 5.2 ist auch erlaubt.

BST 40 geht beim ersten Versuch verloren.

Hilfe 1: Der Sender bekommt gar nichts. Wann und wodurch reagiert er?
Musterlösung
ZeitZENTRAKanalKURIR1
✗ 0 mssendet BST 40, wartet→ ✗ verloren
2000 msTimeout → BST 40 erneut (Versuch 2)→
2030 msgültig, neu → verarbeiten, ACK 40
2060 msACK 40 passt → fertig←

Das ACK 40 geht beim ersten Mal verloren. Beschreiben Sie, woran KURIR1 das Duplikat erkennt und warum er es trotzdem quittieren muss.

Hilfe 1: KURIR1 hat die Bestellung schon verarbeitet. Was weiß ZENTRA davon?
Hilfe 2: Was täte ZENTRA, wenn KURIR1 das Duplikat einfach ignoriert?

Vor dem Vergleich: Vergleichen Sie mit dem Logbuch aus dem Einstieg. Welche Zeile entspricht dem Duplikat?

Musterlösung
ZeitZENTRAKanalKURIR1
0 mssendet BST 40, wartet→
✗ 30 ms✗ verloren ←gültig, neu → verarbeiten, ACK 40
2000 msTimeout → BST 40 erneut→
2030 msgleicher Absender, gleiche Seq → Duplikat: nicht verarbeiten, aber ACK 40
2060 msACK 40 passt → fertig←

KURIR1 hat sich Absender ZENTRA und Seq 40 gemerkt. Ohne erneutes ACK würde ZENTRA bis zum fünften Versuch wiederholen und „Abbruch“ melden, obwohl die Bestellung längst angekommen ist.

BST 40 kommt beim ersten Mal verfälscht an.

Musterlösung
ZeitZENTRAKanalKURIR1
0 mssendet BST 40, wartet→ verfälscht
30 msPrüfsumme falsch → NAK 40
60 msNAK 40 → BST 40 sofort erneut← / →
90 msgültig, neu → verarbeiten, ACK 40
120 msACK 40 passt → fertig←

Pakete brauchen wegen einer Störung 1500 ms je Richtung, der Timeout bleibt bei 2000 ms. Beschreiben Sie, was passiert, und schlagen Sie eine Regel für einen guten Timeout vor.

Hilfe 1: Wann kommt das ACK beim Sender an?
Musterlösung

Das ACK kommt erst nach 3000 ms. Schon nach 2000 ms sendet ZENTRA erneut, KURIR1 erkennt ein Duplikat und quittiert noch einmal: unnötige Wiederholungen, doppelte Quittungen, mehr Last. Ein verspätetes ACK kann ankommen, während der Sender schon auf das nächste Paket wartet – deshalb der Seq-Vergleich. Regel: Timeout größer als die Rundlaufzeit (Hinweg + Verarbeitung + Rückweg), z. B. das Doppelte des gemessenen Höchstwerts. Zu lang ist auch schlecht: Verlorene Pakete werden spät wiederholt.

Aufgabe 5.2 (Partnerarbeit): Der Sender als Mealy-Automat

Der Sender reagiert auf Eingaben (SENDEN = neuer Auftrag, ACK = passendes gültiges ACK, NAK = passendes gültiges NAK, TIMEOUT) mit Ausgaben und wechselt den Zustand. Betrachtet wird ein Paket nach dem anderen.

Zeichnen Sie den Sender als Mealy-Automaten mit den Zuständen BEREIT und WARTET, Σ = {SENDEN, ACK, NAK, TIMEOUT} und Ω = {sende, wiederhole, fertig}. Die Grenze von 5 Versuchen lassen Sie weg. Geben Sie den Automaten vollständig an.

Hilfe 1: Welche Ihrer Sequenzdiagramme aus Aufgabe 5.1 enden in „fertig“, welche gehen weiter? Daraus ergeben sich die Übergänge aus WARTET.
Hilfe 2: Vollständig heißt: In jedem Zustand gibt es für jedes Eingabezeichen genau einen Übergang (Notation Eingabe / Ausgabe, keine Ausgabe: ε). Was passiert in BEREIT bei einem verspäteten ACK? Was in WARTET bei einem neuen Auftrag?
Hilfe 3: Drei Übergänge: BEREIT –SENDEN / sende→ WARTET, WARTET –ACK / fertig→ BEREIT, WARTET –TIMEOUT / wiederhole→ WARTET. Es fehlen fünf.
Musterlösung
ZustandSENDENACKNAKTIMEOUT
BEREITsende → WARTETε → BEREITε → BEREITε → BEREIT
WARTETε → WARTET (Auftrag wartet)fertig → BEREITwiederhole → WARTETwiederhole → WARTET
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Sie können die Abläufe beschreiben.

Aufgaben: Quittieren und Duplikate erkennen

Der Empfänger quittiert und erkennt Duplikate. Dafür merkt er sich, was er von wem zuletzt bekommen hat.

Ihr Bearbeitungsfortschritt:0%
Aufgabe 5.3 (Partnerarbeit): Der Empfänger

Angenommen, die Zentrale merkt sich nur ein Paar letzterAbsender/letzteSeq. Bei ihr kommen nacheinander an: (1) KURIR1 POS 031, (2) KURIR2 POS 017, (3) KURIR1 POS 031 (Wiederholung, weil das ACK verloren ging). Notieren Sie nach jedem Paket die beiden Werte und ob (3) als Duplikat erkannt wird. Was muss sich die Station stattdessen merken?

Hilfe 1: Welche Werte stehen nach Paket (2) in letzterAbsender und letzteSeq?
Musterlösung
PaketletzterAbsenderletzteSeqDuplikat?
(1) KURIR1 031KURIR131nein (neu)
(2) KURIR2 017KURIR217nein (neu)
✗ (3) KURIR1 031KURIR131nicht erkannt, wird doppelt verarbeitet

Ein einziges Paar reicht nur bei einem Gesprächspartner. Die Station merkt sich deshalb die letzte Seq je Absender: für jede Gegenstelle ein eigenes Objekt.

gA: TODO 3 eA: TODO 4, 5

Material: In Ihrer Station sind die Klasse Gegenstelle und die Methode finde(rufzeichen) fertig: finde sucht die Gegenstelle zum Rufzeichen in der Reihung gegenstellen und legt sie an, wenn es sie noch nicht gibt.

Ziel: Am Ende von empfange (nach der Gültigkeitsprüfung und nach if (istQuittung) { return; }):

  1. Jedes Paket an das eigene Rufzeichen mit quittiere(p, "ACK") bestätigen – auch Duplikate.
  2. Nur bei Paketen an das eigene Rufzeichen: Duplikat (gleiche Seq wie zuletzt von diesem Absender)? → duplikate++, nicht verarbeiten. Sonst die Seq bei der Gegenstelle merken.
  3. Danach verarbeiten. Rundrufe an ALLE__ werden weder quittiert noch auf Duplikate geprüft – sie werden nie wiederholt.

Fertig, wenn: die LOOPBACK-Demo ohne Fehler läuft. Duplikate testen Sie in Aufgabe 5.4 c bzw. 5.5 d.

Hilfe 1: Erst quittieren, dann auf Duplikat prüfen. Warum diese Reihenfolge? (Aufgabe 5.1 b)

Hilfe 2: Ergänzen Sie:

an = rufzeichenwahrfalsch
quittiere(p, „ACK“)
g ← finde(Absender von p)
____wahrfalsch
duplikate ← duplikate + 1
Abbruch der Operation // Duplikat
–
____
–
verarbeite(p, Nutzdaten von p)
Struktogramm 5.1: Ende von empfange
Hilfe 3: Die Lücken: Letzte Seq von g = Seq von p und g.setLetzteSeq(Seq von p).

Vor dem Vergleich: Warum startet letzteSeq mit −1 und nicht mit 0?

Musterlösung
   if (istQuittung) {
      return;
   }
   if (an.equals(rufzeichen)) {
      // immer quittieren, auch Duplikate
      quittiere(p, "ACK");
      // Duplikate nur bei Paketen an mich prüfen:
      // Rundrufe werden nie wiederholt.
      Gegenstelle g = finde(p.getAbsender());
      if (g.getLetzteSeq() == p.getSeq()) {
         duplikate++;
         println("   Duplikat " + p.getSeq() + " verworfen",
                 Color.gray);
         return;
      }
      g.setLetzteSeq(p.getSeq());
   }
   verarbeite(p, p.getNutzdaten());

Mit Startwert 0 würde das allererste Paket (Seq 0) als Duplikat verworfen.

Eine Station stürzt ab und startet neu – wieder mit Seq 000. Ihr Partner hat sich von ihr zuletzt Seq 000 gemerkt. Was passiert? Wie kann onOtherClientDisconnected (kleines c) helfen?

Musterlösung

Das erste neue Paket gilt als Duplikat: Es wird quittiert, aber nicht verarbeitet – eine Bestellung geht stillschweigend verloren. Abhilfe: Meldet sich eine Station ab, die Gegenstelle mit ihrem Rufzeichen aus gegenstellen löschen (delete). Ganz sicher ist das nicht, weil ein Absturz nicht immer als Abmeldung ankommt.

Ausgezeichnet – Alle Aufgaben abgeschlossen!

Ihr Empfänger quittiert zuverlässig.

Aufgaben: Stop-and-Wait programmieren gA

Das fertige Funkgerät legt jede ACK/NAK-Nachricht an Ihr Rufzeichen sofort in ein Quittungsfach – noch bevor es ins Logbuch schreibt, damit keine Quittung auf die Datenbank warten muss. funk.warteAufQuittung(int ms) wartet höchstens ms Millisekunden darauf und liefert den Funktext der Quittung oder "" (Timeout).

Ihr Bearbeitungsfortschritt:0%
Aufgabe 5.4 (Partnerarbeit): Der Sender wartet

TODO 4

Ziel: Die Methode soll

  1. p senden und mit funk.warteAufQuittung(2000) auf eine Antwort warten,
  2. bei einem gültigen ACK mit der Seq von p true zurückgeben,
  3. sonst (NAK, Timeout, unbrauchbar) erneut senden – höchstens 5 Versuche, Wiederholungen in wiederholungen zählen,
  4. nach 5 Fehlversuchen abgebrochen++ und false zurückgeben.
Hilfe 1: Welcher Zustand Ihres Automaten aus Aufgabe 5.2 entspricht dem Warten? Welche Kontrollstruktur „wartet“ höchstens fünfmal?

Hilfe 2: Ergänzen Sie:

für versuch von 1 bis 5
versuch > 1wahrfalsch
wiederholungen ← wiederholungen + 1
–
funk.senden(Funktext von p)
q ← Paket.parse(funk.warteAufQuittung(2000))
____wahrfalsch
gib wahr zurück
–
abgebrochen ← abgebrochen + 1
gib falsch zurück
Struktogramm 5.2: sendeZuverlaessig(p: Paket): Wahrheitswert
Hilfe 3: Die Bedingung: q != null && q.istGueltig() && q.getSeq() == p.getSeq() && q.getTyp().equals("ACK"). Wegen && wird q.istGueltig() nur aufgerufen, wenn q nicht null ist.

Vor dem Vergleich: Ihre Lösung prüft die Seq der Quittung. Welcher Fall aus Aufgabe 5.1 d) ginge ohne diese Prüfung schief?

Musterlösung
public boolean sendeZuverlaessig(Paket p) {
   for (int versuch = 1; versuch <= 5; versuch++) {
      if (versuch > 1) {
         wiederholungen++;
      }
      println("-> " + p.beschreibung() + " (Versuch " + versuch + ")",
              Color.lightblue);
      funk.senden(p.toString());
      Paket q = Paket.parse(funk.warteAufQuittung(2000));
      if (q == null) {
         println("   Timeout", Color.orange);
      } else if (!q.istGueltig() || q.getSeq() != p.getSeq()) {
         println("   Quittung unbrauchbar", Color.orange);
      } else if (q.getTyp().equals("ACK")) {
         println("   ACK", Color.green);
         return true;
      } else {
         println("   NAK - sende erneut", Color.orange);
      }
   }
   abgebrochen++;
   return false;
}

Ohne Seq-Vergleich könnte ein verspätetes ACK zum vorigen Paket das aktuelle „bestätigen“, obwohl es verloren ging.

Ordnen Sie die Teile des Automaten aus Aufgabe 5.2 der Methode sendeZuverlaessig zu: Wo ist der Zustand WARTET, wo der Übergang nach BEREIT, wo kommen die Eingaben TIMEOUT und NAK her? Was im Programm kommt im Automaten nicht vor?

Hilfe 1: Solange die Schleife läuft, wartet der Sender.
Musterlösung

Aufruf mit dem ersten funk.senden = SENDEN / sende (BEREIT → WARTET). Die Schleife ist der Zustand WARTET. warteAufQuittung liefert die Eingabe: "" = TIMEOUT, passendes NAK = NAK, passendes ACK = ACK. return true = ACK / fertig; ein neuer Durchlauf = wiederhole. Nicht im Automaten: der Zähler versuch, der Abbruch nach 5 Versuchen und unbrauchbare Quittungen (im Programm eine Wiederholung, im Automaten keine Eingabe).

Stellen Sie setVerlust(20) und setFehler(20) ein. Testen Sie mit LOOPBACK (demo = true), dann zu zweit in der Gruppen-Sitzung – beide Stationen mit Störkanal, denn auch Quittungen laufen hindurch. Senden Sie 20 Bestellungen und notieren Sie mit zeigeStatistik(): Wiederholungen, Duplikate, Abbrüche, Dauer.

Hilfe 1: Ein Versuch gelingt nur, wenn Paket und Quittung weder verloren noch verfälscht werden: \(0{,}8^4 \approx 0{,}41\). Wie wahrscheinlich sind fünf Fehlversuche nacheinander?
Musterlösung

Jede Bestellung wird beim Empfänger genau einmal verarbeitet; einige Duplikate werden erkannt (verlorene ACKs); viele Pakete brauchen 2–3 Versuche, Timeouts verlängern die Übertragung deutlich. Ein Abbruch ist selten (\(0{,}59^5 \approx 7\,\%\) je Paket). Kommt er vor, kann die Bestellung trotzdem angekommen sein – nur die ACKs gingen verloren.

Warum? Vor verarbeite steht synchronized

sendeZuverlaessig blockiert den aufrufenden Thread bis zu 10 s, und es gibt nur ein Quittungsfach. Ruft Ihre Abteilung später aus verarbeite heraus sende auf, dürfen nicht zwei Empfangs-Threads gleichzeitig darin sein – synchronized lässt immer nur einen Thread hinein. empfange selbst ist nicht synchronized: Sonst blieben eingehende Pakete während eines blockierenden sende unquittiert.

Messen Sie in sendeZuverlaessig mit System.currentTimeMillis() die Zeit vom Senden bis zum passenden ACK und geben Sie Mittelwert und Höchstwert in zeigeStatistik() aus. Welcher Timeout wäre in Ihrem Netz angemessen?

Musterlösung

Vor funk.senden die Startzeit merken, bei return true die Differenz zu einer Summe und einem Zähler addieren, Höchstwert mitführen. Typisch sind im Schulnetz einige zehn bis wenige hundert Millisekunden; ein Timeout vom Doppelten des Höchstwerts ist deutlich kürzer als 2000 ms, macht das Netz aber anfälliger für Lastspitzen.

Ausgezeichnet – Alle Aufgaben abgeschlossen!

Ihre Station überträgt zuverlässig.

Aufgaben: Der Automat im Programm eA

Im eA-Gerüst wartet der Sender nicht in einer Schleife: Der Automat ist die Methode ereignis(String eingabe, int seq) mit dem Attribut zustand ("BEREIT"/"WARTET"). Neue Aufträge warten in der Queue sendepuffer.

Ihr Bearbeitungsfortschritt:0%
Tabelle 5.3: Woher kommen die Eingaben?
Eingabekommt vonAufruf
SENDENsende(...) (fertig)ereignis(„SENDEN“, -1)
ACK, NAKempfange (Ihr Code)ereignis(p.getTyp(), p.getSeq())
TIMEOUTTimer → pruefeTimeout() alle 100 msereignis(„TIMEOUT“, -1)

Die Ausgaben erledigen fertige Methoden: naechstesPaket() (sende bzw. fertig: nächstes Paket aus der Queue senden und WARTET, oder BEREIT, wenn die Queue leer ist) und wiederholeOderAbbrechen(grund) (wiederhole bzw. abbrechen). Mit Sendepuffer wird aus „ACK / fertig“ also „ACK / sende (nächstes)“, und der Automat bleibt in WARTET, solange Aufträge warten.

Aufgabe 5.5 (Partnerarbeit): Ereignisgesteuert senden

Erweitern Sie den Automaten aus Aufgabe 5.2 so, dass er nach dem fünften erfolglosen Versuch abbricht (Ausgabe „abbrechen“). Verwenden Sie nur Zustände, keinen Zähler. Wie viele Zustände brauchen Sie? Warum nutzt man im Programm trotzdem eine Zählvariable?

Hilfe 1: Der Zustand muss sich merken, wie oft schon gesendet wurde: W1 (einmal gesendet) … W5.
Musterlösung

Zustände BEREIT, W1 … W5 (sechs), Ω = {sende, wiederhole, fertig, abbrechen}.

ZustandSENDENACKNAK oder TIMEOUT
BEREITsende → W1ε → BEREITε → BEREIT
Wk (k = 1 … 4)ε → Wkfertig → BEREITwiederhole → W(k+1)
W5ε → W5fertig → BEREITabbrechen → BEREIT

Für n Versuche braucht der Automat n + 1 Zustände. Ein endlicher Automat „zählt“ nur über Zustände; im Programm fasst man W1 … W5 zu WARTET mit der Zählvariablen versuche zusammen – kürzer und leicht änderbar.

Timer-Thread und Empfangs-Thread arbeiten gleichzeitig. Ergänzen Sie die letzte Zeile und markieren Sie den Konflikt.

Tabelle 5.4: Ein Wettlauf
ZeitTimer-ThreadEmpfangs-Threadaktuell
t1pruefeTimeout: WARTET, 2000 ms vorbei → gleich ereignis("TIMEOUT", -1)–Seq 40
t2–ACK 40: ereignis("ACK", 40) → naechstesPaket() sendet Seq 41Seq 41
t3ereignis(„TIMEOUT“, -1)–?
Hilfe 1: Auf welches Paket bezieht sich der TIMEOUT aus t1 – und welches Paket ist in t3 aktuell?
Hilfe 2: Was würde passieren, wenn ACK und TIMEOUT gleichzeitig in ereignis ankämen und beide versuche und aktuell ändern?
Musterlösung

In t3 bezieht sich der TIMEOUT auf Seq 40, behandelt würde aber Seq 41: Sie würde sofort wiederholt und ein Versuch verbraucht, obwohl gerade erst gesendet wurde. Abhilfe: ereignis prüft beim TIMEOUT die Zeit noch einmal (System.currentTimeMillis() - gesendetUm >= timeoutMs), sonst ε. Und ereignis ist synchronized: Immer nur ein Thread ist „im Automaten“, ACK und TIMEOUT können sich nicht vermischen.

TODO 6, 7

Ziel: Der ACK-Fall ist vorgegeben. Ergänzen Sie

  1. in ereignis (TODO 6) die Fälle NAK und TIMEOUT im Zustand WARTET,
  2. pruefeTimeout (TODO 7) und den Timerstart am Ende von verbinde,
  3. in empfange: gültige ACK/NAK an das eigene Rufzeichen mit ereignis(p.getTyp(), p.getSeq()) melden.
public synchronized void ereignis(String eingabe, int seq) {
   if (zustand.equals("BEREIT")) {
      if (eingabe.equals("SENDEN")) {
         // sende -> WARTET (oder BEREIT, wenn leer)
         naechstesPaket();
      }
      // ACK, NAK, TIMEOUT: ε
   } else if (zustand.equals("WARTET")) {
      if (eingabe.equals("ACK") && seq == aktuell.getSeq()) {
         // fertig bzw. nächstes Paket
         naechstesPaket();
      }
      // TODO 6: NAK mit passender Seq -> wiederholen
      // TODO 6: TIMEOUT, wenn die Zeit wirklich um ist
      // SENDEN, unpassende Quittung: ε
   }
}
Listing 5.1: ereignis mit vorgegebenem ACK-Fall
Hilfe 1: Ein NAK zählt nur, wenn seq == aktuell.getSeq() – sonst ε. Welche fertige Methode erledigt „wiederhole“?

Hilfe 2: Timer starten (am Ende von verbinde):

Station ich = this;
Timer.repeat(() -> { ich.pruefeTimeout(); }, 100);

Hilfe 3: Beim TIMEOUT in ereignis:

} else if (eingabe.equals("TIMEOUT")
           && System.currentTimeMillis() - gesendetUm >= timeoutMs) {
   wiederholeOderAbbrechen("Timeout");
}

Vor dem Vergleich: Nennen Sie für jede Zeile Ihres ereignis den Übergang aus Ihrem Automaten (Aufgabe 5.2).

Musterlösung
      } else if (eingabe.equals("NAK") && seq == aktuell.getSeq()) {
         wiederholeOderAbbrechen("NAK");
      } else if (eingabe.equals("TIMEOUT")
                 && System.currentTimeMillis() - gesendetUm
                    >= timeoutMs) {
         wiederholeOderAbbrechen("Timeout");
      }

public void pruefeTimeout() {
   if (zustand.equals("WARTET")
       && System.currentTimeMillis() - gesendetUm >= timeoutMs) {
      ereignis("TIMEOUT", -1);
   }
}

// in empfange nach der Gültigkeitsprüfung:
if (istQuittung) {
   if (an.equals(rufzeichen)) {
      ereignis(p.getTyp(), p.getSeq());
   }
   return;
}

Im Unterschied zur gA-Lösung blockiert das Hauptprogramm nicht: Die Station empfängt während des Wartens weiter und nimmt neue Aufträge an (sie warten im Sendepuffer). Die Grenze von fünf Versuchen steckt in wiederholeOderAbbrechen (Zähler versuche, vgl. Teil a).

Testen Sie wie in Aufgabe 5.4 c) – erst LOOPBACK, dann zu zweit, beide mit setVerlust(20) und setFehler(20). Senden Sie mehrere Bestellungen direkt nacheinander. Was zeigt die Statistik? Was fällt beim Senden im Vergleich zur gA-Station auf?

Hilfe 1: Achten Sie darauf, ob Sie während laufender Wiederholungen schon die nächste Bestellung eingeben können.
Musterlösung

Wie bei gA: jede Bestellung genau einmal verarbeitet, Duplikate erkannt, seltene Abbrüche. Zusätzlich: Neue Aufträge lassen sich sofort eingeben, sie warten im Sendepuffer und gehen nacheinander hinaus.

Meldet der Sender „Abbruch“, war die Bestellung vielleicht doch da. Kann irgendein Protokoll über einen Kanal, der Nachrichten verlieren kann, erreichen, dass beide Seiten sicher wissen, dass die Nachricht angekommen ist? Begründen Sie.

Musterlösung

Nein. Der Empfänger weiß nach dem ACK nicht, ob das ACK ankam; eine Quittung auf die Quittung hätte dasselbe Problem – die letzte Nachricht ist immer unbestätigt (Problem der zwei Armeen). Protokolle machen Fehler nur unwahrscheinlich und begrenzen den Schaden (Duplikaterkennung, Abbruchmeldung, Nachfragen beim Kunden).

Ausgezeichnet – Alle Aufgaben abgeschlossen!

Ihr Sender ist ein ereignisgesteuerter Automat.

Sicherung

Definition: Stop-and-Wait

Bei Stop-and-Wait schickt der Sender ein Paket und wartet auf dessen Quittung. Bei ACK mit passender Seq sendet er das nächste, bei NAK oder Timeout dasselbe erneut (höchstens 5 Versuche). Der Empfänger quittiert jedes gültige Paket – auch Duplikate –, verarbeitet aber jedes nur einmal.

Merke

Quittungen tragen die Seq des bestätigten Pakets, sonst bestätigt ein verspätetes ACK das falsche Paket. Duplikate erkennt der Empfänger an Absender und Seq. Ein einziges Paar letzterAbsender/letzteSeq reicht nur bei einem Gesprächspartner; im Liefernetz merkt sich die Station die Seq je Gegenstelle.

Infobox: Und im Internet?

TCP nutzt dieselben Ideen – Sequenznummern, Quittungen, Timeout, Wiederholung, Prüfsumme –, schickt aber mehrere Pakete, bevor die Quittungen zurückkommen. Unser WebSocket läuft selbst über TCP und ist eigentlich zuverlässig; der StoerKanal bildet einen echten Funkkanal nach.

Plan-Check

Lesen Sie Ihre Idee aus dem Einstieg. Was davon steckt in Stop-and-Wait? Was hatten Sie nicht bedacht (z. B. verlorene Quittung)?

Rückbezug: Die verschwundene Bestellung

Mit Stop-and-Wait hätte die Zentrale nach 2 Sekunden ohne ACK wiederholt – nicht erst nach dem Anruf um 17:58 Uhr. Die zweite Sendung „sicherheitshalber“ wäre nicht nötig gewesen; und wäre sie doch gekommen, hätte Kurier 1 sie an Absender ZENTRA und Seq 040 als Duplikat erkannt, erneut quittiert und nur eine Pizza Tonno geliefert. Die NAK-Regel half nicht, weil ein verlorenes Paket keine Antwort erzeugt.

Checkpoint

Checkpoint_Kap5_Station_gA.java bzw. Checkpoint_Kap5_Station_eA.java (Stop-and-Wait, Duplikate je Gegenstelle). Wer hier einsteigt, bearbeitet Kapitel 6 mit diesem Stand.


Kapitel 6: Die Großbestellung

Worum es geht: Eine Bestellung ist länger als 60 Zeichen → Fragmentierung: zerlegen, nummerieren, wieder zusammensetzen – auch wenn unterwegs etwas schiefgeht.

Einstieg: Die Großbestellung

Störung im Liefernetz (Plenum)

Das GSG feiert sein Schulfest. Die Zentrale schickt Kurier 1 diese Bestellung (137 Zeichen):

Schulfest GSG: 12x Pizza Margherita, 8x Pizza Salami, 5x Pizza Tonno, 10x Cola, 10x Wasser. Lieferung 11:30 an Hausmeister, Seiteneingang

Bildschirm der Zentrale:

-> [BST 058 1/1 ZENTRA->KURIR1] Schulfest GSG: ... (Versuch 1)
   NAK - sende erneut
-> [BST 058 1/1 ZENTRA->KURIR1] Schulfest GSG: ... (Versuch 2)
   NAK - sende erneut
...
   Abbruch: KURIR1

Till schlägt vor: „Dann erlauben wir eben 200 Zeichen.“

Leitfrage: FN/1 hat die Felder Teil und Gesamt. Reichen sie, damit Kurier 1 eine zerlegte Bestellung immer richtig zusammensetzt? Legen Sie sich fest und nennen Sie einen Fall, der schiefgehen könnte.

Nebenfragen:

  1. Warum lehnt Kurier 1 das Paket ab, obwohl kein Zeichen verfälscht ist – und warum ist Tills Vorschlag keine gute Idee?
Unser Plan
  • Welche Felder haben wir bisher immer mit 01 gefüllt?
  • Was kann mit Teilpaketen passieren: fehlen, doppelt kommen, überholen, sich mit Teilen eines anderen Senders mischen?

Nr.Plan-PunktAufgabe
1Die Bestellung von Hand in Teilpakete zerlegen6.1 a
2zerlege: Stücke zu höchstens 60 Zeichen, Teil/Gesamt, eigene Seq6.1 b
3setzeZusammen und Puffer in empfange6.1 c, d
4Kritische Fälle prüfen (fehlt, doppelt, Reihenfolge, zwei Sender)Plan-Check, Challenge

Länge 137 > 60: istGueltig() lehnt ab, der Kurier antwortet mit NAK. Tills Vorschlag bräche FN/1 – alle anderen Stationen müssten geändert werden. Außerdem gehen lange Pakete häufiger kaputt.

Aufgaben: Lange Nachrichten zerlegen

Der Sender zerlegt, der Empfänger setzt zusammen. gA und eA schreiben denselben Code (eA ohne TODO-Nummern).

Ihr Bearbeitungsfortschritt:0%

Material: Ihre Station.java. Signaturen:

Aufgabe 6.1 (Partnerarbeit): Fragmentierung

Zerlegen Sie die Schulfest-Bestellung in FN/1-Pakete von ZENTRA an KURIR1 (erste Seq: 20). Für die Teile 1 und 2 genügen Seq, Teil, Gesamt und Länge; Teil 3 schreiben Sie vollständig (Prüfsumme ???). Wie viele Zeichen werden insgesamt übertragen (ohne Quittungen)?

Hilfe 1: Wie viele Pakete zu höchstens 60 Zeichen braucht man für 137 Zeichen?
Hilfe 2: Teil 1 enthält die Zeichen 0–59, Teil 2 die Zeichen 60–119, Teil 3 den Rest. Jedes Teilpaket bekommt eine eigene Seq.
Musterlösung

Übertragen werden 3 · 31 + 137 = 230 Zeichen; Nutzanteil 137/230 ≈ 60 %.

gA: TODO 5 eA: ohne TODO-Nummer

Ziel: Der Text wird in Stücke von höchstens 60 Zeichen zerlegt. Jedes Stück wird ein Paket mit Teil i + 1, Gesamt = Anzahl der Stücke und einer eigenen Seq (naechsteSeq, danach erhöhen, nach 999 folgt 0). Auch ein leerer Text ergibt ein Paket. Fertig, wenn: die Demo die lange Bestellung als drei Pakete sendet.

Hilfe 1: Anzahl der Stücke mit ganzzahliger Division: (text.length() + 59) / 60. Was ergibt das für 137, für 60, für 0?

Hilfe 2: Ergänzen Sie:

liste ← neue leere DynArray
anzahl ← (Länge von text + 59) / 60
anzahl = 0wahrfalsch
anzahl ← 1
–
für i von 0 bis anzahl − 1
von ← i · 60
bis ← ____
bis > Länge von textwahrfalsch
bis ← Länge von text
–
p ← neues Paket(rufzeichen, empfaenger, typ, naechsteSeq, ____, anzahl, Teiltext von „von“ bis vor „bis“)
naechsteSeq ← (naechsteSeq + 1) mod 1000
liste.append(p)
gib liste zurück
Struktogramm 6.1: zerlege(empfaenger: Zeichenkette, typ: Zeichenkette, text: Zeichenkette): DynArray
Musterlösung
public DynArray zerlege(String empfaenger, String typ,
                        String text) {
   DynArray liste = new DynArray();
   int anzahl = (text.length() + 59) / 60;
   if (anzahl == 0) {
      // auch leerer Text ergibt ein Paket
      anzahl = 1;
   }
   for (int i = 0; i < anzahl; i++) {
      int von = i * 60;
      int bis = von + 60;
      if (bis > text.length()) {
         bis = text.length();
      }
      Paket p = new Paket(rufzeichen, empfaenger, typ, naechsteSeq,
                          i + 1, anzahl, text.substring(von, bis));
      naechsteSeq = (naechsteSeq + 1) % 1000;
      liste.append(p);
   }
   return liste;
}

Grenze: Teil und Gesamt sind zweistellig – höchstens 99 Teile, also 5940 Zeichen.

gA: TODO 6 eA: ohne TODO-Nummer

Ziel: Die Teile liegen in beliebiger Reihenfolge in der Reihung. Die Methode hängt ihre Nutzdaten in der Reihenfolge der Teilnummern aneinander.

BasisSuchen Sie für jede Teilnummer t von 1 bis Gesamt das passende Paket und hängen Sie seine Nutzdaten an.
ChallengeSortieren Sie die Reihung durch Einfügen (getItem/setItem) nach der Teilnummer und verketten Sie dann der Reihe nach.
Hilfe 1: Ein Element der Reihung hat den Typ Object: Paket t = (Paket) liste.getItem(i);
Hilfe 2 Basis: Äußere Schleife über t von 1 bis Gesamt, innere Schleife sucht das Paket mit getTeil() == t. Gesamt steht in jedem Paket, z. B. im ersten.
Hilfe 2 Challenge: Wie bei der Einfügesortierung im Kapitel Datenstrukturen – verglichen wird getTeil().

Vor dem Vergleich: Was liefert Ihre Methode für eine leere Reihung?

Musterlösung Basis
public String setzeZusammen(DynArray liste) {
   if (liste.isEmpty()) {
      return "";
   }
   int gesamt = ((Paket) liste.getItem(0)).getGesamt();
   String text = "";
   for (int t = 1; t <= gesamt; t++) {
      for (int i = 0; i < liste.getLength(); i++) {
         Paket p = (Paket) liste.getItem(i);
         if (p.getTeil() == t) {
            text = text + p.getNutzdaten();
         }
      }
   }
   return text;
}
Musterlösung Challenge
public String setzeZusammen(DynArray liste) {
   for (int i = 1; i < liste.getLength(); i++) {
      Paket akt = (Paket) liste.getItem(i);
      int j = i - 1;
      while (j >= 0
             && ((Paket) liste.getItem(j)).getTeil() > akt.getTeil()) {
         liste.setItem(j + 1, liste.getItem(j));
         j--;
      }
      liste.setItem(j + 1, akt);
   }
   String text = "";
   for (int i = 0; i < liste.getLength(); i++) {
      text = text + ((Paket) liste.getItem(i)).getNutzdaten();
   }
   return text;
}

gA: TODO 5/6 in empfange eA: in empfange, ohne TODO-Nummer

Ziel: Am Ende von empfange (nach der Duplikatprüfung): Ist gesamt gleich 1, wird das Paket wie bisher verarbeitet. Sonst kommt es in den Puffer teile; bei Teil 1 wird teile vorher neu angelegt. Sind so viele Teile gesammelt, wie Gesamt angibt: zusammensetzen, verarbeiten, Puffer leeren. Fertig, wenn: die Schulfest-Bestellung mit LOOPBACK und dann mit setVerlust(20) zu zweit als eine Nachricht erscheint.

Hilfe 1: Duplikate kommen hier nicht mehr an – die hat die Duplikatprüfung vorher aussortiert.
Hilfe 2: Ein Puffer genügt, solange nur ein Sender gleichzeitig zerlegte Nachrichten schickt: Stop-and-Wait überträgt die Teile nacheinander.
Musterlösung
   // am Ende von empfange (nach der Duplikatprüfung):
   if (p.getGesamt() == 1) {
      verarbeite(p, p.getNutzdaten());
      return;
   }
   if (p.getTeil() == 1) {
      // neue Nachricht beginnt
      teile = new DynArray();
   }
   teile.append(p);
   if (teile.getLength() == p.getGesamt()) {
      String ganz = setzeZusammen(teile);
      teile = new DynArray();
      verarbeite(p, ganz);
   } else {
      println("   Teil " + p.getTeil() + "/" + p.getGesamt()
              + " gepuffert", Color.gray);
   }

Bricht der Sender bei einem Teil ab, bleibt der Puffer unvollständig; mit dem nächsten Teil 1 wird er verworfen.

Die Zentrale sendet Teile ohne zu warten nacheinander, mit setVerzoegerung(1500) – Teil 3 kann vor Teil 1 ankommen. Ändern Sie den Empfänger: Der Puffer wird nicht bei Teil 1 geleert, ein schon vorhandener Teil wird nicht noch einmal aufgenommen, und der Puffer bleibt nach Teilnummer sortiert (insertAt). Was passiert, wenn zwei Stationen gleichzeitig lange Nachrichten an Sie senden? Schlagen Sie eine Lösung vor.

Hilfe 1: Suchen Sie die erste Position mit größerer oder gleicher Teilnummer; gibt es keine, wird am Ende eingefügt (insertAt mit Index = Länge). Gleiche Teilnummer = Duplikat.
Musterlösung
private void nimmAuf(Paket p) {
   int i = 0;
   while (i < teile.getLength()
          && ((Paket) teile.getItem(i)).getTeil() < p.getTeil()) {
      i = i + 1;
   }
   if (i < teile.getLength()
       && ((Paket) teile.getItem(i)).getTeil() == p.getTeil()) {
      // Teil schon vorhanden: Duplikat
      return;
   }
   teile.insertAt(i, p);
   if (teile.getLength() == p.getGesamt()) {
      String ganz = setzeZusammen(teile);
      teile = new DynArray();
      verarbeite(p, ganz);
   }
}

Bei zwei Sendern landen Teile verschiedener Nachrichten im selben Puffer und werden vermischt. Lösung: je Absender ein eigener Puffer – als Attribut von Gegenstelle – oder ein Kopffeld „Nachrichtennummer“ (eine Formatänderung FN/2, die alle vereinbaren müssten). Ohne Quittungen fehlt ein verlorener Teil für immer.

Ausgezeichnet – Alle Aufgaben abgeschlossen!

Lange Nachrichten kommen vollständig an.

Sicherung

Definition: Fragmentierung

Bei der Fragmentierung wird eine Nachricht, die länger als die erlaubte Nutzdatenlänge ist, in nummerierte Teilpakete (Teil x von Gesamt) zerlegt. Der Empfänger sammelt sie und setzt sie nach der Teilnummer zusammen.

Merke

Jedes Paket kostet in FN/1 31 Verwaltungszeichen (Overhead). Zuverlässigkeit kostet zusätzlich Quittungen, Wartezeit und Wiederholungen. Teil/Gesamt genügen nur, weil Stop-and-Wait die Teile eines Senders nacheinander und ohne Duplikate liefert.

Plan-Check

Erstens: Prüfen Sie Ihre Festlegung zur Leitfrage. Welcher kritische Fall wird durch Stop-and-Wait abgefangen, welcher nicht?
Zweitens – Rückblick auf den ganzen Kern: Ergänzen Sie für jedes Problem aus dem Funkchaos, wodurch FN/1 und Ihre Station es lösen. Beantworten Sie damit die Leitfrage der Einheit.

Tabelle 6.1: Was das Liefernetz jetzt kann
Problem aus dem Funkchaos (Kap. 1)Lösung
„Ist das für mich?“, „Wer hat das gesendet?“
„Bestellung, Antwort oder Zahlung?“
„Ich – ich auch!“, „OK“ ohne Bezug
Bestellung doppelt
Adresse verfälscht
Bestellung verschwunden
Lange Bestellung abgeschnitten
Zahlungen für alle lesbar, Absender fälschbar

Wie es weitergeht: In den Abteilungen bekommt jede Gruppe eine Aufgabe im Liefernetz (Zentrale, Kurier, Kundenverzeichnis, Kasse, Funkstrecke, Bestellstatus, Logbuch). Die Nutzdaten erhalten dann feste Formate, z. B. eine Bestellung KKKKP Text (Kundennummer, Priorität, Bestelltext). Die Logik Ihrer Abteilung kommt in verarbeite.

Rückbezug: Die Großbestellung

Teil/Gesamt reichen nicht immer: Fehlt ein Teil, bleibt die Nachricht unvollständig; überholen sich Teile oder senden zwei Stationen gleichzeitig, mischt ein einfacher Puffer sie. Stop-and-Wait verhindert Überholen und Duplikate bei einem Sender; für mehrere Sender braucht man einen Puffer je Absender.

ProblemLösung
„Ist das für mich?“ / „Wer?“Empfänger und Absender im Kopf, Adressfilter (Kap. 3)
„Bestellung, Antwort oder Zahlung?“Typfeld (Kap. 2)
„OK“ ohne BezugSeq; Quittungen tragen die Seq (Kap. 5)
Bestellung doppeltDuplikaterkennung über Absender und Seq (Kap. 5)
Adresse verfälschtPrüfsumme, NAK (Kap. 4)
Bestellung verschwundenACK, Timeout, Wiederholung (Kap. 5)
abgeschnittenLängenfeld (Kap. 2), Fragmentierung (Kap. 6)
Zahlungen lesbar, Absender fälschbarnoch offen → Abteilung Kasse

Die Leitfrage der Einheit: Eindeutig wird die Verständigung durch ein gemeinsames Format, zuverlässig durch Prüfsumme, Quittungen und Wiederholung. Die Regeln legt eine Vereinbarung fest, die alle genau gleich umsetzen – ändert eine Station sie allein, versteht sie niemand mehr.

Checkpoint

Checkpoint_Kap6_Station_gA.java bzw. Checkpoint_Kap6_Station_eA.java – die vollständige Station. Sie ist der Ausgangspunkt aller Abteilungen.


Abteilungen: Überblick

Worum es geht: FN/1 bringt Pakete sicher ans Ziel – aber noch keine Pizza zur Kundschaft. → Sie teilen das Liefernetz in Abteilungen auf, vereinbaren, was in den Nutzdaten steht, und bauen jede Abteilung als eigene Station.

Einstieg: Die Probe vor dem ersten Abend

Störung im Liefernetz (Plenum)

Ihr Protokoll FN/1 funktioniert: Zwei Stationen tauschen Pakete aus, erkennen verfälschte Pakete an der Prüfsumme, quittieren mit ACK und wiederholen verlorene Pakete. Die Geschäftsleitung von Food Now! plant den ersten echten Abend mit dem Liefernetz. Bei der Probe hört der Lausch-Client Folgendes (Quittungen weggelassen):

19:02:11  KUNDE1 → ZENTRA  BST  00423 2xPIZZA,1xCOLA
19:02:14  KUNDE1 → ZENTRA  BST  08151 1xBURGER
19:02:19  ZENTRA → ALLE__  BST  2xPIZZA,1xCOLA liefern!!
19:02:20  ZENTRA → ALLE__  BST  1xBURGER auch!!
19:03:40  ZENTRA → ALLE__  STA  wo wohnt Kunde 0042?
19:09:12  KURIR1 → ALLE__  STA  welcher Weg??
19:21:55  KURIR1 → ALLE__  ZAH  19,50 EUR KUNDE 0042 KARTE
19:22:30  PIZPAR → ALLE__  ZAH  6,90 EUR KUNDE 0815 BAR
    // PIZPAR = Pizza Paradiso, die Konkurrenz
Mitschnitt Ü1: Probe des Liefernetzes

Die Zentrale weiß nicht, wo Kunde 0042 wohnt. Der eilige Burger (Priorität 1) wartet hinter der Pizza. Der Kurier hat keinen Stadtplan und findet den Rückweg nicht. Jede Station liest die Zahlungen mit, und die Konkurrenz meldet eine Zahlung, die es nie gab. Hinterher kann niemand sagen, wie lange die Lieferung gedauert hat.

Leitfrage: Welche Aufgaben muss das Liefernetz außer dem Transport von Paketen noch erledigen – und welche Stationen („Abteilungen“) braucht Food Now! dafür?

Nebenfragen:

  1. Welche Fachinhalte aus der Q-Phase helfen jeweils?
  2. Was müssen zwei Abteilungen miteinander vereinbaren, bevor sie programmieren?

Unser Plan

Sammeln Sie im Kurs in drei Spalten: Problem im Mitschnitt → zuständige Abteilung → offene Frage.

  • Gehen Sie den Mitschnitt Zeile für Zeile durch und notieren Sie zu jeder Zeile das Problem.
  • Fassen Sie Probleme zusammen, die dieselbe Abteilung lösen könnte. Geben Sie jeder Abteilung einen Namen und ein Rufzeichen mit genau sechs Zeichen.
  • Zeichnen Sie mit Pfeilen, welche Abteilung welcher anderen welche Pakete schickt.

  • Zentrale (Bestellungen verwalten), Kurier und Kartendienst (Weg finden), Kundenverzeichnis (Adressen), Kasse (Zahlungen verschlüsseln und buchen), Bestellstatus (Ablauf überwachen), Logbuch (Funkverkehr auswerten, Datenschutz), eA zusätzlich Funkstrecke (verrauschte Außenverbindung).
  • FN/1 regelt, wie Pakete transportiert werden. Was in den Nutzdaten steht (Adresse, Karte, Zahlung, Status), müssen die Abteilungen zusätzlich vereinbaren – ein Protokoll über dem Protokoll, die Anwendungsschicht.
  • Die genaue Aufteilung zeigt der Aufklapper „Die Abteilungen im Überblick“ unten.

So arbeiten die Abteilungen

Jede Gruppe (2–4 Personen) übernimmt eine Abteilung und baut sie als eigene Station. Im Go-Live arbeiten alle Stationen in einer gemeinsamen Sitzung zusammen.

Die Abteilungen im Überblick (erst nach der Kursdiskussion öffnen)
Tabelle Ü1: Abteilungen, Rufzeichen und Fachthemen
AbteilungRufzeichenAufgabe im LiefernetzFachthemen
ZentraleZENTRAnimmt Bestellungen an, fragt Adressen ab, verteilt AufträgeQueue, DynArray, Einfügesortierung; eA Vererbung, Fairness
KurierKURIR1 …, KARTE1holt den Stadtplan, fährt aus, kassiert, fährt zurück2D-Array, Stack, RLE, Huffman-Vergleich; eA Backtracking
KundenverzeichnisKUNDENbeantwortet Adressanfragenbinärer Suchbaum, Datenschutz; eA Löschen, Ausgleichen
KasseKASSE1entschlüsselt Zahlungen, führt das KassenbuchVigenère, bekannter Klartext; eA Diffie-Hellman, Signatur, RSA-Idee
Funkstrecke eARELAIS, AUSSENverbindet die Außenfiliale über eine verrauschte StreckeHamming(7,4), Huffman-Baum
BestellstatusSTATUSverfolgt jede Bestellung, warnt bei unzulässigen AbläufenMealy-Automat, DEA; eA Grammatik, Kellerautomat
LogbuchLOGBUCrichtet die Datenbank ein, wertet aus, wacht über den DatenschutzSQL, Datenschutz; eA ER-Modell, PreparedStatement

Dazu kommen Stationen der Lehrkraft: KUNDE1 (die Kundschaft), der Lausch-Client am Beamer und im eA-Go-Live die Konkurrenz PIZPAR.

Tabelle Ü2: Was die Abteilungen voneinander brauchen
Abteilungbraucht von …liefert an …
ZentraleKundenverzeichnis: Lage der Adresse (ADR); Kurier: Meldung „frei“ (POS); eA Bestellstatus: Prüfung von BestelltextenKundenverzeichnis: Anfrage; Kurier: Lieferauftrag (BST); alle: STA mit ANN, KOC, STO; eA Funkstrecke: Aufträge für Hasbergen
KurierZentrale: Lieferauftrag; Kartendienst: Stadtplan (KRT); Kasse: Zahlungsformat, Schlüssel, Klasse ZahlungZentrale: POS; Kasse: ZAH; alle: STA mit ABH, LIE
KundenverzeichnisZentrale: Anfrageformat; Lehrkraft: KundenlisteZentrale: Lage der Lieferadresse
KasseKurier: ZAH im vereinbarten Format; eA KEY-AustauschKurier: Schlüsselregel, Klassen Kasse und Zahlung
Funkstrecke eAZentrale: Aufträge für Hasbergenalle: STA mit ABH, LIE der Außenfiliale
BestellstatusZentrale, Kurier: STA mit den vereinbarten Codesalle: Anzeigetafel, Warnungen; eA Zentrale: Klasse Bestellstatus
Logbuchalle: Einträge in die Tabelle logbuchalle: Datenbank, Zugangscode, Datenschutzregeln, Auswertung
Tabelle Ü3: Ablauf einer Bestellung im Go-Live (Normalfall, ohne Quittungen)
Nr.Von → AnTypNutzdatenBedeutung
0KURIR1 → KARTE1KRT(leer)Kurier fordert den Stadtplan an
0KARTE1 → KURIR1KRTKartenzeilen, RLEStadtplan
0KURIR1 → ZENTRAPOSlaut VertragKurier steht an der Zentrale und ist frei
1KUNDE1 → ZENTRABST00423 2xPIZZA,1xCOLAKunde 0042, Priorität 3, Bestelltext
2ZENTRA → ALLE__STA017ANNBestellung 017 angenommen
3ZENTRA → KUNDENADRlaut VertragWo wohnt Kunde 0042?
4KUNDEN → ZENTRAADRlaut VertragLage im Stadtplan
5ZENTRA → ALLE__STA017KOCwird gekocht, wartet auf einen Kurier
6ZENTRA → KURIR1BSTlaut VertragLieferauftrag
7KURIR1 → ALLE__STA017ABHabgeholt
8KURIR1 → ALLE__STA017LIEgeliefert
9KURIR1 → KASSE1ZAHlaut VertragZahlung, verschlüsselt
10KURIR1 → ZENTRAPOSlaut Vertragzurück und wieder frei

„Laut Vertrag“ heißt: Dieses Format entwirft Ihr Kurs selbst in der Schnittstellenkonferenz.

Wahl der Abteilung

  1. Abteilungsmarkt: Lesen Sie die Kurzsteckbriefe (Tabelle Ü4). Die Sterne zeigen den Programmieranteil.
  2. Wahlzettel: Jede Gruppe gibt einen Erst-, Zweit- und Drittwunsch mit je einem Satz Begründung ab.
  3. Zuteilung durch die Lehrkraft: Jede Pflichtabteilung wird genau einmal besetzt (gA: Zentrale, Kurier, Kundenverzeichnis, Kasse, Bestellstatus, Logbuch; eA zusätzlich Funkstrecke). Nur so braucht der Kurs alle Themen der Q-Phase. Weitere Gruppen werden weitere Kurier-Gruppen (KURIR2, KURIR3).
  4. Rollen in der Gruppe (Wechsel an jedem Meilenstein): Protokollverantwortliche/r (führt das Protokollblatt, vertritt die Gruppe in der Schnittstellenkonferenz), Modulentwickler/in (Fachalgorithmus), Stationsentwickler/in (Anbindung, Test). Jede Person muss am Ende jeden Teil erklären können.
Tabelle Ü4: Kurzsteckbriefe für den Abteilungsmarkt
AbteilungProblem in einem SatzFachthemenAnspruch
ZentraleDer eilige Burger wartet hinter der Pizza, Antworten gehen durcheinander.Queue, DynArray, Sortieren★★★
KurierDer Stadtplan braucht neun Pakete, und Kim findet nicht zurück.2D-Array, Stack, RLE, Huffman★★☆
Kundenverzeichnis4 000 Kunden in einer Liste, und Pizza Paradiso hört Namen mit.Suchbaum, Rekursion, Datenschutz★★☆
KasseAlle lesen die Zahlungen mit – auch verschlüsselt.Vigenère, Kryptoanalyse★★☆
Funkstrecke eAJedes hundertste Bit kippt, Wiederholen hilft nicht.Hamming, Huffman, Binärbaum★★★
Bestellstatus„Geliefert“, bevor „abgeholt“ – und niemand merkt es.Mealy-Automat, DEA★★☆
LogbuchWer hat recht – und was darf das Logbuch speichern?SQL, Datenschutz★★☆

Meilensteine

Die Schnittstellenkonferenz

Erst plant jede Gruppe ihre Abteilung (Einstieg, Plan-Ticket, erster Entwurfsteil). Dann trifft sich der Kurs. Jede Gruppe bringt einen Angebotszettel mit: Welche Pakettypen bietet sie an, welche braucht sie? Für jedes angebotene Paket: Format v0.1 als Formattabelle mit einem Beispiel.

Tabelle Ü5: Für alle fest vorgegeben
WasFestlegung
PaketformatFN/1 (Kopf 28 Zeichen, höchstens 60 Zeichen Nutzdaten, Prüfsumme mod 1000), messageType immer "FN1"; Rundrufe an ALLE__ werden nicht quittiert
Bestellungen von KUNDE1 (BST)KKKKP Text: Position 0–3 Kundennummer, Position 4 Priorität (1 = eilig … 3 = normal; eA 0 = Medikament), Position 5 Leerzeichen, ab Position 6 Bestelltext
BestelltextPositionen durch Komma getrennt, je Position Anzahl (1–9), x, Gericht in Großbuchstaben, z. B. 2xPIZZA,1xCOLA; nur ASCII, keine Umlaute. eA Menüs mit verschachtelten Klammern, z. B. 1xMENUE(PIZZA(SALAMI,KAESE),COLA)
Stadtplan (KRT)Anforderung mit leeren Nutzdaten; Antwort: Kartenzeilen mit / verbunden, dann lauflängencodiert (Anzahl-Wert)
Statusmeldungen (STA)an ALLE__; NNNCCC: dreistellige Bestellnummer, dann Code ANN angenommen, KOC in Zubereitung, ABH abgeholt, LIE geliefert, STO storniert; z. B. 017LIE
Bestellnummernvergibt die Zentrale, dreistellig 001–999
SitzungscodesFN-<Kurs>-<Gruppe> für Gruppentests, FN-<Kurs>-TEST für Tests mit den Ersatzstationen der Lehrkraft, FN-<Kurs>-LIVE fürs Go-Live

Bedingungskarten

Jede Gruppe erhält eine von zwei (Kurier: drei) Bedingungskarten ihrer Abteilung. Die Bedingungen sorgen dafür, dass Sie nicht nachbauen, sondern selbst entwerfen: Sie planen eine Lösung, die genau diese Bedingungen erfüllt, und begründen Ihre Entscheidungen im Protokollblatt. Ihre Karte steht im Kapitel Ihrer Abteilung.

Schnittstelle zur Station

Alle Abteilungen bauen auf der Station aus dem Kern auf. Die Abteilungsarbeit steckt in eigenen Modulklassen (z. B. Zentrale, Kurier), die Sie zuerst ohne Netz testen, und in der Methode verarbeite der Station.

Checkpoint

Für die Abteilungsphase starten alle mit dem Checkpoint vom Ende des Kerns (Kapitel 6, Datei Station.java). Sie erkennt Duplikate je Absender. Ein einziges Paar letzterAbsender/letzteSeq reicht nur bei einem Gesprächspartner – im Go-Live spricht die Zentrale mit vielen.

Tabelle Ü6: Was Sie von der Station brauchen
ElementBedeutung
Hauptprogramm: rufzeichen, session, datenbankRufzeichen (genau 6 Zeichen), Sitzungscode ("LOOPBACK" zum Alleintesten), Zugangscode der Logbuch-Datenbank
c Station(rufzeichen: Zeichenkette, datenbankCode: Zeichenkette)Station erzeugen; verbinden mit starte(sessionCode) (gA) bzw. verbinde(sessionCode) (eA)
– verarbeite(p: Paket, text: Zeichenkette)wird für jedes gültige Datenpaket an diese Station oder an ALLE__ aufgerufen; text sind die vollständigen Nutzdaten (Teile zusammengesetzt, Quittung und Duplikaterkennung erledigt). Hier ergänzt jede Abteilung ihre Logik
gA: + sende(empfaenger: Zeichenkette, typ: Zeichenkette, text: Zeichenkette): Wahrheitswertsendet zuverlässig und wartet auf die Quittung; false nach 5 erfolglosen Versuchen
eA + sende(empfaenger: Zeichenkette, typ: Zeichenkette, text: Zeichenkette)legt die Pakete in den Sendepuffer und kehrt sofort zurück; bricht ein Paket ab, ruft die Station abgebrochen(p: Paket) auf (dort ergänzen Sie, was dann passieren soll)
Paket: getAbsender(), getEmpfaenger(), getTyp(), getSeq(), getNutzdaten()Zugriff auf die Felder
Achtung

Die ADT-Klassen der Online-IDE sind nicht generisch (Bibliothek „Abiturklassen Niedersachsen“ im Workspace einschalten). Man schreibt DynArray liste = new DynArray(); und liest mit Typumwandlung: Bestellung b = (Bestellung) liste.getItem(0);.

Warum? synchronized in verarbeite

In der gA-Station blockiert sende den aufrufenden Thread, bis die Quittung da ist, und es gibt nur ein Quittungsfach. Kommen zwei Pakete fast gleichzeitig an, laufen zwei Aufrufe von verarbeite in zwei Threads. Senden beide, holt sich womöglich der eine Thread die Quittung des anderen. private synchronized void verarbeite(Paket p, String text) sorgt dafür, dass immer nur ein Thread darin arbeitet. empfange bleibt ohne synchronized: Sonst würden eingehende Pakete während eines langen sende nicht quittiert.

eA Ihre Station sendet über einen Sendepuffer und blockiert nicht. sende und verarbeite dürfen synchronized sein – dann darf in verarbeite aber kein Thread.sleep stehen, sonst warten auch die eigenen Quittungen. Wartezeiten (z. B. eine simulierte Fahrt) erzeugen Sie mit Timer.executeLater(() -> …, ms).

Wenn nichts ankommt

Prüfen Sie der Reihe nach, bevor Sie Ihren Code verdächtigen:

  1. Sind beide Stationen in der Online-IDE angemeldet und im selben Sitzungscode?
  2. Hat jede Station ein eigenes Rufzeichen mit genau sechs Zeichen?
  3. Steht demo so, wie Sie es brauchen? Ist der Geschwindigkeitsregler auf Maximum?
  4. Kommt das Paket beim Lausch-Client an? Wenn nein: Senden prüfen. Wenn ja: Adressfilter und Typ beim Empfänger prüfen.
  5. Wird verarbeite aufgerufen? Eine Ausgabe in der ersten Zeile von verarbeite zeigt es.
  6. Passen die Nutzdaten zum Schnittstellenvertrag (Positionen, Längen)?

Ist Ihre Partnerabteilung noch nicht so weit, testen Sie gegen die Ersatzstationen der Lehrkraft im Sitzungscode FN-<Kurs>-TEST. Sie arbeiten mit den Referenzformaten (Plan B).

Welche Themen braucht der Kurs?

Tabelle Ü7: Q-Phase-Themen im Liefernetz
Themagebraucht in …zusätzlich eA
Objektorientierungalle Abteilungen (Modulklassen, Assoziation Station – Modul)Vererbung (Zentrale; Station extends WebSocket)
2D-Array, SortierenKurier, ZentraleLaufzeitvergleich (Zentrale, Kundenverzeichnis)
Queue, Stack, DynArrayZentrale, Kurier, Kasse, BestellstatusTiefensuche (Kurier), Kellerautomat (Bestellstatus)
Binärbaum, SuchbaumKundenverzeichnisLöschen; Huffman-Baum (Funkstrecke)
KryptologieKasse (Vigenère, Angriff)Diffie-Hellman, Signatur, RSA-Idee (Kasse)
CodierungKern (Prüfsumme, Hamming), Kurier (RLE, Huffman)Hamming und Huffman auf Bitebene (Funkstrecke)
Automaten, SprachenBestellstatus (Mealy, DEA)Mealy-Sender (Kern), Grammatik, Kellerautomat
DatenbankenLogbuch; Go-Live-Auswertung für alleER-Modell, PreparedStatement (Logbuch)
DatenschutzKundenverzeichnis, Logbuch, KernRecht auf Löschung, Metadaten

Protokollblatt und Bewertung

Das Protokollblatt ist das wichtigste Produkt Ihrer Gruppe. Es beschreibt Ihre Abteilung so, dass eine andere Gruppe ohne Ihren Quelltext eine passende Station bauen könnte. Sie beginnen es im Einstieg (v0.1) und führen es bis nach dem Go-Live weiter.

Tabelle Ü8: Protokollblatt (Vorlage)
AbschnittInhalt
1 KopfAbteilung, Gruppe, Mitglieder mit Rolle, Rufzeichen, Bedingungskarte, Version und Datum
2 Aufgabe und Pakettypen2–3 Sätze zum Problem der Abteilung; Tabelle: Typ, sendet/empfängt, Partner, quittiert ja/nein
3 Nutzdatenformateje Format eine Formattabelle (Position, Länge, Inhalt, Wertebereich, Beispiel), auch für Fehlermeldungen; Kennzeichnung „eigener Entwurf“ oder „Plan B übernommen, weil …“
4 AbläufeSequenzdiagramm für den Normalfall und mindestens zwei Fehlerfälle; bei Automaten der Zustandsgraph
5 Datenstrukturen und AlgorithmenKlassendiagramm, Struktogramm des wichtigsten Algorithmus, verwendete ADT mit Begründung
6 Entscheidungen und Bedingungenmindestens drei (eA: vier) Entscheidungen: Entscheidung – Alternative – Begründung; je Bedingung der Karte: wie erfüllt, wie geprüft
7 TestsSelbsttest, Schnittstellentest, Go-Live: Testfall – erwartet – beobachtet – Ursache
8 Go-LiveKennzahlen mit SQL-Abfrage; die zwei wichtigsten Fehler mit Beleg und Verbesserung
9 eA Datenschutz und SicherheitWelche Daten verarbeitet die Station? Was ist geschützt, was nicht?
10 VersionenÄnderung – Grund – Datum – zugestimmt von

Bewertung (Ausgabe zu Beginn der Abteilungsphase). Bewertet werden die Operatoren entwerfen („nach vorgegebenen Bedingungen ein Modell oder einen Algorithmus selbstständig planen und erarbeiten“) und implementieren („einen Algorithmus oder eine Datenstruktur erarbeiten und codieren“). Teile A–F sind Gruppenleistung, Teil G ist Ihre Einzelleistung.

Tabelle Ü9: Bewertungskriterien
KriteriumgAeAVoll erfüllt, wenn …
A1 Nutzdatenformate108jede Formattabelle mit Wertebereich und passendem Beispiel, auch für Fehlerfälle; mit allen Partnern unterschrieben
A2 Entwurfsbedingungen87jede Bedingung nachweislich erfüllt; die Lösung folgt erkennbar aus Ihren Bedingungen. Plan B ist erlaubt, wenn gekennzeichnet und gegen eine Alternative begründet
A3 Abläufe und Algorithmen65Sequenzdiagramm mit zwei Fehlerfällen, Klassendiagramm, Struktogramm (bzw. vollständiger Automat)
A4 Begründete Entscheidungen65Entscheidungen mit Alternative und fachlicher Begründung (Rechnung, Messung, Datenschutz); Grenzen benannt
B1 Fachalgorithmus107vollständig und korrekt, Selbsttest auch für Randfälle bestanden
B2 Abiturkonform75nur erlaubte String-Operationen, ADT mit Abitur-Signaturen, keine Laufzeitfehler (isEmpty, Indexgrenzen, Ziffernprüfung)
B3 Anbindung86verarbeite reagiert auf alle vereinbarten Pakete genau nach Vertrag; die Station stürzt nie ab
B4 Codequalität54Modul ohne Netz testbar, sprechende Namen, Kommentare mit Verweis aufs Protokollblatt
C1 Tests85mindestens sechs Testfälle mit Rand- und Fehlerfällen, Soll – Ist – Ursache
C2 Fehleranalyse Go-Live75zwei Probleme mit SQL-Beleg, Kategorie, Verbesserung
D1 Betrieb im Go-Live65Startcheck und Rauchtest, Absprachen eingehalten
D2 Auswertung43Kennzahlen per SQL bestimmt und gedeutet
E eA Erweiterung–10eA-Aufgaben entworfen, implementiert, getestet, beurteilt
F eA Präsentation und Reflexion–10eine Entscheidung überzeugend begründet, Beleg, differenzierte Reflexion
G Kolloquium (einzeln)1515Sie erklären jeden Teil Ihrer Abteilung und beantworten „Was passiert, wenn …?“

Grundsätze: Übernommener Code (Gerüste, Plan B) ist erlaubt, muss aber gekennzeichnet sein. Störungen durch andere Gruppen im Go-Live gehen nicht zu Ihren Lasten, wenn Sie sie im Fehlerprotokoll belegen. Fällt Ihre Station im Go-Live aus, übernimmt die Lehrkraft mit einer Ersatzstation; Sie analysieren den Fehler im Fehlerprotokoll. Bei deutlich ungleichen Beiträgen können die Gruppenpunkte für Einzelne angepasst werden; Grundlage ist unter anderem eine kurze anonyme Beitragsrückmeldung, die regelmäßig eingeholt wird.

Kolloquium: Gruppengespräch (gA nach dem Go-Live, eA in der Präsentation). Jedes Gruppenmitglied zieht eine von drei Fragekarten; vorbereitet sein müssen also alle. Fragetypen: „Was passiert, wenn … verloren geht / doppelt kommt / gefälscht ist?“, „Zeigen Sie im Code, wo …“, „Warum haben Sie … und nicht … gewählt?“, dazu eine Frage zum Kern (z. B. „Was passiert, wenn das ACK zu Ihrem Paket verloren geht?“).

Selbstcheck vor der Abgabe


Abteilung Zentrale

Worum es geht: Bestellungen kommen schneller, als Adressen und Kuriere bereitstehen. → Die Zentrale merkt sich jede Bestellung in einer Schlange, sortiert die ausliefbaren nach Dringlichkeit und vergibt sie an freie Kuriere.

Einstieg: Wo bleibt mein Burger?

Störung im Liefernetz (Gruppenarbeit)

Freitag, 19:30 Uhr. Die alte Zentrale arbeitet „einfach alles sofort ab“. Der Lausch-Client zeigt (Quittungen weggelassen):

19:30:02  KUNDE1 → ZENTRA  BST  00423 2xPIZZA,1xCOLA
19:30:05  KUNDE1 → ZENTRA  BST  08151 1xBURGER
19:30:06  KUNDE1 → ZENTRA  BST  00073 3xPASTA
19:30:07  ZENTRA → KUNDEN  ADR  wo wohnt 0042?
19:30:07  ZENTRA → KUNDEN  ADR  wo wohnt 0815?
19:30:08  ZENTRA → KUNDEN  ADR  wo wohnt 0007?
19:30:09  KUNDEN → ZENTRA  ADR  Zeile 5, Spalte 30
19:30:10  KUNDEN → ZENTRA  ADR  Zeile 3, Spalte 20
19:30:10  KUNDEN → ZENTRA  ADR  Zeile 1, Spalte 6
19:30:11  ZENTRA → KURIR1  BST  3xPASTA, Zeile 5, Spalte 30
    // danach ist KURIR1 wieder frei – und wartet
19:58:40  KUNDE1 → ZENTRA  BST  08151 WO BLEIBT MEIN BURGER?
Mitschnitt Z1: Freitagabend in der alten Zentrale

Die Pasta kam zuletzt und wurde zuerst geliefert. Die Antworten des Kundenverzeichnisses kamen alle an – aber drei Anfragen waren gleichzeitig offen, und die Zentrale konnte keine Antwort sicher einer Bestellung zuordnen. Den eiligen Burger (Priorität 1) hat sie dabei vergessen. Und obwohl KURIR1 nach der Pasta längst wieder frei war, wartet die Pizza noch.

Leitfrage: In welcher Reihenfolge soll die Zentrale Bestellungen ausliefern lassen – und was muss sie sich merken, während eine Bestellung auf ihre Adresse oder auf einen Kurier wartet?

Nebenfragen:

  1. Gibt es mehr als eine sinnvolle Reihenfolge?
  2. Welche Datenstrukturen aus dem Unterricht verhalten sich so, wie die Zentrale es braucht?

Unser Plan

Sammeln Sie in der Gruppe: Problem → Idee → offene Frage.

  • Spielen Sie die Situation mit Karteikarten nach: Jede Bestellung ist eine Karte. Wo liegen die Karten, solange die Adresse fehlt? Wo, wenn die Adresse da ist, aber kein Kurier?
  • Formulieren Sie für jeden „Kartenstapel“ eine Regel: Wo kommt eine Karte hinzu, wo wird sie entnommen?
  • Mit welchen Abteilungen müssen Sie ein Nutzdatenformat vereinbaren?

Tragen Sie den Plan als Protokollblatt v0.1 ein (Abschnitte 2, 3 und 6) und zeigen Sie ihn der Lehrkraft (Plan-Ticket). Danach beginnt Aufgabe 1.

Bedingungskarte Z-a
  1. Dringendere Bestellungen (kleinere Priorität) zuerst, bei gleicher Priorität gilt die Eingangsreihenfolge.
  2. Der Lieferauftrag enthält alles, was der Kurier für Weg und Kasse braucht – aber weder Kundennummer noch Adresse.
  3. Es ist immer nur eine Adressanfrage unterwegs.
  4. Die Zentrale meldet ANN, KOC und STO an ALLE__.
  5. eA Keine Bestellung verhungert: Wer dreimal übergangen wurde, rückt eine Prioritätsstufe auf.
Bedingungskarte Z-b
  1. Dringendere Bestellungen zuerst, bei gleicher Priorität gilt die Eingangsreihenfolge.
  2. Den Auftrag bekommt der nächstgelegene freie Kurier (Abstand = Zeilenunterschied + Spaltenunterschied).
  3. Der Lieferauftrag enthält weder Kundennummer noch Adresse, aber den Betrag in Cent – der Kurier braucht keine Preisliste.
  4. Es ist immer nur eine Adressanfrage unterwegs; die Zentrale meldet ANN, KOC und STO.
  5. eA Keine Bestellung verhungert: Wer dreimal übergangen wurde, rückt eine Prioritätsstufe auf.

Aufgaben: Die Zentrale entwerfen

Entwerfen Sie den Ablauf in der Zentrale und die Schnittstellen zu den anderen Abteilungen. Halten Sie alles im Protokollblatt fest.

Ihr Bearbeitungsfortschritt:0%
Aufgabe 1 (Gruppenarbeit): Ablauf und Schnittstellen

Material: Ihre Bedingungskarte, Bestellformat KKKKP Text, Tabelle Ü3 (Ablauf einer Bestellung im Go-Live).

Zeichnen Sie ein Sequenzdiagramm für eine Bestellung aus Sicht der Zentrale: alle Pakete, die die Zentrale empfängt und sendet, mit Typ und den Angaben, die darin stehen müssen. Ergänzen Sie drei Sonderfälle: (1) Die Bestellung ist unlesbar. (2) Der Kunde ist unbekannt. (3) Kein Kurier ist frei, als die Adresse eintrifft.

Hilfe 1: Senkrechte Linien für KUNDE1, ZENTRA, KUNDEN, KURIR1 und ALLE__; die Zeit läuft nach unten. Quittungen dürfen Sie weglassen, die erledigt der Kern.
Hilfe 2: Beginnen Sie mit BST von KUNDE1. Was muss die Zentrale danach sofort tun, was erst später? Welche Pakete lösen bei der Zentrale eine Reaktion aus?
Hilfe 3: Im Sonderfall (3) passiert beim Eintreffen der Adresse nur etwas in der Zentrale selbst. Das Vergeben löst erst ein anderes Paket aus – welches?

Entwerfen Sie (1) das Format der Adressanfrage und klären Sie mit dem Kundenverzeichnis, wie dessen Antwort aussieht, und (2) das Format des Lieferauftrags gemeinsam mit den Kurier-Gruppen. Geben Sie je eine Formattabelle (Position, Länge, Inhalt, Wertebereich, Beispiel) an und begründen Sie sie mit Ihrer Bedingungskarte.

Hilfe 1: Was braucht der Kurier, um den Weg zu finden? Was braucht er, um zu kassieren? Was braucht er nicht?
Hilfe 2: Feste Feldbreiten wie im FN/1-Kopf erlauben das Zerlegen mit substring. Damit die Zentrale eine Antwort ihrer Anfrage zuordnen kann, sollte in Anfrage und Antwort dieselbe Kennung stehen – welche?
Hilfe 3: Ein langer Bestelltext ist kein Problem: Der Kern zerlegt lange Nutzdaten in mehrere Pakete.

Das Klassendiagramm in Aufgabe 3 ist vorgegeben. Ergänzen Sie es um alles, was Ihre Bedingungskarte zusätzlich verlangt (Karte Z-b: Positionen der freien Kuriere), und begründen Sie Ihre Wahl der Datenstruktur.

Aufgabe 2 (Partnerarbeit): Die Verwaltung von Hand

Material: Ereignisse in dieser Reihenfolge (Bestellnummern ab 001; jede Adressantwort gehört zur gerade angefragten Bestellung).

Tabelle Z1: Ereignisse in der Zentrale
Nr.Ereignis
1BST 00423 2xPIZZA,1xCOLA
2BST 08151 1xBURGER
3BST 00073 3xPASTA
4Adresse zu 001
5BST 12001 1xSALAT
6Adresse zu 002
7Adresse zu 003
8BST 03503 2xPOMMES
9Adresse zu 004
10Adresse zu 005

Die Zentrale verwaltet zwei „Kartenstapel“: Bestellungen ohne Adresse warten in einer Warteschlange, Bestellungen mit Adresse in einer nach Dringlichkeit sortierten Auftragsliste.

Geben Sie nach jedem Ereignis den Inhalt der Eingangsschlange an (vorn links) und notieren Sie, wann welche Adressanfrage gesendet wird. Geben Sie außerdem nach jeder Adressantwort die Auftragsliste an (Position 0 links, Schreibweise Nummer/Priorität), wenn noch kein Kurier frei ist. In welcher Reihenfolge wird ausgeliefert, wenn danach ein Kurier nacheinander alle übernimmt?

Hilfe 1: enqueue bei jeder neuen Bestellung, dequeue bei jeder Adressantwort. Eine Anfrage geht hinaus, wenn eine Bestellung in eine leere Schlange kommt oder wenn nach einem dequeue noch etwas in der Schlange steht.
Hilfe 2: In der Auftragsliste wandert die neu angehängte Bestellung nach vorn, solange sie dringender ist als ihr linker Nachbar – wie bei der Einfügesortierung im Kern.

Stellen Sie die Operation sortiere() (Einfügesortierung auf der dynamischen Reihung liste) auf Papier als Struktogramm dar. Nutzen Sie nur getLength, getItem, setItem und istDringenderAls.

Hilfe 1: Eine äußere Zählschleife läuft über i ab 1; das Element an Position i wird in akt gemerkt.

Hilfe 2: Ergänzen Sie die Lücken:

für i von 1 bis liste.getLength() − 1
akt ← liste.getItem(i)
j ← i − 1
solange j ≥ 0 und ____
liste.setItem(____, liste.getItem(j))
j ← j − 1
liste.setItem(____, akt)
Struktogramm Z1: sortiere()
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Ihr Entwurf steht. Prüfen Sie ihn, bevor Sie programmieren:

Aufgaben: Die Zentrale programmieren

Implementieren Sie die Klassen Bestellung und Zentrale als eigene Datei Zentrale.java und testen Sie sie ohne Netz (Bibliothek „Abiturklassen Niedersachsen“ einschalten).

Ihr Bearbeitungsfortschritt:0%
Aufgabe 3 (Partnerarbeit): Bestellung und Zentrale implementieren

Material: Klassendiagramm, Selbsttest und Gerüst der Datei Zentrale.java. Tragen Sie vor dem Programmieren in den Selbsttest die erwarteten Werte aus Ihrem Schnittstellenvertrag ein („test first“).

// ---- Selbsttest (Hauptprogramm) ----
Zentrale z = new Zentrale();
int n1 = z.neueNummer();
z.nimmAn(Bestellung.ausText("00423 2xPIZZA,1xCOLA", n1));
int n2 = z.neueNummer();
z.nimmAn(Bestellung.ausText("08151 1xBURGER", n2));
// erwartet: true (an Position 5 fehlt das Leerzeichen)
println(Bestellung.ausText("00423Pizza", 9) == null);

// Beispiele aus Ihrem Schnittstellenvertrag eintragen:
// Antwort "Kunde unbekannt" zu Bestellung 1
String unbekannt1 = "________";
// Antwort zu Bestellung 1: Kunde wohnt in Zeile 1, Spalte 6
String antwort1 = "________";
// Antwort zu Bestellung 2: Kunde wohnt in Zeile 3, Spalte 20
String antwort2 = "________";

// erwartet laut Protokollblatt: ________
println(z.adressanfrage());
// erwartet: false (Antwort gehört nicht zur vordersten)
println(z.adresseEingetroffen(antwort2));
// erwartet: false (Kunde unbekannt)
println(z.adresseEingetroffen(unbekannt1));
// erwartet: true
println(z.adresseEingetroffen(antwort1));
// erwartet laut Protokollblatt: ________
println(z.adressanfrage());
// erwartet: true
println(z.adresseEingetroffen(antwort2));
// erwartet: erst Nr 2 (Prio 1), dann Nr 1
z.zeigeListe();
z.kurierFrei("KURIR1");
Bestellung b = z.naechsteBestellung();
String k = z.naechsterKurier();
// erwartet laut Protokollblatt: KURIR1 ________
println(k + " " + z.lieferauftrag(b));
Listing Z1: Selbsttest in Zentrale.java
Gerüst der Klassen Bestellung und Zentrale anzeigen
class Bestellung {
   private int kundennr;
   // 1 = eilig ... 3 = normal
   private int prioritaet;
   // Eingangsnummer = Bestellnummer
   private int zeit;
   private String text;
   private int zeile = -1;
   private int spalte = -1;

   public Bestellung(int kundennr, int prioritaet, int zeit,
                     String text) {
      this.kundennr = kundennr;
      this.prioritaet = prioritaet;
      this.zeit = zeit;
      this.text = text;
   }

   // liest "KKKKP Text"; null, wenn das Format nicht stimmt
   public static Bestellung ausText(String s, int zeit) {
      // TODO Teil a
      return null;
   }

   // kommt diese Bestellung vor der anderen dran?
   public boolean istDringenderAls(Bestellung andere) {
      // TODO Teil a
      return false;
   }

   public void setZiel(int zeile, int spalte) {
      this.zeile = zeile;
      this.spalte = spalte;
   }

   public String alsText() {
      return "Kunde " + kundennr + ", Prio " + prioritaet
             + ", Nr " + zeit + ": " + text;
   }

   public int getKundennr() { return kundennr; }
   public int getPrioritaet() { return prioritaet; }
   public int getZeit() { return zeit; }
   public String getText() { return text; }
   public int getZeile() { return zeile; }
   public int getSpalte() { return spalte; }
}

class Zentrale {
   // Feldpositionen Ihres ADR-Antwortformats
   // TODO Teil b: Werte laut Schnittstellenvertrag eintragen
   private int ANTWORT_LAENGE = 0;
   private int POS_NR = 0;
   private int POS_ZEILE = 0;
   private int POS_SPALTE = 0;

   // Bestellungen, die auf ihre Adresse warten
   private Queue eingang = new Queue();
   // Adresse bekannt, dringendste vorn
   private DynArray liste = new DynArray();
   // Rufzeichen der freien Kuriere
   private DynArray freieKuriere = new DynArray();
   private int naechsteNr = 1;

   public int neueNummer() {
      int nr = naechsteNr;
      // 1 ... 999, dann wieder 1
      naechsteNr = naechsteNr % 999 + 1;
      return nr;
   }

   public void nimmAn(Bestellung b) {
      if (b == null) {
         println("Bestellung unlesbar!", Color.orange);
         return;
      }
      eingang.enqueue(b);
   }

   // Anfrage für die vorderste Bestellung; "" bei leerer Schlange
   public String adressanfrage() {
      // TODO Teil b
      return "";
   }

   // false, wenn die Antwort nicht zur vordersten Bestellung
   // passt oder unlesbar ist
   public boolean adresseEingetroffen(String text) {
      // TODO Teil b
      return false;
   }

   // steht vorn in der Schlange die Bestellung mit dieser Nummer?
   public boolean vordersteHatNr(String nrText) {
      if (eingang.isEmpty()) {
         return false;
      }
      Bestellung b = (Bestellung) eingang.head();
      return mitNullen(b.getZeit(), 3).equals(nrText);
   }

   public Bestellung verwerfeVorderste() {
      if (eingang.isEmpty()) {
         return null;
      }
      return (Bestellung) eingang.dequeue();
   }

   // Einfügesortierung: dringendste Bestellung nach vorn
   public void sortiere() {
      // TODO Teil c
   }

   public Bestellung naechsteBestellung() {
      if (liste.isEmpty()) {
         return null;
      }
      Bestellung b = (Bestellung) liste.getItem(0);
      liste.delete(0);
      return b;
   }

   // Auftrag zurück in die Liste, z. B. Kurier nicht erreichbar
   public void nimmAnZurueck(Bestellung b) {
      liste.append(b);
      sortiere();
   }

   public void kurierFrei(String rufzeichen) {
      freieKuriere.append(rufzeichen);
   }

   public boolean kannVergeben() {
      return !liste.isEmpty() && !freieKuriere.isEmpty();
   }

   public String naechsterKurier() {
      if (freieKuriere.isEmpty()) {
         return "";
      }
      String k = (String) freieKuriere.getItem(0);
      freieKuriere.delete(0);
      return k;
   }

   // Lieferauftrag im Format laut Schnittstellenvertrag
   public String lieferauftrag(Bestellung b) {
      // TODO Teil c
      return "";
   }

   public void zeigeListe() {
      println("--- offene Bestellungen: " + liste.getLength()
              + " ---", Color.aquamarine);
      for (int i = 0; i < liste.getLength(); i++) {
         Bestellung b = (Bestellung) liste.getItem(i);
         println((i + 1) + ". " + b.alsText());
      }
   }

   public String mitNullen(int zahl, int stellen) {
      String s = "" + zahl;
      while (s.length() < stellen) {
         s = "0" + s;
      }
      return s;
   }

   // Ziffernfolge -> Zahl; -1, wenn ein Zeichen keine Ziffer ist
   public int zahlAus(String s) {
      int wert = 0;
      for (int i = 0; i < s.length(); i++) {
         char c = s.charAt(i);
         if (c < '0' || c > '9') {
            return -1;
         }
         wert = wert * 10 + ((int) c - 48);
      }
      return wert;
   }
}
Listing Z2: Gerüst der Klassen Bestellung und Zentrale

Ziel: ausText und istDringenderAls arbeiten nach Vorgabe. Fertig, wenn: Die Zeile mit ausText("00423Pizza", 9) gibt true aus.

Implementieren Sie ausText (Format KKKKP Text: vier Ziffern Kundennummer, Priorität 1–3, an Position 5 ein Leerzeichen, sonst null) und istDringenderAls (kleinere Priorität zuerst, bei Gleichstand die kleinere Eingangsnummer).

Hilfe 1: Wie haben Sie im Kern mit zahlAus geprüft, ob ein Zahlenfeld nur Ziffern enthält? Wie lang muss eine gültige Bestellung mindestens sein?
Hilfe 2: Schritte für ausText: Länge und Leerzeichen prüfen → Kundennummer mit zahlAus(s.substring(0, 4)) lesen, bei −1 abbrechen → Priorität an Position 4 prüfen → neues Objekt mit s.substring(6) als Text.
Hinweis

Integer.parseInt ist in der Online-IDE zu großzügig ("4x" ergibt 4). Prüfen Sie Zahlenfelder deshalb immer Zeichen für Zeichen.

Ziel: Die Zentrale fragt nur für die vorderste Bestellung an und übernimmt nur eine dazu passende Antwort. Fertig, wenn: Die fünf Ausgaben zu adressanfrage und adresseEingetroffen stimmen mit Ihren eingetragenen Erwartungen überein.

Tragen Sie zuerst die Feldpositionen Ihres Antwortformats in die Attribute am Klassenanfang ein. Implementieren Sie dann adressanfrage() und adresseEingetroffen(text) nach Ihrem Schnittstellenvertrag. Eine Antwort wird nur angenommen, wenn ihre Länge stimmt, alle Zahlenfelder lesbar sind und die Bestellnummer zur vordersten Bestellung passt. Dann wird die Bestellung entnommen, ihr Ziel gesetzt, sie an die Liste angehängt und die Liste sortiert.

Hilfe 1: Vor head() und dequeue() immer isEmpty() prüfen – das verlangt auch das Abitur. head() liefert ein Object: Bestellung b = (Bestellung) eingang.head();
Hilfe 2: Mit den Attributen bleibt Ihr Code lesbar: zahlAus(text.substring(POS_ZEILE, POS_ZEILE + 2)). Eine Antwort „unbekannt“ hat dort keine Ziffern – zahlAus liefert dann −1.
Hilfe 3: Reihenfolge in adresseEingetroffen: Schlange leer oder Länge falsch → false; Nummer, Zeile, Spalte lesen; passt die Nummer nicht oder ist ein Wert −1 → false; sonst dequeue, setZiel, append, sortiere, true.

Ziel: Die dringendste Bestellung steht immer vorn, der Lieferauftrag entspricht Ihrem Vertrag. Fertig, wenn: Alle Ausgaben des Selbsttests stimmen.

Implementieren Sie sortiere nach Ihrem Struktogramm und lieferauftrag nach Ihrem Schnittstellenvertrag.

Hilfe 1: getItem liefert ein Object – beim Vergleich umwandeln: akt.istDringenderAls((Bestellung) liste.getItem(j)).

Hilfe 2: Zahlen im Lieferauftrag brauchen feste Breiten: mitNullen(b.getZeile(), 2).

Karte Z-b: Speichern Sie zu jedem freien Kurier auch seine Position (z. B. eine zweite Reihung oder eine kleine Klasse) und schreiben Sie naechsterKurier(b: Bestellung), der den Kurier mit dem kleinsten Abstand zum Ziel von b liefert. Der Betrag kommt aus Preisliste.summe(text) (Klasse der Kurier-Gruppe).

Ausgezeichnet – Alle Aufgaben abgeschlossen!

Ihr Modul besteht den Selbsttest (Meilenstein M2). Prüfen Sie noch:

Aufgaben: Station ZENTRA anbinden

Jetzt wird die Zentrale zur Station. Kopieren Sie Bestellung und Zentrale ohne das Hauptprogramm in den Workspace mit Ihrer Station, setzen Sie rufzeichen = "ZENTRA" und testen Sie erst mit session = "LOOPBACK", dann im Gruppen-Sitzungscode.

Ihr Bearbeitungsfortschritt:0%
Aufgabe 4 (Gruppenarbeit): Die Zentrale geht auf Sendung

Material: Ergänzung der Klasse Station

// in der Klasse Station:
private Zentrale zentrale = new Zentrale();

private synchronized void verarbeite(Paket p, String text) {
   String typ = p.getTyp();
   if (typ.equals("BST") && p.getAbsender().equals("KUNDE1")) {
      // TODO Teil a
   } else if (typ.equals("ADR")) {
      // TODO Teil b
   } else if (typ.equals("POS")) {
      // TODO Teil c
   }
}

// vergibt Aufträge, solange Kurier und Auftrag vorhanden sind
private void vergeben() {
   // TODO Teil c
}
Listing Z3: Ergänzung der Station ZENTRA

Ergänzen Sie den Fall BST: Bestellnummer holen, Bestellung lesen. Ist sie unlesbar, STO melden. Sonst annehmen, ANN melden und – wenn die neue Bestellung vorn in der Schlange steht – die Adressanfrage an KUNDEN senden.

Hilfe 1: Wie erkennen Sie, dass die neue Bestellung vorn steht? vordersteHatNr hilft.
Hilfe 2: Statusmeldung: sende("ALLE__", "STA", nrText + "ANN"); mit String nrText = zentrale.mitNullen(nr, 3);
Hilfe 3: Methodenaufrufe mit Nebenwirkung (wie neueNummer()) gehören in eine eigene Zeile – die Online-IDE wertet Verkettungen nicht sicher von links nach rechts aus.

Ergänzen Sie den Fall ADR: Bei unbekanntem Kunden die vorderste Bestellung verwerfen und STO melden, sonst eintragen und KOC melden. Danach die nächste Adressanfrage senden (falls vorhanden) und vergeben.

Hilfe 1: Woran erkennen Sie in Ihrem Antwortformat „unbekannt“? Wo steht die Bestellnummer?
Hilfe 2: Verwerfen Sie nur, wenn zentrale.vordersteHatNr(nrText) gilt. Sonst storniert eine verspätete Antwort die falsche Bestellung. Prüfen Sie vor jedem substring die Länge des Textes.

Ergänzen Sie den Fall POS (ein Kurier meldet sich frei) und die Methode vergeben().

Hilfe 1: Woran erkennen Sie in den POS-Nutzdaten laut Vertrag, dass der Kurier frei ist?
Hilfe 2: vergeben() ist eine Schleife mit zentrale.kannVergeben() als Bedingung. Was soll passieren, wenn sende false liefert (Kurier nicht erreichbar)? nimmAnZurueck hilft.
Hilfe 2 eA: In der eA-Station liefert sende nichts zurück. Bricht ein Paket ab, ruft die Station abgebrochen(p) auf. Lesen Sie dort die Bestellnummer aus p.getNutzdaten() und melden Sie STO – oder legen Sie den Auftrag zurück, wenn Sie sich ihn gemerkt haben.

Planen Sie mit dem Kundenverzeichnis und einer Kurier-Gruppe einen Schnittstellentest und führen Sie ihn durch (Gruppen-Sitzungscode, Störkanal aus, dann 10 % Verlust). Halten Sie in einer Tabelle fest: Testfall – erwartet – beobachtet – Ursache bei Abweichung (Spezifikation oder Implementierung?).

Hilfe 1: Mindestens: normale Bestellung; eilige überholt normale; unlesbare Bestellung; unbekannter Kunde; kein Kurier frei; zwei Kuriere.
Hilfe 2: Bestellungen können Sie selbst senden: Eine Person startet eine Station mit rufzeichen = "KUNDE1" und demo = false und tippt die Bestellungen ein. Ist eine Partnerabteilung noch nicht bereit, testen Sie gegen die Ersatzstationen in FN-<Kurs>-TEST.
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Ihre Zentrale ist auf Sendung (Meilenstein M3). Prüfen Sie:

Aufgaben: Fairness und Vererbung eA

Die Zentrale wird fair und lernt eine neue Art von Bestellung.

Ihr Bearbeitungsfortschritt:0%
Aufgabe 5 (Partnerarbeit): Niemand wartet ewig

Material: Am Freitagabend kommen fast nur eilige Bestellungen (Priorität 1). Die Pizza von Bestellung 001 (Priorität 3) wird bei jeder Vergabe wieder übergangen – sie verhungert. Bedingung 5 Ihrer Karte: Wer dreimal übergangen wurde, rückt eine Prioritätsstufe auf.

Ergänzen Sie Bestellung um einen Zähler uebergangen und eine Methode uebergehe() und schreiben Sie in der Zentrale naechsteBestellungFair(): Nach dem Entnehmen werden alle wartenden Aufträge „übergangen“, dann wird neu sortiert. Testen Sie: zwei normale Bestellungen, danach acht Runden „eine eilige kommt dazu, einmal wird vergeben“. Notieren Sie die Reihenfolge der vergebenen Nummern.

Hilfe 1: uebergehe(): Zähler erhöhen; erreicht er 3 und ist die Priorität größer als 1, Priorität um 1 senken und Zähler zurücksetzen.
Hilfe 2: Warum muss danach sortiere() aufgerufen werden?

Food Now! liefert auch Medikamente der Apotheke aus (Priorität 0 im Bestellformat). Sie haben Vorrang vor allem und rücken nicht auf. Entwerfen Sie eine Unterklasse Medikamentenlieferung von Bestellung, die istDringenderAls und alsText überschreibt. Zeichnen Sie das Klassendiagramm mit Vererbungspfeil, passen Sie ausText an und erklären Sie, warum sortiere() nicht geändert werden muss.

Hilfe 1: Der Konstruktor ruft super(kundennr, 0, zeit, text) auf.
Hilfe 2: istDringenderAls: Ist die andere auch eine Medikamentenlieferung (Priorität 0), entscheidet die Eingangsnummer, sonst gilt immer true.

Ergänzen Sie die Station: (1) Aufträge für die Außenfiliale Hasbergen (das Kundenverzeichnis meldet dafür eine vereinbarte Lage, z. B. Zeile 99) gehen sofort an RELAIS statt in die Auftragsliste. (2) Bestelltexte werden vor der Annahme mit der Klasse Bestellstatus der Abteilung Bestellstatus geprüft; ungültige werden mit STO storniert. Handeln Sie beides mit den Abteilungen aus.

Hilfe 1: RELAIS meldet sich nicht mit POS frei. Aufträge für Hasbergen werden deshalb direkt nach dem Eintreffen der Adresse gesendet – verwerfeVorderste() liefert die Bestellung, ohne sie in die Liste zu übernehmen.
Hilfe 2: Die Klasse Bestellstatus kommt in Ihren Workspace. Texte ohne Klammern prüft istGueltigerBestelltext(text), Menüs mit Klammern klammernOk(text). Solange die Klasse noch fehlt, schreiben Sie eine Fassung, die immer true liefert.
Aufgabe 6 (Einzelarbeit): Laufzeit und Alternativen

Die Liste ist vor liste.append(b) schon sortiert. Wie viele Vergleiche braucht sortiere() dann im besten und im schlechtesten Fall bei n Aufträgen? Wie viele bräuchte die Einfügesortierung für eine völlig unsortierte Liste?

Hilfe 1: Bei einer fast sortierten Liste bricht die innere Schleife für alle alten Elemente sofort ab.

Ein Mitschüler schlägt vor: „Nehmt drei Queues, eine je Priorität. Vergeben wird immer aus der dringendsten nicht leeren Schlange.“ Beurteilen Sie den Vorschlag – auch im Hinblick auf Bedingung 5 und die Medikamente.

Hilfe 1: Welche Reihenfolge entsteht innerhalb jeder Schlange? Kann eine Queue ein Element aus der Mitte herausgeben?
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Die Erweiterung läuft (Meilenstein M4). Prüfen Sie:

Sicherung

Definition: Prioritätswarteschlange

Eine Warteschlange, aus der immer das dringendste Element zuerst entnommen wird; bei gleicher Dringlichkeit das älteste. Die Zentrale baut sie aus einer sortierten dynamischen Reihung.

Merke

Die Zentrale nutzt eine Schlange (FIFO) für Bestellungen, die auf ihre Adresse warten: Es ist immer nur eine Anfrage unterwegs, und keine Bestellung geht verloren. Eine nach Priorität sortierte dynamische Reihung (Einfügesortierung) liefert den nächsten Auftrag immer an Position 0. Die ADT-Klassen speichern Object; beim Lesen wird umgewandelt ((Bestellung) liste.getItem(i)). Vor head, dequeue, getItem und delete wird geprüft, ob die Struktur leer bzw. der Index gültig ist.

Infobox: Schnittstelle zum Go-Live

Diese Pakete empfängt und sendet die Zentrale. Die Formate stehen in Ihrem Schnittstellenvertrag.

Tabelle Z2: Pakete der Zentrale
RichtungTypPartnerNutzdaten
empfängtBSTKUNDE1KKKKP Text
sendetADRKUNDENAnfrage laut Vertrag
empfängtADRKUNDENAntwort laut Vertrag
sendetBSTKURIRn, eA RELAISLieferauftrag laut Vertrag
empfängtPOSKURIRnMeldung „frei“ laut Vertrag
sendetSTAALLE__NNN + ANN, KOC oder STO
Plan-Check

Vergleichen Sie Ihren Plan aus dem Einstieg mit Ihrer fertigen Zentrale: Welche Plan-Punkte haben sich bestätigt, welche mussten Sie ändern – und warum?

Rückbezug: Wo bleibt mein Burger?

Mit Schlange und sortierter Auftragsliste wird der eilige Burger zuerst vergeben, obwohl er später kam. Weil immer nur eine Anfrage unterwegs ist und jede Antwort die Bestellnummer trägt, kann die Zentrale jede Antwort zuordnen – eine verspätete oder unpassende Antwort wird verworfen statt falsch verbucht. Ein frei gemeldeter Kurier bekommt sofort den nächsten Auftrag, die Pizza wartet nicht mehr.


Abteilung Kurier

Worum es geht: Der Stadtplan braucht neun Pakete, und nach der Lieferung findet die Kurierin nicht zurück. → Der Kurier überträgt den Plan komprimiert, speichert ihn als 2D-Array und merkt sich den Weg auf einem Stapel.

Einstieg: Kim findet nicht zurück

Störung im Liefernetz (Gruppenarbeit)

Erster Arbeitstag von Kurierin Kim (KURIR1). Bevor sie losfahren kann, braucht ihr Programm den Stadtplan. Der Kartendienst KARTE1 schickt ihn als Text – Zeile für Zeile, getrennt durch /. Der Lausch-Client zeigt:

20:00:01  KURIR1 → KARTE1  KRT  (Anforderung)
20:00:01  KARTE1 → KURIR1  KRT  Teil 01/09 ##.#########…
20:00:03  KARTE1 → KURIR1  KRT  Teil 02/09
    // Timeout, Wiederholung
20:00:05  KARTE1 → KURIR1  KRT  Teil 02/09 ……/##.######…
…
20:00:27  KARTE1 → KURIR1  KRT  Teil 09/09 .########.#
20:00:27  ZENTRA → KURIR1  BST  Lieferauftrag 017
    // wartet seit 20:00:09 auf KURIR1
20:07:40  KURIR1 → ALLE__  STA  WIE KOMME ICH ZURUECK?
Mitschnitt K1: Kims erste Tour

Der Plan hat 12 Zeilen mit je 40 Zeichen, mit Trennzeichen 491 Zeichen – das sind 9 Pakete. Bei Störung dauert das fast eine halbe Minute, und in dieser Zeit wartet schon der erste Auftrag. Dabei besteht der Plan fast nur aus langen Folgen gleicher Zeichen. Auf dem Hinweg wurde Kim außerdem wegen einer Absperrung spontan umgeleitet. Jetzt weiß ihr Programm nicht mehr, wie sie gefahren ist – und nur der gefahrene Weg ist sicher frei.

Leitfrage: Wie kommt der Kurier mit wenigen Paketen zu seinem Plan – und auf genau demselben Weg zurück zur Zentrale?

Nebenfragen:

  1. Wie kann man den Plan kürzer übertragen, ohne Information zu verlieren?
  2. In welcher Reihenfolge braucht der Kurier auf dem Rückweg die Positionen, die er sich gemerkt hat?

Unser Plan

Sammeln Sie in der Gruppe: Problem → Idee → offene Frage.

  • Lesen Sie eine Zeile des Plans laut vor, ohne jedes Zeichen einzeln zu nennen. Was sagen Sie dann?
  • Legen Sie den Hinweg mit Karten nach: Auf jede Karte schreiben Sie die Position, von der Kim gerade losfährt. Welche Karte brauchen Sie für den Rückweg zuerst?
  • Welche Pakete empfängt und sendet ein Kurier während einer Lieferung? Mit wem müssen Sie dafür etwas vereinbaren?

Tragen Sie den Plan als Protokollblatt v0.1 ein (Abschnitte 2, 3 und 6) und zeigen Sie ihn der Lehrkraft (Plan-Ticket). Danach beginnt Aufgabe 1.

Bedingungskarte K-A
  1. Ihre Gruppe betreibt auch den Kartendienst KARTE1.
  2. Störungsprofil beim Test: 20 % Verlust.
  3. Der Kurier prüft, ob der Plan vollständig ist (12 Zeilen à 40 Zeichen), und fordert ihn sonst neu an.
Bedingungskarte K-B
  1. Der Kurier zeigt den Plan nach jedem Schritt mit seiner Position an.
  2. Störungsprofil beim Test: 20 % Fehler.
  3. Der Rückweg führt exakt über den Hinweg und wird als Positionsfolge ausgegeben.
Bedingungskarte K-C
  1. Der Kurier meldet alle 5 Schritte seine Position an die Zentrale (Format mit der Zentrale aushandeln).
  2. Störungsprofil beim Test: 300 ms Verzögerung.
  3. Die Nutzdaten jedes eigenen Pakets haben höchstens 20 Zeichen.

Material für alle Aufgaben: der Stadtplan von Osnabrück (stark vereinfacht), Zeile 0 oben, Spalte 0 links.

Waagerechte Straßen in Zeile 1, 5 und 9, senkrechte Straßen in Spalte 2, 11, 20, 29 und 38, dazwischen Häuserblöcke; die Zentrale liegt in Zeile 5, Spalte 11. Z 0 5 10 15 20 25 30 35 0 5 10 Hasestraße Neuer Graben Iburger Straße Lotter Straße Martinistraße Johannisstraße Bramscher Straße Natruper Straße
Abbildung K1: Stadtplan (40 × 12 Felder)
Tabelle K1: Legende und Richtungen
ZeichenBedeutung
.Straße (befahrbar)
#Häuserblock
ZZentrale (Zeile 5, Spalte 11)
N / Sein Feld nach oben (Zeile − 1) / unten (Zeile + 1)
O / Wein Feld nach rechts (Spalte + 1) / links (Spalte − 1)
Plan als Text (für das Programm)
String[] plan = {
   "##.########.########.########.########.#",
   "........................................",
   "##.########.########.########.########.#",
   "##.########.########.########.########.#",
   "##.########.########.########.########.#",
   "...........Z............................",
   "##.########.########.########.########.#",
   "##.########.########.########.########.#",
   "##.########.########.########.########.#",
   "........................................",
   "##.########.########.########.########.#",
   "##.########.########.########.########.#"
};
Listing K1: Der Stadtplan als Reihung von Zeichenketten

Aufgaben: Den Kurier entwerfen

Entwerfen Sie, wie der Plan übertragen wird, wie der Kurier seinen Weg speichert und welche Pakete er austauscht. Halten Sie alles im Protokollblatt fest.

Ihr Bearbeitungsfortschritt:0%
Aufgabe 1 (Gruppenarbeit): Karte, Weg und Ablauf

Material: Stadtplan, Ihre Bedingungskarte, Tabelle Ü3 (Ablauf einer Bestellung im Go-Live).

  1. Wie viele FN/1-Pakete braucht der Plan unkomprimiert (12 Zeilen, mit / verbunden)?
  2. Codieren Sie die Zeilen 0, 1 und 5 von Hand mit Lauflängencodierung (Notation Anzahl-Wert).
  3. Der ganze Plan (mit Trennzeichen) ergibt lauflängencodiert 234 Zeichen. Berechnen Sie Kompressionsverhältnis, prozentuale Datenersparnis und die Zahl der Pakete.
  4. Woran erkennt der Empfänger, wo eine Anzahl endet und wo eine Kartenzeile endet? Was müsste man ändern, wenn im Plan Ziffern (Hausnummern) vorkämen?
Hilfe 1: Aus rrrssssgrr wird 3r4s1g2r. Auch einzelne Zeichen bekommen eine Anzahl: 1g. Das / wird wie jedes andere Zeichen codiert.
Hilfe 2: Kompressionsverhältnis = Größe komprimiert / Größe original; Datenersparnis = (1 − Verhältnis) · 100 %.
Hilfe 3: Im Plan kommen keine Ziffern vor. Was folgt daraus für das Lesen von 40.? Und wie wäre 12 zu lesen, wenn auch Ziffern Werte sein dürften?

Die 480 Kartenzeichen kommen so oft vor: # 315-mal, . 164-mal, Z einmal. Erstellen Sie einen Huffman-Baum für die drei Zeichen und bestimmen Sie die Codes. Wie viele Bit braucht der Plan Huffman-codiert, wie viele mit 7-Bit-ASCII, wie viele lauflängencodiert in ASCII (234 Zeichen)? Unser Kanal überträgt allerdings Zeichen, keine einzelnen Bits. Entscheiden Sie begründet, welches Verfahren für KRT sinnvoll ist.

Hilfe 1: Fassen Sie die beiden seltensten Zeichen zusammen: zuerst Z (1) und . (164).
Hilfe 2: Ein Bit müsste im Zeichenkanal als Zeichen '0' oder '1' übertragen werden. Wie viele Zeichen wären die Huffman-Bits dann?

Kim fährt von der Zentrale (5, 11) zu Kunde 0042 (Hasestraße, Zeile 1, Spalte 6). Fahrtenplan: Liegt das Ziel an einer waagerechten Straße (Zeile 1, 5 oder 9), fährt sie zuerst senkrecht bis zur Zielzeile, dann waagerecht; sonst umgekehrt.

  1. Geben Sie den Hinweg als Folge aus N, O, S, W an.
  2. Vor jedem Schritt wird die alte Position auf einen Stapel gelegt. Zeichnen Sie den Stapel nach dem Hinweg (oben = zuletzt abgelegt).
  3. Geben Sie die Positionen an, die wiederholtes pop() für den Rückweg liefert.
Hilfe 1: Von Zeile 5 nach Zeile 1 sind es 4 Schritte nach Norden, von Spalte 11 nach Spalte 6 fünf Schritte nach Westen.
Hilfe 2: Oben auf dem Stapel liegt die Position vor dem letzten Schritt.

Stellen Sie den Ablauf einer Tour aus Sicht von KURIR1 als Sequenzdiagramm dar – vom Start des Programms bis zur erneuten Freimeldung. Entwerfen Sie das POS-Format (Formattabelle mit Beispiel) und stimmen Sie es mit der Zentrale ab. Klären Sie mit der Zentrale das Format des Lieferauftrags und mit der Kasse Zahlungsformat und Schlüsselregel.

Hilfe 1: Partner: KARTE1, ZENTRA, ALLE__, KASSE1.
Hilfe 2: Woher kennt der Kurier den Betrag? Entweder steht er im Lieferauftrag, oder der Kurier berechnet ihn aus dem Bestelltext mit der Klasse Preisliste (Aufgabe 4).
Hilfe 3: Was braucht die Zentrale aus POS, um zu wissen, dass der Kurier frei ist? Braucht sie auch seine Position (Bedingungskarte der Zentrale)?
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Ihr Entwurf steht. Prüfen Sie ihn:

Aufgaben: Stadtplan und Weg programmieren

Implementieren Sie die Lauflängencodierung und das Fahren in der Klasse Kurier (Datei Kurier.java) und testen Sie ohne Netz.

Ihr Bearbeitungsfortschritt:0%
Aufgabe 2 (Partnerarbeit): rleKodiere und rleDekodiere

Material: Auszug der Klasse Kurier. Die beiden Methoden sind static, weil sie keine Attribute des Kuriers brauchen – so kann auch der Kartendienst sie ohne Kurier-Objekt aufrufen.

// ---- Selbsttest ----
// erwartet: 3r4s1g2r
println(Kurier.rleKodiere("rrrssssgrr"));
// erwartet: rrrssssgrr
println(Kurier.rleDekodiere("3r4s1g2r"));
// erwartet: 40
println(Kurier.rleDekodiere("40.").length());

class Kurier {
   // ... (Aufgabe 3)

   // RLE, Notation Anzahl-Wert: "rrrssssgrr" -> "3r4s1g2r"
   public static String rleKodiere(String s) {
      // TODO Teil b
      return "";
   }

   // zurück: "3r4s1g2r" -> "rrrssssgrr"; Anzahlen auch mehrstellig
   public static String rleDekodiere(String s) {
      // TODO Teil c
      return "";
   }
}
Listing K2: Selbsttest und Gerüst der Lauflängencodierung

Entwerfen Sie auf Papier ein Struktogramm für rleKodiere(s: Zeichenkette): Zeichenkette. Erlaubt sind nur length, charAt, Verkettung und Vergleiche.

Hilfe 1: Eine äußere Schleife geht über die Läufe, eine innere zählt, wie oft dasselbe Zeichen hintereinander kommt.

Hilfe 2: Ergänzen Sie die Lücken:

ergebnis ← „“
i ← 0
solange i < Länge von s
wert ← Zeichen von s an Position i
anzahl ← 1
solange ____ und Zeichen an Position i + anzahl = wert
anzahl ← anzahl + 1
ergebnis ← ____
i ← ____
gib ergebnis zurück
Struktogramm K1: rleKodiere(s: Zeichenkette): Zeichenkette

Ziel: Ihr Struktogramm läuft als Java-Methode. Fertig, wenn: Der Selbsttest zeigt 3r4s1g2r.

Hilfe 1: ergebnis = ergebnis + anzahl + wert; hängt die Zahl als Text und dann das Zeichen an.
Hilfe 2: Achten Sie auf die Reihenfolge der Bedingungen: erst i + anzahl < s.length(), dann s.charAt(i + anzahl) – sonst gibt es am Textende einen Laufzeitfehler.

Ziel: Auch mehrstellige Anzahlen (40., 11.) werden richtig gelesen. Fertig, wenn: Der Selbsttest zeigt rrrssssgrr und 40.

Hilfe 1: Lesen Sie Zeichen für Zeichen. Ist es eine Ziffer, gehört es zur Anzahl, sonst ist es der Wert.
Hilfe 2: Aus den Ziffern 4 und 0 wird die Zahl 40 wie in zahlAus: anzahl = anzahl * 10 + ((int) c - 48);
Hilfe 3: Nach dem Wert hängen Sie ihn anzahl-mal an und setzen anzahl wieder auf 0.

Erzeugen Sie einen Kurier mit dem Plan aus Listing K1, lassen Sie mit karteAlsText() den Text erzeugen (Zeilen mit / verbunden), codieren Sie ihn und prüfen Sie rleDekodiere(kodiert).equals(original). Geben Sie das Kompressionsverhältnis aus und vergleichen Sie mit Aufgabe 1 a).

Hilfe 1: Das Verhältnis als Kommazahl: (double) kodiert.length() / original.length().
Aufgabe 3 (Partnerarbeit): Fahren und zurückfinden

Material: Klassendiagramm, Selbsttest und Gerüst der Datei Kurier.java (Konstruktor, planeRoute, zeigeKarte, karteAlsText und zeilenAus sind fertig).

// ---- Selbsttest (plan wie in Listing K1) ----
Kurier k = new Kurier(plan, 5, 11);
String route = k.planeRoute(1, 6);
// erwartet: NNNNWWWWW
println(route);
// erwartet: true und danach 1 6
println(k.fahre(route));
println(k.getZeile() + " " + k.getSpalte());
// erwartet: false (nördlich liegt ein Häuserblock)
println(k.schritt('N'));
// erwartet: (1/7) (1/8) (1/9) (1/10) (1/11) ... (5/11)
println(k.fahreZurueck());
// erwartet: 5 11
println(k.getZeile() + " " + k.getSpalte());
Listing K3: Selbsttest für das Fahren
Gerüst der Klassen Punkt und Kurier anzeigen
class Punkt {
   private int zeile;
   private int spalte;

   public Punkt(int zeile, int spalte) {
      this.zeile = zeile;
      this.spalte = spalte;
   }

   public int getZeile() { return zeile; }
   public int getSpalte() { return spalte; }
}

class Kurier {
   private char[][] karte;
   private int zeile;
   private int spalte;
   // bisherige Positionen (Punkt)
   private Stack route = new Stack();

   public Kurier(String[] plan, int startZeile,
                 int startSpalte) {
      karte = new char[plan.length][plan[0].length()];
      for (int z = 0; z < plan.length; z++) {
         for (int s = 0; s < plan[z].length(); s++) {
            karte[z][s] = plan[z].charAt(s);
         }
      }
      zeile = startZeile;
      spalte = startSpalte;
   }

   public int getZeile() { return zeile; }
   public int getSpalte() { return spalte; }

   // ein Schritt in Richtung N, O, S oder W; nur über Straßen
   public boolean schritt(char richtung) {
      // TODO Teil a
      return false;
   }

   // ganze Route fahren; false beim ersten unmöglichen Schritt
   public boolean fahre(String richtungen) {
      // TODO Teil a
      return false;
   }

   // Rückweg über den Stapel; liefert die Positionen als Text
   public String fahreZurueck() {
      // TODO Teil b
      return "";
   }

   // Fahrtenplan: erst bis zur Straße des Ziels, dann zum Ziel
   public String planeRoute(int zz, int zs) {
      String r = "";
      int dz = Math.abs(zz - zeile);
      int ds = Math.abs(zs - spalte);
      if (zz == 1 || zz == 5 || zz == 9) {
         r = r + wiederhole(senkrecht(zz - zeile), dz);
         r = r + wiederhole(waagerecht(zs - spalte), ds);
      } else {
         r = r + wiederhole(waagerecht(zs - spalte), ds);
         r = r + wiederhole(senkrecht(zz - zeile), dz);
      }
      return r;
   }

   private char senkrecht(int d) {
      if (d < 0) { return 'N'; }
      return 'S';
   }

   private char waagerecht(int d) {
      if (d < 0) { return 'W'; }
      return 'O';
   }

   private String wiederhole(char c, int n) {
      String s = "";
      for (int i = 0; i < n; i++) {
         s = s + c;
      }
      return s;
   }

   public void zeigeKarte() {
      for (int z = 0; z < karte.length; z++) {
         String zeileText = "";
         for (int s = 0; s < karte[z].length; s++) {
            if (z == zeile && s == spalte) {
               zeileText = zeileText + "@";
            } else {
               zeileText = zeileText + karte[z][s];
            }
         }
         println(zeileText);
      }
   }

   // Karte zeilenweise, getrennt durch '/'
   public String karteAlsText() {
      String t = "";
      for (int z = 0; z < karte.length; z++) {
         if (z > 0) {
            t = t + "/";
         }
         for (int s = 0; s < karte[z].length; s++) {
            t = t + karte[z][s];
         }
      }
      return t;
   }

   // "ab/cd/ef" -> {"ab", "cd", "ef"} (ohne split)
   public static String[] zeilenAus(String text) {
      int anzahl = 1;
      for (int i = 0; i < text.length(); i++) {
         if (text.charAt(i) == '/') {
            anzahl++;
         }
      }
      String[] zeilen = new String[anzahl];
      int nr = 0;
      String aktuell = "";
      for (int i = 0; i < text.length(); i++) {
         char c = text.charAt(i);
         if (c == '/') {
            zeilen[nr] = aktuell;
            nr++;
            aktuell = "";
         } else {
            aktuell = aktuell + c;
         }
      }
      zeilen[nr] = aktuell;
      return zeilen;
   }

   // rleKodiere und rleDekodiere aus Aufgabe 2 hier einfügen
}
Listing K4: Gerüst der Klassen Punkt und Kurier

Ziel: Der Kurier fährt nur über Straßen und legt vor jedem Schritt die alte Position auf den Stapel. Fertig, wenn: Der Selbsttest zeigt true, 1 6 und false.

Implementieren Sie schritt(richtung): Das Zielfeld wird berechnet; liegt es außerhalb des Plans oder ist dort ein #, bleibt der Kurier stehen und liefert false. Sonst wird die alte Position als Punkt auf den Stapel gelegt und der Kurier bewegt sich. fahre(richtungen) fährt alle Schritte nacheinander und bricht beim ersten unmöglichen Schritt ab.

Hilfe 1: Arbeiten Sie mit Hilfsvariablen nz, ns für das Zielfeld. Erst nach der Prüfung wird gestapelt und bewegt.
Hilfe 2: Prüfen Sie zuerst die Grenzen (nz < 0 || nz >= karte.length || …), erst dann karte[nz][ns].
Hilfe 3: Nach bestandener Prüfung: route.push(new Punkt(zeile, spalte)); zeile = nz; spalte = ns;

Ziel: Der Rückweg führt exakt über den Hinweg. Fertig, wenn: Der Selbsttest zeigt die Positionen von (1/7) bis (5/11) und danach 5 11.

Implementieren Sie fahreZurueck(): Solange der Stapel nicht leer ist, wird die oberste Position entnommen und der Kurier dorthin gesetzt. Rückgabe ist der Rückweg als Text. Begründen Sie im Protokollblatt, warum der Rückweg nicht noch einmal auf Befahrbarkeit geprüft werden muss.

Hilfe 1: Eine Schleife while (!route.isEmpty()) schützt vor pop auf einem leeren Stapel.
Hilfe 2: pop() liefert ein Object: Punkt p = (Punkt) route.pop();

Schreiben Sie einen Selbsttest: Für jede der Zieladressen (1, 6), (3, 20), (5, 30), (9, 8), (7, 38), (10, 2), (0, 11), (2, 29), (1, 35), (9, 24), (6, 2), (5, 3) wird ein neuer Kurier an der Zentrale erzeugt, die Route geplant und gefahren, die Ankunft geprüft und zurückgefahren. Ausgabe: Ziel, Route, „OK“ oder „FEHLER“.

Hilfe 1: Zwei Reihungen int[] zz = {1, 3, 5, …}; und int[] zs = {6, 20, 30, …}; mit demselben Index.
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Ihr Modul besteht den Selbsttest (Meilenstein M2). Prüfen Sie noch:

Aufgaben: KARTE1 und KURIR1 auf Sendung

Jetzt laufen zwei Stationen: der Kartendienst KARTE1 und die Kurierin KURIR1 – zwei Programme mit je eigenem rufzeichen, auf zwei Geräten bzw. mit zwei Konten.

Ihr Bearbeitungsfortschritt:0%
Aufgabe 4 (Gruppenarbeit): Der Kurier geht auf Tour

Material: Klasse Preisliste (fertig), Klassen Kasse und Zahlung der Abteilung Kasse (Schnittstellenvertrag; bis dahin eine Ersatzfassung der Lehrkraft), Schlüsselregel der Kasse.

Klasse Preisliste anzeigen
class Preisliste {
   // Preis in Cent, 0 = unbekannt
   public static int preis(String gericht) {
      if (gericht.equals("PIZZA")) { return 850; }
      if (gericht.equals("PASTA")) { return 790; }
      if (gericht.equals("BURGER")) { return 690; }
      if (gericht.equals("SALAT")) { return 590; }
      if (gericht.equals("POMMES")) { return 350; }
      if (gericht.equals("COLA")) { return 250; }
      if (gericht.equals("MENUE")) { return 1290; }
      return 0;
   }

   // "2xPIZZA,1xCOLA" -> 1950; Klammerinhalte zählen nicht
   public static int summe(String t) {
      int summe = 0;
      int i = 0;
      while (i < t.length()) {
         int anzahl = (int) t.charAt(i) - 48;
         // Ziffer und 'x' überspringen
         i = i + 2;
         String gericht = "";
         while (i < t.length() && t.charAt(i) >= 'A'
                && t.charAt(i) <= 'Z') {
            gericht = gericht + t.charAt(i);
            i++;
         }
         summe = summe + anzahl * preis(gericht);
         // Klammerinhalt bis zum nächsten Komma überspringen
         int tiefe = 0;
         while (i < t.length()
                && (tiefe > 0 || t.charAt(i) != ',')) {
            if (t.charAt(i) == '(') { tiefe++; }
            if (t.charAt(i) == ')') { tiefe--; }
            i++;
         }
         // Komma überspringen
         i++;
      }
      return summe;
   }
}
Listing K5: Die Klasse Preisliste
// in der Station KARTE1
private String[] plan = { /* die 12 Zeilen aus Listing K1 */ };

private synchronized void verarbeite(Paket p, String text) {
   // TODO Teil a: leere KRT-Anforderung beantworten
}

// in der Station KURIR1 (andere Datei, anderes Gerät)
// null, bis der Plan da ist
private Kurier kurier = null;
private Kasse kasse = new Kasse();
// Schlüssel nach der Schlüsselregel der Kasse
private String schluessel = "";

private synchronized void verarbeite(Paket p, String text) {
   String typ = p.getTyp();
   if (typ.equals("KRT") && p.getAbsender().equals("KARTE1")) {
      // TODO Teil a: Plan auspacken, Kurier erzeugen, frei melden
   } else if (typ.equals("BST") && kurier != null) {
      liefere(text);
   }
}

// TODO Teil b
private void liefere(String text) {
}
Listing K6: Ergänzungen der Stationen KARTE1 und KURIR1

Ergänzen Sie verarbeite der Station KARTE1: Auf jede KRT-Anforderung mit leeren Nutzdaten antwortet sie dem Absender mit dem lauflängencodierten Plan. Beim Start fordert KURIR1 den Plan an (im Hauptprogramm nach dem Verbinden). Kommt die Antwort, wird der Plan decodiert, in Zeilen zerlegt, die Kurierin an der Zentrale erzeugt und die Freimeldung an die Zentrale gesendet.

Hilfe 1: Der Absender steht in p.getAbsender() – so funktioniert der Dienst für beliebig viele Kuriere. Das Zerlegen in Pakete erledigt der Kern.
Hilfe 2: Hauptprogramm von KURIR1: station.sende("KARTE1", "KRT", "");. Solange kein Plan da ist, ist kurier noch null – deshalb meldet sich die Station erst nach dem Plan frei.
Hilfe 3: Karte K-A: Prüfen Sie vor dem Erzeugen plan.length und die Länge jeder Zeile; fordern Sie sonst neu an.

Implementieren Sie liefere(text): Lieferauftrag nach Ihrem Vertrag zerlegen, ABH melden, Route fahren (nach jedem Schritt 200 ms warten; Karte K-B: Plan zeigen; Karte K-C: Position melden), LIE melden, Zahlung verschlüsselt an die Kasse schicken, zurückfahren, frei melden.

Hilfe 1: Prüfen Sie zuerst die Länge des Auftrags und jedes Zahlenfeld mit zahlAus (in die Station kopieren). Bei einem unlesbaren Auftrag: Meldung ausgeben, nicht losfahren.
Hilfe 2: Zahlungsart zufällig: char art = 'K'; if (Math.random() < 0.5) { art = 'B'; }. Die Zahlung bauen Sie mit der Klasse Zahlung der Kasse und verschlüsseln sie mit kasse.vigenereVer(…, schluessel).
Hilfe 3 gA: Thread.sleep(200); zwischen den Schritten macht die Fahrt im Go-Live sichtbar.
Hilfe 3 eA: In Ihrer Station darf in verarbeite kein Thread.sleep stehen. Fahren Sie schrittweise mit Timer.executeLater(() -> naechsterSchritt(), 200); – jeder Schritt plant den nächsten, der letzte meldet LIE.

Testen Sie mit der Zentrale und der Kasse im Gruppen-Sitzungscode – erst ohne Störung, dann mit Ihrem Störungsprofil. Prüfen Sie insbesondere: Kommt der Plan trotz Störung vollständig an? Kann die Kasse Ihre Zahlung entschlüsseln und buchen? Halten Sie Testfall – erwartet – beobachtet – Ursache fest.

Hilfe 1: Geben Sie beim Empfang des Plans plan.length und plan[0].length() aus – es müssen 12 und 40 sein.
Hilfe 2: Typische Fehlerquellen: Zahlungsklartext nicht im Format der Kasse, falscher Schlüssel, Freimeldung vor dem Plan.
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Ihre Kurierin ist auf Tour (Meilenstein M3). Prüfen Sie:

Aufgaben: Baustellen und sichere Zahlung eA

Die Kurierin findet auch um Baustellen herum ans Ziel und tauscht mit der Kasse einen Schlüssel aus.

Ihr Bearbeitungsfortschritt:0%
Aufgabe 5 (Partnerarbeit): Wegsuche mit Backtracking

Material: Auf dem Neuen Graben ist eine Baustelle: Feld (5, 15) ist mit X gesperrt. Der Fahrtenplan zu Kunde 0007 (5, 30) bleibt nach drei Schritten stecken (fahre liefert false, Kim steht auf (5, 14)).

Ein Verfahren, das immer einen Weg findet, wenn es einen gibt (Backtracking): Probiere die Richtungen in der Reihenfolge N, O, S, W; gehe nur auf befahrbare, noch nicht besuchte Felder und lege dabei die alte Position auf einen Stapel; geht es nicht weiter, nimm die oberste Position vom Stapel und gehe dorthin zurück. Führen Sie die ersten 10 Schritte für Start (5, 11) und Ziel (5, 30) von Hand aus. Ergänzen Sie außerdem schritt so, dass auch X gesperrt ist.

Hilfe 1: Sie brauchen zusätzlich ein Feld besucht[zeile][spalte] – sonst läuft die Suche im Kreis.
Hilfe 2: Von (5, 11) aus ist N befahrbar. Wohin führt das zuerst, und wo kommt der erste Rückschritt?

Ziel: Eine Route um die Baustelle herum. Fertig, wenn: fahre(sucheWeg(…)) mit Baustelle bei (5, 30) ankommt.

Implementieren Sie public static String sucheWeg(String[] plan, int sz, int ss, int zz, int zs) in einer Klasse Wegsuche. Rückgabe: Route aus N, O, S, W oder "", wenn es keinen Weg gibt. Bauen Sie die Baustelle in den Plan ein und testen Sie.

Hilfe 1: Schleife „solange Ziel nicht erreicht“: erste freie Richtung suchen; gibt es eine, alte Position auf den Stapel, Schritt machen, besucht setzen, Richtung an die Route hängen; sonst – wenn der Stapel leer ist, gibt es keinen Weg – oberste Position vom Stapel holen und das letzte Zeichen der Route entfernen.
Hilfe 2: Letztes Zeichen entfernen: route = route.substring(0, route.length() - 1); Die Baustelle setzen Sie z. B. mit plan[5] = plan[5].substring(0, 15) + "X" + plan[5].substring(16);

Der kürzeste Weg mit Baustelle hat 27 Schritte. Erklären Sie, warum Ihre Tiefensuche einen deutlich längeren Weg findet, und beschreiben Sie, wie eine Breitensuche mit einer Schlange (Queue) den kürzesten Weg findet.

Hilfe 1: Die Tiefensuche folgt einer Richtung, solange es geht – sie „weiß“ nicht, wo das Ziel liegt.
Aufgabe 6 (Partnerarbeit): Schlüsseltausch mit der Kasse

Material: Schnittstellenvertrag mit der Kasse (KEY-Format, Signaturregel), Klasse Kasse mit potenzMod, schluesselAus und signiere (Abteilung Kasse, Aufgabe 6 und 7).

Ergänzen Sie KURIR1: Beim Start wählt die Kurierin eine geheime Zufallszahl a (2 bis 21), sendet KEY mit ihrem öffentlichen Wert an KASSE1 und berechnet aus der Antwort den gemeinsamen Schlüssel. Jede Zahlung wird mit schluesselAus(K) verschlüsselt und nach der Regel der Kasse signiert. Zeigen Sie im Logbuch oder Lausch-Client, dass weder a noch K über Funk gehen.

Hilfe 1: Zufallszahl: int a = 2 + (int) (Math.random() * 20);. Den öffentlichen Wert berechnet kasse.potenzMod(5, a, 23).
Hilfe 2: Zahlungen, die vor der KEY-Antwort fällig werden, warten: Merken Sie sie sich und senden Sie sie, sobald der Schlüssel da ist.
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Ihre Erweiterung läuft (Meilenstein M4). Prüfen Sie:

Sicherung

Definition: Lauflängencodierung (RLE)

Verlustfreies Kompressionsverfahren, das jede Folge gleicher Zeichen durch ihre Anzahl und das Zeichen ersetzt (Notation Anzahl-Wert, z. B. 3r4s1g2r).

Merke

Lauflängencodierung ersetzt Läufe gleicher Werte durch Anzahl-Wert (3r4s1g2r). Sie ist verlustfrei und lohnt sich bei langen Läufen; Kompressionsverhältnis = komprimiert / original. Welches Verfahren am kürzesten ist, hängt vom Kanal ab: In Bit gemessen gewinnt Huffman, im Zeichenkanal RLE. Ein 2D-Array speichert den Plan als karte[zeile][spalte]. Ein Stapel (LIFO) liefert die besuchten Positionen in umgekehrter Reihenfolge – genau die Reihenfolge des Rückwegs. Vor pop wird mit isEmpty geprüft, vor jedem Array-Zugriff die Grenzen.

Infobox: Schnittstelle zum Go-Live

Diese Pakete tauschen Kartendienst und Kurier aus.

Tabelle K2: Pakete von Kartendienst und Kurier
StationRichtungTypPartnerNutzdaten
KARTE1empfängt / sendetKRTjeder Kurierleer / Zeilen mit /, RLE
KURIRnsendetPOSZENTRAlaut Vertrag
KURIRnempfängtBSTZENTRALieferauftrag laut Vertrag
KURIRnsendetSTAALLE__NNN + ABH bzw. LIE
KURIRnsendetZAHKASSE1laut Vertrag, verschlüsselt
eA KURIRnsendet / empfängtKEYKASSE1laut Vertrag
Plan-Check

Vergleichen Sie Ihren Plan aus dem Einstieg mit Ihrer fertigen Station: Welche Plan-Punkte haben sich bestätigt, welche mussten Sie ändern – und warum?

Rückbezug: Kim findet nicht zurück

Lauflängencodiert passt der Plan in 4 statt 9 Pakete, und der erste Auftrag muss nicht mehr eine halbe Minute warten. Weil Kim vor jedem Schritt ihre alte Position auf den Stapel legt, liefert pop den Rückweg in genau der richtigen Reihenfolge – über die Straßen, die sie wirklich gefahren ist, auch nach einer Umleitung.


Abteilung Kundenverzeichnis

Worum es geht: Die Kundenliste ist zu lang zum Durchsuchen, und über Funk gehen Namen und Telefonnummern. → Das Kundenverzeichnis findet Adressen in einem binären Suchbaum und antwortet nur mit dem, was die Lieferung wirklich braucht.

Einstieg: Kundin 3987 und Pizza Paradiso

Störung im Liefernetz (Gruppenarbeit)

Bisher stand die Kundenliste als Textdatei in der Zentrale – mit Namen, Telefonnummern und Adressen. Zwei Vorfälle aus der letzten Woche:

Montag, 18:40 Uhr: Food Now! hat inzwischen 4 000 Kundinnen und Kunden. Die Zentrale geht bei jeder Bestellung die Liste von oben nach unten durch und braucht für Kundin 3987 fast so lange wie für die ganze Liste. Drei Bestellungen warten.

Dienstag, 19:15 Uhr:

19:15:02  ZENTRA → ALLE__  BST  M.Schulte,Hasestr.12,2xPIZZA
    // dazu Telefonnummer und Kundennummer im zweiten Teil
Mitschnitt V1: Ein Auftrag mit allen Kundendaten

Pizza Paradiso hört mit. Am nächsten Tag liegt bei Mia Schulte Werbung im Briefkasten – mit ihrem Namen und ihrer Lieblingspizza.

Leitfrage: Wie kann ein eigenes Kundenverzeichnis Adressen schnell finden und dabei möglichst wenig über die Kundschaft verraten?

Nebenfragen:

  1. Wie viele Vergleiche braucht man höchstens, um unter 4 000 Kundennummern die richtige zu finden?
  2. Welche Angaben über die Kundschaft braucht das Liefernetz wirklich?

Unser Plan

Sammeln Sie in der Gruppe: Problem → Idee → offene Frage.

  • Wie suchen Sie ein Wort im Wörterbuch? Wie viele Seiten schlagen Sie dabei höchstens auf?
  • Streichen Sie in der Kundenliste (Tabelle V1) alle Angaben, die für eine Lieferung nicht nötig sind.
  • Was müssen eine Adressanfrage und eine Adressantwort enthalten – und was nicht?

Tragen Sie den Plan als Protokollblatt v0.1 ein (Abschnitte 2, 3 und 6) und zeigen Sie ihn der Lehrkraft (Plan-Ticket). Danach beginnt Aufgabe 1.

Bedingungskarte V-a
  1. Der Suchbaum hat höchstens die Höhe 4 (Einfügereihenfolge selbst festlegen).
  2. In der Adressantwort stehen nur Daten, die für die Lieferung wirklich nötig sind.
  3. Unbekannte Kunden werden eindeutig gemeldet.
  4. eA Kunden können gelöscht werden, ohne dass der Baum neu aufgebaut wird.
Bedingungskarte V-b
  1. Der Suchbaum hat höchstens die Höhe 4, und die Vielbesteller 0042 und 0815 stehen auf Ebene 1 oder 2.
  2. Eine Antwort enthält nie die Kundennummer; Anfrage und Antwort werden anders zugeordnet.
  3. Die Antwort unterscheidet „Kunde unbekannt“ von „Anfrage unlesbar“.
  4. eA Kunden können gelöscht werden, ohne dass der Baum neu aufgebaut wird.

Material für alle Aufgaben: Kundenliste des Kundenbüros in Anmeldereihenfolge. Das Pseudonym hat sich jede Person in der App selbst gegeben. Die Lage bezieht sich auf den Stadtplan der Abteilung Kurier (Zeile/Spalte).

Tabelle V1: Kundenliste (alle Personen und Nummern erfunden)
Kundennr.NameTelefonPseudonymAdresse (Lage)
0042Mia Schulte0541 000 001Hungrig42Hasestr. 12 (1/6)
0815Jonas Meyer0541 000 002PizzafanJohannisstr. 3 (3/20)
0007Lea Hoffmann0541 000 003NachtschichtNeuer Graben 30 (5/30)
0350Ben Wagner0541 000 004VeggieIburger Str. 8 (9/8)
1200Emma Becker0541 000 005SportlerinNatruper Str. 21 (7/38)
0123Paul Schröder0541 000 006PastaliebeLotter Str. 5 (10/2)
0500Hanna Koch0541 000 007SpaetdienstMartinistr. 44 (0/11)
0999Finn Richter0541 000 008BurgerbossBramscher Str. 2 (2/29)
0271Lina Wolf0541 000 009SalatbarHasestr. 40 (1/35)
0640Noah Klein0541 000 010Familie5Iburger Str. 27 (9/24)
0077Sophie Neumann0541 000 011Studi77Lotter Str. 19 (6/2)
1024Elias Braun0541 000 012BytehungerNeuer Graben 3 (5/3)
★ 9001Ida Lange05405 000 001LandluftHasbergen, Am Bahnhof 1 (Außenfiliale)
★ 9002Tom Krüger05405 000 002BahnfahrerHasbergen, Lindenstr. 9 (Außenfiliale)

Die mit ★ markierten Kunden gibt es nur im eA-Kurs: Sie wohnen im Bereich der Außenfiliale Hasbergen (Lage mit der Zentrale vereinbaren, z. B. Zeile 99).

Aufgaben: Das Verzeichnis entwerfen

Planen Sie den Suchbaum und die Schnittstelle zur Zentrale. Halten Sie alles im Protokollblatt fest.

Ihr Bearbeitungsfortschritt:0%
Aufgabe 1 (Gruppenarbeit): Suchbaum und Datenschutz

Material: Kundenliste (ohne die ★-Kunden), Ihre Bedingungskarte.

Fügen Sie die zwölf Kundennummern in der Anmeldereihenfolge in einen leeren binären Suchbaum ein. Zeichnen Sie den Baum und geben Sie seine Höhe an.

Hilfe 1: Die erste Nummer (0042) wird die Wurzel. Jede weitere Nummer wandert von der Wurzel aus nach links (kleiner) oder rechts (größer), bis ein freier Platz kommt.
Hilfe 2: 0350 ist größer als 0042 (also rechts) und kleiner als 0815 (also links von 0815).

Geben Sie die Suchwege für 0640 und für 0043 (nicht vorhanden) an und zählen Sie die besuchten Knoten. Wie hoch wird der Baum, wenn die zwölf Nummern aufsteigend sortiert eingefügt werden? Wie viele Knoten besucht eine Suche dann im schlechtesten Fall?

Hilfe 1: Bei 0043 endet die Suche an einem leeren Teilbaum – das ist die Antwort „nicht gefunden“.
Hilfe 2: Sortiert eingefügt hängt jede neue Nummer rechts an der vorigen.

Erfüllen Sie Bedingung 1 Ihrer Karte: Geben Sie eine Einfügereihenfolge der zwölf Nummern an und weisen Sie nach, dass der Baum die Bedingung erfüllt. Begründen Sie, warum mit zwölf Kunden keine kleinere Höhe als 4 möglich ist.

Hilfe 1: Sortieren Sie die Nummern. Welche Nummer sollte in die Wurzel, damit links und rechts etwa gleich viele stehen?
Hilfe 2: Ein Baum der Höhe h hat höchstens \(2^h – 1\) Knoten.
Hilfe 3: Karte V-b: Wenn 0042 und 0815 auf Ebene 2 stehen sollen, muss die Wurzel zwischen ihnen liegen. Wie viele Nummern bleiben dann links von 0042, zwischen 0042 und der Wurzel, …?

Entscheiden Sie, welche Spalten der Kundenliste ins Verzeichnis gehören und welche Angaben in der Adressantwort über Funk gehen. Entwerfen Sie mit der Zentrale das Format der Antwort (auch für „unbekannt“, Karte V-b zusätzlich „unlesbar“) als Formattabelle (Position, Länge, Inhalt, Wertebereich, Beispiel). Begründen Sie mit den Grundsätzen Datensparsamkeit und Zweckbindung.

Hilfe 1: Was braucht die Zentrale, um einen Kurier zu schicken? Was braucht der Kurier? Wer braucht Namen und Telefonnummer – und wofür?
Hilfe 2: Alle Stationen hören jedes Paket mit. Kundennummer und Pseudonym sind Pseudonyme: Wer die Liste des Kundenbüros nicht hat, kann sie keiner Person zuordnen – wer lange genug mithört, vielleicht doch.
Hilfe 3: Woran erkennt die Zentrale, zu welcher ihrer Anfragen eine Antwort gehört? Bei Karte V-b darf es nicht die Kundennummer sein.
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Ihr Entwurf steht. Prüfen Sie ihn:

Aufgaben: Den Suchbaum programmieren

Implementieren Sie Kunde und Kundenverzeichnis als eigene Datei Kundenverzeichnis.java und testen Sie ohne Netz (Bibliothek „Abiturklassen Niedersachsen“ einschalten).

Ihr Bearbeitungsfortschritt:0%
Aufgabe 2 (Partnerarbeit): Einfügen, Suchen, Antworten

Material: Klassendiagramm, Selbsttest und Gerüst. Tragen Sie vor dem Programmieren die Anfragen und erwarteten Antworten aus Ihrem Schnittstellenvertrag ein.

// ---- Selbsttest (Hauptprogramm) ----
Kundenverzeichnis v = new Kundenverzeichnis();
v.fuegeEin(new Kunde(42, "Hungrig42", "Hasestr. 12", 1, 6));
v.fuegeEin(new Kunde(815, "Pizzafan", "Johannisstr. 3", 3, 20));
v.fuegeEin(new Kunde(7, "Nachtschicht", "Neuer Graben 30", 5, 30));
// wird abgelehnt: Nummer 42 ist schon vergeben
v.fuegeEin(new Kunde(42, "Doppelt", "gibt es schon", 0, 0));
// erwartet: 7, 42, 815 (aufsteigend)
v.zeigeSortiert();
// erwartet: 3 Kunden, Höhe 2
println(v.anzahl() + " Kunden, Höhe " + v.hoehe());
// erwartet: Pizzafan
println(v.suche(815).getPseudonym());
// erwartet: true (0043 gibt es nicht)
println(v.suche(43) == null);

// Anfragen aus Ihrem Schnittstellenvertrag eintragen:
// Bestellung 17, Kunde 0042
String anfrage1 = "________";
// Bestellung 18, Kunde 0043 (unbekannt)
String anfrage2 = "________";
// erwartet laut Protokollblatt: ________
println(v.beantworte(anfrage1));
// erwartet laut Protokollblatt: ________
println(v.beantworte(anfrage2));
// unlesbare Anfrage; erwartet laut Protokollblatt: ________
println("[" + v.beantworte("01X") + "]");
Listing V1: Selbsttest in Kundenverzeichnis.java
Gerüst der Klassen Kunde und Kundenverzeichnis anzeigen
class Kunde {
   private int nr;
   private String pseudonym;
   private String adresse;
   private int zeile;
   private int spalte;

   public Kunde(int nr, String pseudonym, String adresse,
                int zeile, int spalte) {
      this.nr = nr;
      this.pseudonym = pseudonym;
      this.adresse = adresse;
      this.zeile = zeile;
      this.spalte = spalte;
   }

   public int getNr() { return nr; }
   public String getPseudonym() { return pseudonym; }
   public String getAdresse() { return adresse; }
   public int getZeile() { return zeile; }
   public int getSpalte() { return spalte; }
}

class Kundenverzeichnis {
   // Feldpositionen Ihres Anfrageformats
   // TODO Teil d: Werte laut Schnittstellenvertrag eintragen
   private int ANFRAGE_LAENGE = 0;
   private int POS_KUNDENNR = 0;

   private BinTree wurzel = new BinTree();

   public void fuegeEin(Kunde k) {
      fuegeEin(wurzel, k);
   }

   private void fuegeEin(BinTree b, Kunde k) {
      // TODO Teil a
   }

   // Kunde zur Nummer oder null
   public Kunde suche(int nr) {
      // TODO Teil b
      return null;
   }

   public int anzahl() {
      return anzahl(wurzel);
   }

   private int anzahl(BinTree b) {
      if (b.isEmpty()) {
         return 0;
      }
      return 1 + anzahl(b.getLeft()) + anzahl(b.getRight());
   }

   public int hoehe() {
      return hoehe(wurzel);
   }

   private int hoehe(BinTree b) {
      // TODO Teil c
      return 0;
   }

   public void zeigeSortiert() {
      println("--- Kundenverzeichnis ---", Color.aquamarine);
      inorder(wurzel);
   }

   private void inorder(BinTree b) {
      // TODO Teil c
   }

   // Antwort im Format laut Schnittstellenvertrag
   public String beantworte(String anfrage) {
      // TODO Teil d
      return "";
   }

   public String mitNullen(int zahl, int stellen) {
      String s = "" + zahl;
      while (s.length() < stellen) {
         s = "0" + s;
      }
      return s;
   }
}
Listing V2: Gerüst der Klassen Kunde und Kundenverzeichnis

Ziel: Kunden landen an der richtigen Stelle, doppelte Nummern werden gemeldet. Fertig, wenn: Der doppelte Kunde 42 erzeugt eine Meldung.

Implementieren Sie fuegeEin(b, k) rekursiv. Eine Kundennummer, die schon vorhanden ist, wird nicht noch einmal eingefügt, sondern gemeldet.

Hilfe 1: Was passiert, wenn b leer ist? Was, wenn nicht?
Hilfe 2: Ist der Baum leer, bekommt er mit b.setItem(k) den Kunden als Wurzel; laut Abitur-Signatur erhält er dabei zwei leere Teilbäume. Sonst holen Sie den vorhandenen Kunden mit Kunde vorhanden = (Kunde) b.getItem(); und vergleichen die Nummern.
Hilfe 3: Je nach Vergleich: fuegeEin(b.getLeft(), k), fuegeEin(b.getRight(), k) oder Meldung „schon vergeben“.

Ziel: Eine Suche ohne Rekursion, die nie getItem() auf einem leeren Baum aufruft. Fertig, wenn: Der Selbsttest Pizzafan und true zeigt.

Stellen Sie suche(nr) zuerst auf Papier als Struktogramm dar (mit einer Schleife, die von der Wurzel aus nach unten läuft), und implementieren Sie es dann. Wird die Nummer nicht gefunden, ist das Ergebnis null.

Hilfe 1: Eine Variable b zeigt auf den aktuellen Teilbaum. Was ist zu tun, solange er nicht leer ist?

Hilfe 2: Ergänzen Sie die Lücken:

b ← wurzel
solange nicht b.isEmpty()
k ← b.getItem()
nr = k.getNr()wahrfalsch
gib k zurück
____wahrfalsch
b ← ____
b ← ____
gib null zurück
Struktogramm V1: suche(nr: Ganzzahl): Kunde
Hilfe 3: Ohne die Prüfung b.isEmpty() würde getItem() auf einem leeren Baum aufgerufen – das muss laut Abitur-Hinweisen ausgeschlossen werden. Beim Lesen umwandeln: Kunde k = (Kunde) b.getItem();

Ziel: Sie können nachweisen, dass Ihr Baum Bedingung 1 erfüllt. Fertig, wenn: Der Selbsttest 3 Kunden, Höhe 2 zeigt und Ihr geplanter Baum aus allen zwölf Kunden die Höhe 4 hat.

Implementieren Sie hoehe(b) (leerer Baum: 0) und inorder(b) (alle Kunden aufsteigend nach Kundennummer: Nummer, Pseudonym, Adresse). Testen Sie mit beiden Einfügereihenfolgen aus Aufgabe 1.

Hilfe 1: Höhe = 1 + größere Höhe der beiden Teilbäume (Math.max).
Hilfe 2: Inorder: erst den linken Teilbaum ausgeben, dann die Wurzel, dann den rechten.

Ziel: Die Antwort entspricht genau Ihrem Vertrag. Fertig, wenn: Die drei beantworte-Zeilen Ihre eingetragenen Erwartungen zeigen.

Tragen Sie die Feldpositionen Ihres Anfrageformats ein und implementieren Sie beantworte(anfrage). Anfragen mit falscher Länge oder unlesbarer Kundennummer werden so behandelt, wie Ihr Vertrag es festlegt.

Hilfe 1: Die Kundennummer lesen Sie Ziffer für Ziffer wie mit zahlAus und prüfen dabei jedes Zeichen.
Hilfe 2: Feste Breiten in der Antwort: mitNullen(k.getZeile(), 2).
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Ihr Modul besteht den Selbsttest (Meilenstein M2). Prüfen Sie noch:

Aufgaben: Station KUNDEN anbinden

Kopieren Sie Kunde und Kundenverzeichnis ohne das Hauptprogramm in den Workspace mit Ihrer Station und setzen Sie rufzeichen = "KUNDEN".

Ihr Bearbeitungsfortschritt:0%
Aufgabe 3 (Gruppenarbeit): Das Verzeichnis geht auf Sendung

Material: Ihre Station, Kundenliste, Ihre geplante Einfügereihenfolge.

Beim Start werden die Kunden in Ihrer geplanten Reihenfolge eingefügt. verarbeite beantwortet jede ADR-Anfrage an den Absender.

Hilfe 1: Das Laden gehört in eine Methode lade() der Station, die das Hauptprogramm vor dem Verbinden aufruft.
Hilfe 2: An wen geht die Antwort? p.getAbsender(). Was tun Sie, wenn beantworte laut Ihrem Vertrag nichts liefern soll?

Testen Sie im Gruppen-Sitzungscode mit der Zentrale: bekannte Kunden, unbekannter Kunde, mehrere Bestellungen schnell hintereinander, 10 % Verlust. Halten Sie Testfall – erwartet – beobachtet – Ursache fest. Prüfen Sie im Mitschnitt (Lausch-Client oder Logbuch), dass keine Namen, Pseudonyme und Adressen übertragen werden.

Hilfe 1: Wenn die Zentrale nicht reagiert: Stimmen Typ (ADR), Länge der Anfrage und Reihenfolge der Felder in beiden Programmen überein?
Hilfe 2: Ist die Zentrale noch nicht bereit, schicken Sie Anfragen von einer Station mit rufzeichen = "ZENTRA" und demo = false von Hand – oder testen Sie gegen die Ersatzstation in FN-<Kurs>-TEST.
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Ihr Verzeichnis ist auf Sendung (Meilenstein M3). Prüfen Sie:

Aufgaben: Recht auf Löschung und ausgeglichene Bäume eA

Kundinnen und Kunden dürfen verlangen, gelöscht zu werden – und der Baum soll trotzdem flach bleiben.

Ihr Bearbeitungsfortschritt:0%
Aufgabe 4 (Partnerarbeit): Einen Kunden löschen

Material: Lina Wolf (0271) schreibt: „Bitte löschen Sie alle meine Daten.“ Nach Art. 17 DSGVO (Recht auf Löschung) muss Food Now! personenbezogene Daten löschen, sobald sie für den Zweck nicht mehr nötig sind und keine Aufbewahrungspflicht besteht. Bedingung 4 Ihrer Karte: Löschen ohne Neuaufbau des Baums.

Löschen Sie im Baum aus Aufgabe 1 a) nacheinander 0077, dann 1200, dann 0350. Beschreiben Sie für jeden Fall die Regel und zeichnen Sie den Baum danach.

Hilfe 1: Fall 1: Der Knoten ist ein Blatt. Fall 2: Er hat genau einen nicht leeren Teilbaum. Fall 3: Er hat zwei.
Hilfe 2: Fall 3: Ersetzen Sie den Kunden durch den kleinsten Kunden im rechten Teilbaum und löschen Sie diesen dort. Warum bleibt die Suchbaum-Eigenschaft erhalten?

Implementieren Sie loesche(nr) mit einer rekursiven Hilfsmethode. Nutzen Sie nur die Abitur-Operationen von BinTree (setItem, setLeft, setRight, setEmpty, isLeaf …). Testen Sie die drei Fälle aus Teil a) mit zeigeSortiert und hoehe.

Hilfe 1: Fall 2 ohne Zugriff auf den Elternknoten: Kopieren Sie Inhalt und Teilbäume des einzigen Kindes in den aktuellen Knoten.
Hilfe 2: Den kleinsten Knoten im rechten Teilbaum findet eine Schleife „gehe nach links, solange der linke Teilbaum nicht leer ist“.

Beurteilen Sie: Ist Lina Wolf nach loesche(271) „vergessen“? Beziehen Sie das Logbuch, die Kundenliste des Kundenbüros und die Aufbewahrungspflicht für Rechnungen ein.

Hilfe 1: Wo steht die Kundennummer 0271 sonst noch? Denken Sie an jede Bestellung von KUNDE1 und jede Adressanfrage, die alle Stationen mithören.
Aufgabe 5 (Partnerarbeit): Den Baum ausgleichen

Nach vielen Neuanmeldungen mit aufsteigenden Nummern wird der Baum hoch. Implementieren Sie ausgleichen(): Alle Kunden werden inorder in eine DynArray gesammelt; daraus wird rekursiv ein neuer Baum gebaut, dessen Wurzel jeweils das mittlere Element ist. Testen Sie mit dem Baum aus Aufgabe 1 a).

Hilfe 1: baue(liste, von, bis): Ist von > bis, entsteht ein leerer Baum. Sonst ist mitte = (von + bis) / 2 die Wurzel, links steht baue(liste, von, mitte − 1), rechts baue(liste, mitte + 1, bis).
Hilfe 2: Der Konstruktor new BinTree(inhalt) erzeugt einen Baum mit dieser Wurzel und zwei leeren Teilbäumen.

Schätzen Sie für 4 000 Kunden ab: Wie viele Vergleiche braucht eine Suche höchstens (sortiert eingefügt / ausgeglichen / lineare Liste)? Wie oft sollte ausgeglichen werden?

Hilfe 1: \(2^{12} = 4096\).
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Ihre Erweiterung läuft (Meilenstein M4). Prüfen Sie:

Sicherung

Definition: Binärer Suchbaum

Ein Binärbaum, in dem für jeden Knoten alle Schlüssel im linken Teilbaum kleiner und alle im rechten Teilbaum größer sind als sein eigener Schlüssel.

Merke

In einem binären Suchbaum stehen links kleinere, rechts größere Schlüssel. Einfügen und Suchen gehen von der Wurzel aus; der Aufwand entspricht höchstens der Höhe des Baums – im besten Fall etwa \(\log_2 n\), im schlechtesten n. Die Höhe hängt von der Einfügereihenfolge ab. Jede Operation prüft zuerst isEmpty(); gelesene Inhalte werden mit (Kunde) umgewandelt. Datensparsamkeit beginnt beim Entwurf: Was nicht gespeichert oder gesendet wird, kann niemand mitlesen. Kundennummer und Pseudonym schützen, machen die Daten aber nicht anonym.

Infobox: Schnittstelle zum Go-Live

Diese Pakete tauscht das Kundenverzeichnis mit der Zentrale aus.

Tabelle V2: Pakete des Kundenverzeichnisses
RichtungTypPartnerNutzdaten
empfängtADRZENTRAAnfrage laut Vertrag
sendetADRZENTRAAntwort laut Vertrag, auch „unbekannt“
Plan-Check

Vergleichen Sie Ihren Plan aus dem Einstieg mit Ihrer fertigen Station: Welche Plan-Punkte haben sich bestätigt, welche mussten Sie ändern – und warum?

Rückbezug: Kundin 3987 und Pizza Paradiso

Ein gut aufgebauter Suchbaum findet Kundin 3987 unter 4 000 Kunden mit höchstens 12 Vergleichen statt bis zu 4 000. Über Funk gehen weder Name noch Telefonnummer, sondern nur, was die Lieferung braucht – Pizza Paradiso kann daraus keine Werbung mehr adressieren. Ganz anonym ist das Liefernetz trotzdem nicht: Wer lange mithört, kann aus der Lage auf Adressen schließen.


Abteilung Kasse

Worum es geht: Jede Station liest die Zahlungen mit – auch nachdem die Kasse verschlüsselt. → Die Kasse entwirft einen Klartext, den Vigenère vollständig verschlüsselt, führt ein Kassenbuch ohne Doppelbuchungen und regelt, wie der Schlüssel zur Kurierin kommt.

Einstieg: Alle lesen mit

Störung im Liefernetz (Gruppenarbeit)

Am Ende der ersten Probe zeigt der Lausch-Client am Beamer, was alle Stationen mitgehört haben:

19:21:55  KURIR1 → KASSE1  ZAH  ZAHLUNG 19,50 EUR KUNDE 0042
    // Fortsetzung: KARTE
19:24:10  KURIR1 → KASSE1  ZAH  ZAHLUNG 9,50 EUR KUNDE 1200
    // Fortsetzung: BAR
Mitschnitt KA1: Zahlungen im Klartext

Die Kasse reagiert sofort und verschlüsselt ab jetzt mit Vigenère (Schlüssel PIZZA), wie auf der Kryptologie-Seite gelernt. Am nächsten Abend:

20:05:31  KURIR1 → KASSE1  ZAH  OIGKUCO 19,50 DTR ZCMCE 0042
    // Fortsetzung: ZIQSE
20:05:40  PIZPAR → ALLE__  STA  Umsatz heute 312,40 EUR :-)
Mitschnitt KA2: Zahlungen mit Vigenère

Pizza Paradiso kennt weiterhin jeden Betrag und jede Kundennummer. Außerdem steht der Schlüssel PIZZA im Quelltext der Kurier-Gruppe – und den haben schon drei Gruppen gesehen.

Leitfrage: Wie muss eine Zahlung aussehen und übertragen werden, damit Mithörer weder Betrag noch Bestellung erfahren?

Nebenfragen:

  1. Warum hilft die Vigenère-Verschlüsselung hier fast nichts? Was müsste sich am Klartext ändern?
  2. Wie kommt der Schlüssel zur Kurierin, ohne dass ihn alle anderen erfahren?

Unser Plan

Sammeln Sie in der Gruppe: Problem → Idee → offene Frage.

  • Markieren Sie im verschlüsselten Mitschnitt alles, was ein Angreifer noch lesen kann.
  • Wie könnte man Ziffern so umschreiben, dass Vigenère sie verschlüsselt? (Verschlüsselt wird nur A–Z.)
  • Sammeln Sie Wege, einen Schlüssel zu übergeben. Welche sind sicher, welche bequem? Wie verhindert die Kasse, dass eine Bestellung zweimal gebucht wird?

Tragen Sie den Plan als Protokollblatt v0.1 ein (Abschnitte 2, 3 und 6) und zeigen Sie ihn der Lehrkraft (Plan-Ticket). Danach beginnt Aufgabe 1.

Bedingungskarte KA-a
  1. Vigenère nach Abitur-Konvention (nur A–Z).
  2. Kein Bestandteil der Zahlung (Bestellnummer, Betrag in Cent, Zahlungsart) ist im Geheimtext lesbar oder an Wortgrenzen erkennbar.
  3. Eine Bestellung wird nur einmal gebucht.
  4. eA Kein Schlüssel steht im Quelltext.
  5. eA Gefälschte Zahlungen werden erkannt.
Bedingungskarte KA-b
  1. Vigenère nach Abitur-Konvention (nur A–Z).
  2. Die Zahlungsart steht an erster Stelle, der Betrag wird in 10-Cent-Schritten übertragen; kein Bestandteil ist im Geheimtext lesbar.
  3. Eine Bestellung wird nur einmal gebucht; Zahlungen mit dem Betrag 0,00 € werden abgewiesen.
  4. eA Kein Schlüssel steht im Quelltext.
  5. eA Gefälschte Zahlungen werden erkannt.

Aufgaben: Die Zahlung entwerfen

Ergebnis dieses Abschnitts: Zahlungsformat und Schlüsselregel im Protokollblatt und im Schnittstellenvertrag mit den Kurier-Gruppen.

Ihr Bearbeitungsfortschritt:0%
Aufgabe 1 (Gruppenarbeit): Was Vigenère schützt – und was nicht

Material: Vigenère-Quadrat (Kryptologie-Seite), Mitschnitte aus dem Einstieg. Konvention nach den Abitur-Hinweisen: Nur A–Z wird verschlüsselt; andere Zeichen bleiben unverändert, und der Schlüssel rückt dabei nicht weiter.

Verschlüsseln Sie ZAHLUNG 19,50 EUR BESTELLUNG 017 mit dem Schlüssel HASE nach dem Vigenère-Verfahren. Markieren Sie, was ein Angreifer danach noch lesen oder erschließen kann.

Hilfe 1: Z + H: Z ist Position 25, H Position 7; (25 + 7) mod 26 = 6 → G.
Hilfe 2: Beim Leerzeichen und bei den Ziffern bleibt der Schlüssel stehen: Nach ZAHLUNG (Schlüssel H A S E H A S) geht es bei EUR mit E weiter.
Hilfe 3: Was verraten Wortlängen und Wortgrenzen, wenn man ahnt, welche Wörter in einer Zahlung vorkommen?

Entwerfen Sie ein Klartextformat für eine Zahlung, das Bedingung 2 Ihrer Karte erfüllt (Bestellnummer, Betrag, Zahlungsart B = bar / K = Karte), als Formattabelle (Position, Länge, Inhalt, Wertebereich, Beispiel). Verschlüsseln Sie das Beispiel „Bestellung 017, 19,50 €, Karte“ mit HASE und prüfen Sie: Was kann ein Angreifer jetzt noch erkennen?

Hilfe 1: Vigenère verschlüsselt nur A–Z. Was passiert, wenn Sie jede Ziffer durch einen Buchstaben ersetzen?
Hilfe 2: Feste Längen statt Trennzeichen: Dann gibt es keine Leerzeichen und keine Wortgrenzen, und der Empfänger zerlegt mit substring.
Hilfe 3: Was ist der größte Betrag, den Ihr Format darstellen kann? Diese Grenze gehört ins Protokollblatt.

Legen Sie fest, wie der Schlüssel zu den Kurier-Gruppen kommt, wo er im Programm steht und wann er gewechselt wird. Beurteilen Sie Ihre Regel: Wer kann den Schlüssel trotzdem erfahren?

Hilfe 1: Darf der Schlüssel in einem Funkpaket stehen? Darf er im Quelltext stehen, den andere Gruppen sehen?
Hilfe 2: Je länger der Schlüssel und je öfter er wechselt, desto schwerer wird ein Angriff (Kasiski-Test, bekannter Klartext).
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Ihr Entwurf steht. Prüfen Sie ihn:

Aufgaben: Verschlüsseln und buchen

Implementieren Sie die Klassen Kasse, Zahlung und Kassenbuch als eigene Datei Kasse.java und testen Sie ohne Netz. Die Klassen Kasse und Zahlung geben Sie danach an die Kurier-Gruppen weiter.

Ihr Bearbeitungsfortschritt:0%
Aufgabe 2 (Partnerarbeit): Vigenère und die Klasse Zahlung

Material: Selbsttest und Gerüst. Tragen Sie die erwarteten Werte zu Ihrem Klartextformat vor dem Programmieren ein.

// ---- Selbsttest (Hauptprogramm) ----
Kasse kasse = new Kasse();
// erwartet: REJVS
println(kasse.vigenereVer("HALLO", "KEY"));
// erwartet: GAZPBNY 19,50 IBR
println(kasse.vigenereVer("ZAHLUNG 19,50 EUR", "HASE"));
// erwartet: HALLO
println(kasse.vigenereEnt("REJVS", "KEY"));

Zahlung z = new Zahlung(17, 1950, 'K');
String klar = z.alsKlartext();
// erwartet laut Protokollblatt: ________
println(klar);
String geheim = kasse.vigenereVer(klar, "HASE");
// erwartet laut Protokollblatt: ________
println(geheim);
String zurueckKlar = kasse.vigenereEnt(geheim, "HASE");
Zahlung zurueck = Zahlung.ausKlartext(zurueckKlar);
// erwartet: 17 1950 K
println(zurueck.getBestellnr() + " " + zurueck.getCent()
        + " " + zurueck.getArt());
// erwartet: true (zu kurz für jedes Format)
println(Zahlung.ausKlartext("ABC") == null);
Listing KA1: Selbsttest in Kasse.java
Gerüst der Klassen Kasse und Zahlung anzeigen
class Kasse {

   // Vigenère verschlüsseln (nur A-Z)
   public String vigenereVer(String text, String schluessel) {
      // TODO Teil a
      return "";
   }

   // Vigenère entschlüsseln
   public String vigenereEnt(String text, String schluessel) {
      // TODO Teil b
      return "";
   }

   public String mitNullen(int zahl, int stellen) {
      String s = "" + zahl;
      while (s.length() < stellen) {
         s = "0" + s;
      }
      return s;
   }
}

class Zahlung {
   private int bestellnr;
   private int cent;
   // 'B' bar, 'K' Karte
   private char art;

   public Zahlung(int bestellnr, int cent, char art) {
      this.bestellnr = bestellnr;
      this.cent = cent;
      this.art = art;
   }

   public int getBestellnr() { return bestellnr; }
   public int getCent() { return cent; }
   public char getArt() { return art; }

   // Klartext im Format laut Schnittstellenvertrag
   public String alsKlartext() {
      // TODO Teil c
      return "";
   }

   // Gegenstück; null, wenn der Text nicht ins Format passt
   public static Zahlung ausKlartext(String k) {
      // TODO Teil c
      return null;
   }
}
Listing KA2: Gerüst der Klassen Kasse und Zahlung

Ziel: Verschlüsseln nach Abitur-Konvention. Fertig, wenn: Der Selbsttest REJVS und GAZPBNY 19,50 IBR zeigt.

Stellen Sie den Algorithmus zuerst auf Papier als Struktogramm dar und implementieren Sie dann vigenereVer.

Hilfe 1: Sie brauchen zwei Zähler: i läuft über den Text, j über den Schlüssel. Wann darf j weiterrücken?
Hilfe 2: Verschiebung des passenden Schlüsselbuchstabens: int k = (int) schluessel.charAt(j % schluessel.length()) - 65;
Hilfe 3: Neues Zeichen: (char) (((int) c - 65 + k) % 26 + 65); j wird nur bei einem Großbuchstaben erhöht.

Ziel: Entschlüsseln ist das Spiegelbild. Fertig, wenn: Der Selbsttest HALLO zeigt.

Implementieren Sie vigenereEnt. Begründen Sie im Protokollblatt, warum man vor % 26 die Zahl 26 addiert, und geben Sie an, zwischen welchen Werten die Zahl vor % 26 dann liegt.

Hilfe 1: Entschlüsseln heißt: Verschiebung abziehen.
Hilfe 2: (int) c - 65 - k kann negativ sein; in Java ergibt % dann einen negativen Rest.

Ziel: Ihr Klartextformat läuft als Code. Fertig, wenn: Der Selbsttest Ihre eingetragenen Werte und 17 1950 K zeigt.

Implementieren Sie alsKlartext und ausKlartext nach Ihrem Format. ausKlartext liefert null, wenn die Länge nicht stimmt oder ein Zeichen nicht ins Format passt.

Hilfe 1: Die einzelnen Ziffern einer Zahl bekommen Sie mit / und %: Für 1950 sind das 1950 / 1000 % 10, 1950 / 100 % 10, 1950 / 10 % 10, 1950 % 10.
Hilfe 2: Ziffer → Buchstabe: (char) (ziffer + 65); Buchstabe → Ziffer: (int) c - 65. Prüfen Sie beim Zurückwandeln, ob das Ergebnis zwischen 0 und 9 liegt.
Aufgabe 3 (Partnerarbeit): Das Kassenbuch

Material: Gerüst der Klasse Kassenbuch (in dieselbe Datei)

class Kassenbuch {
   private DynArray zahlungen = new DynArray();

   // false, wenn die Bestellung schon bezahlt ist
   public boolean buche(Zahlung z) {
      // TODO Teil a
      return false;
   }

   // 1950 -> "19,50 EUR"
   public String alsEuro(int cent) {
      // TODO Challenge
      return "";
   }

   // Anzahl der Zahlungen, Umsatz, davon bar
   public void tagesabschluss() {
      // TODO Challenge
   }
}
Listing KA3: Gerüst der Klasse Kassenbuch

Ziel: Keine Bestellung wird zweimal gebucht. Fertig, wenn: buche für 17/1950/K, 18/950/B und noch einmal 17 die Werte true, true, false liefert.

Implementieren Sie buche: Ist die Bestellnummer schon im Kassenbuch, wird nicht gebucht und false zurückgegeben. Erklären Sie im Protokollblatt, warum eine Zahlung überhaupt zweimal ankommen kann, obwohl der Kern Duplikate erkennt. (Karte KA-b: Weisen Sie auch Zahlungen mit dem Betrag 0,00 € ab.)

Hilfe 1: Lineare Suche durch die Reihung; beim Lesen umwandeln: ((Zahlung) zahlungen.getItem(i)).getBestellnr().
Hilfe 2: Der Kern erkennt nur Duplikate desselben Pakets (gleiche Seq). Was passiert, wenn die Kurierin abstürzt und neu startet – oder jemand ein altes Paket erneut sendet?

Implementieren Sie alsEuro und tagesabschluss (Anzahl der Zahlungen, Umsatz, davon bar). Testen Sie mit 17/1950/K, 18/950/B und einer Doppelbuchung von 17.

Hilfe 1: Euro = cent / 100, Rest = cent % 100; ein einstelliger Rest braucht eine führende Null (9,05).
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Ihr Modul besteht den Selbsttest (Meilenstein M2). Prüfen Sie noch:

Aufgaben: Station KASSE1 und Angriff

Kopieren Sie Ihre Klassen ohne das Hauptprogramm in den Workspace mit Ihrer Station (rufzeichen = "KASSE1").

Ihr Bearbeitungsfortschritt:0%
Aufgabe 4 (Gruppenarbeit): Die Kasse geht auf Sendung

Material: Ergänzung der Station

// in der Station KASSE1
private Kasse kasse = new Kasse();
private Kassenbuch buch = new Kassenbuch();
private String schluessel = "";

// Hauptprogramm vor dem Verbinden:
// station.setSchluessel(Input.readString("Schlüssel:"));
public void setSchluessel(String s) {
   schluessel = s;
}

private synchronized void verarbeite(Paket p, String text) {
   if (p.getTyp().equals("ZAH")) {
      // TODO Teil a
   }
}
Listing KA4: Ergänzung der Station KASSE1

Ergänzen Sie verarbeite: Bei ZAH entschlüsseln, in eine Zahlung umwandeln, buchen und das Ergebnis ausgeben („gebucht“, „doppelt – nicht gebucht“, „unlesbar“).

Hilfe 1: Reihenfolge: vigenereEnt → Zahlung.ausKlartext → bei null „unlesbar“ → sonst buche.
Hilfe 2: Ein falscher Schlüssel ergibt meist Buchstaben, die nicht ins Format passen – dann liefert ausKlartext null.

Testen Sie mit einer Kurier-Gruppe: richtige Zahlung, falscher Schlüssel, dieselbe Zahlung zweimal, 20 % Fehler im Störkanal. Prüfen Sie im Lausch-Client, dass kein Betrag und keine Bestellnummer lesbar sind. Halten Sie Testfall – erwartet – beobachtet – Ursache fest.

Hilfe 1: Wenn alles „unlesbar“ ist: Stimmen Schlüssel und Klartextformat (Reihenfolge, Längen, Buchstabencodierung der Ziffern) bei beiden Gruppen überein?
Hilfe 2: Ist die Kurier-Gruppe noch nicht bereit, senden Sie Zahlungen von einer Station mit rufzeichen = "KURIR1" und demo = false von Hand.
Aufgabe 5 (Partnerarbeit): Angriff mit bekanntem Klartext

Material: Die Kasse des Vorjahres hat ihr Format an die Pinnwand gehängt: Bestellnummer (3 Zeichen), Betrag in Cent (4 Zeichen), Zahlungsart (1 Zeichen), jede Ziffer als Buchstabe (0 = A … 9 = J). Pizza Paradiso hörte damals mit:

21:10:02  KURIR1 → ALLE__  STA  017LIE
21:10:02  KURIR1 → KASSE1  ZAH  HBZFQFSO
21:14:40  KURIR1 → ALLE__  STA  018LIE
21:14:41  KURIR1 → KASSE1  ZAH  HBAEQFSF
Mitschnitt KA3: Statusmeldung und Zahlung kurz hintereinander

Zeigen Sie, wie Pizza Paradiso aus den Statusmeldungen und den Geheimtexten den Schlüssel bestimmt, und entschlüsseln Sie die zweite Zahlung (Angriff mit bekanntem Klartext). Übertragen Sie den Angriff auf Ihr Format: Welche Teile Ihres Klartexts kann ein Mithörer kennen oder raten?

Hilfe 1: Direkt vor der Zahlung steht die Statusmeldung im Klartext: Die Bestellnummer ist 017, also beginnt der Klartext mit ABH.
Hilfe 2: Schlüsselbuchstabe = Geheimbuchstabe − Klartextbuchstabe (mod 26). Für die Zahlungsart gibt es nur zwei Möglichkeiten – die zweite Zahlung entscheidet.

Beurteilen Sie drei Vorschläge: (1) längerer Schlüssel, (2) Bestellnummer weglassen, (3) vor den Klartext zwei zufällige Buchstaben setzen. Was hilft wirklich?

Hilfe 1: Wie viel bekannter Klartext reicht jeweils noch aus? Kann die Kasse ohne Bestellnummer noch buchen?
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Ihre Kasse ist auf Sendung (Meilenstein M3). Prüfen Sie:

Aufgaben: Schlüsseltausch und Signatur eA

Der Schlüssel soll nicht mehr auf Papier wandern, und gefälschte Zahlungen sollen auffallen.

Ihr Bearbeitungsfortschritt:0%
Aufgabe 6 (Partnerarbeit): Diffie-Hellman über KEY-Pakete

Material: Kryptologie-Seite (Diffie-Hellman-Verfahren); öffentlich vereinbart: p = 23, g = 5. Fertige Methoden für die Klasse Kasse:

// basis hoch exponent mod m (Zwischenergebnisse klein halten)
public int potenzMod(int basis, int exponent, int m) {
   int ergebnis = 1;
   for (int i = 0; i < exponent; i++) {
      ergebnis = (ergebnis * basis) % m;
   }
   return ergebnis;
}

// aus der gemeinsamen Zahl einen Schlüssel aus 3 Buchstaben
public String schluesselAus(int zahl) {
   String s = "";
   int z = zahl;
   for (int i = 0; i < 3; i++) {
      s = s + (char) (z % 26 + 65);
      z = z / 26 + 7 * (i + 1);
   }
   return s;
}
Listing KA5: Methoden für den Schlüsseltausch

Die Kurierin wählt geheim a = 6, die Kasse b = 15. Berechnen Sie A, B, den gemeinsamen Schlüssel K und schluesselAus(K). Zeichnen Sie ein Sequenzdiagramm des Austauschs mit KEY-Paketen: Was steht öffentlich in den Nutzdaten?

Hilfe 1: \(A = g^a \bmod p = 5^6 \bmod 23\). Rechnen Sie schrittweise: 5, 2, 10, 4, 20, 8.
Hilfe 2: \(K = B^a \bmod p = A^b \bmod p\).

Entwerfen Sie mit den Kurier-Gruppen das KEY-Format und implementieren Sie die Seite der Kasse: Auf jedes KEY wählt die Kasse ein zufälliges b, antwortet mit B und merkt sich K je Kurier (Klasse Schluesselpartner mit Rufzeichen und K in einer DynArray). Bei ZAH sucht sie den Partner zum Absender und entschlüsselt mit schluesselAus(K); ohne Partner: „kein Schlüssel – Zahlung abgelehnt“.

Hilfe 1: Zufallszahl: int b = 2 + (int) (Math.random() * 20);. Prüfen Sie die Ziffern im KEY mit zahlAus, bevor Sie rechnen.
Hilfe 2: Sendet derselbe Kurier erneut KEY, ersetzen Sie den vorhandenen Eintrag mit setItem – sonst findet die Suche weiter den alten Schlüssel.

Beurteilen Sie den Handshake: (1) Wie viele verschiedene Schlüssel kann schluesselAus bei p = 23 überhaupt liefern? (2) Pizza Paradiso sendet ein KEY-Paket mit Absender KURIR1. Was passiert? (3) Was müsste man ändern?

Hilfe 1: Welche Werte kann K bei p = 23 annehmen, wenn g = 5 alle Reste 1 bis 22 erzeugt? Probieren Sie schluesselAus für einige K aus.
Hilfe 2: Im gemeinsamen Funkkanal kann jeder jedes Absenderfeld beschreiben.
Aufgabe 7 (Partnerarbeit): Gefälschte Zahlungen und Schlüssel erkennen

Material: Signatur mit gemeinsamem Geheimnis – wie auf der Kryptologie-Seite, aber der Hash beachtet die Reihenfolge der Zeichen. Fachlich heißt diese Art von Signatur MAC.

// einfacher Hash, beachtet die Reihenfolge der Zeichen
public int hash(String s) {
   int h = 7;
   for (int i = 0; i < s.length(); i++) {
      h = (h * 31 + (int) s.charAt(i)) % 1000;
   }
   return h;
}

// Signatur = Hash(Text + Geheimnis), 3-stellig angehängt
public String signiere(String text, int geheimnis) {
   return text + mitNullen(hash(text + geheimnis), 3);
}

// die letzten 3 Zeichen sind die Signatur
public boolean pruefeSignatur(String nutzdaten, int geheimnis) {
   if (nutzdaten.length() < 3) {
      return false;
   }
   int ende = nutzdaten.length() - 3;
   String text = nutzdaten.substring(0, ende);
   String sig = nutzdaten.substring(ende);
   return sig.equals(mitNullen(hash(text + geheimnis), 3));
}
Listing KA6: Signatur mit gemeinsamem Geheimnis

Die Kurierin verschlüsselt den Klartext ABHBJFAK (Vorjahresformat) mit CHO (K = 2) und signiert den Geheimtext mit dem Geheimnis 2. Geben Sie die ZAH-Nutzdaten an. Pizza Paradiso ändert den Betrag auf 0,50 €, verschlüsselt mit dem erratenen Schlüssel und hängt die alte Signatur an. Was meldet pruefeSignatur? Bauen Sie die Prüfung in Ihre Kasse ein (Geheimnis = K des Partners).

Hilfe 1: Signiert wird der Geheimtext – so kann die Kasse prüfen, bevor sie entschlüsselt.
Hilfe 2: Die Signatur hängt vom ganzen Text und vom Geheimnis ab. Wer das Geheimnis nicht kennt, kann sie nicht neu berechnen.

Bisher übernimmt die Kasse jedes KEY, in dessen Absenderfeld KURIR1 steht. Mit der RSA-Idee kann KURIR1 seinen öffentlichen Wert so signieren, dass nur er die Signatur erzeugen, aber jeder sie prüfen kann. Schlüsselpaar von KURIR1 (kleine Zahlen): öffentlich n = 33, e = 3; geheim d = 7.

  1. Prüfen Sie, dass \(e \cdot d \bmod 20 = 1\) gilt (20 = (3 − 1) · (11 − 1)).
  2. KURIR1 sendet A = 8. Berechnen Sie die Signatur \(s = A^d \bmod n\) und zeigen Sie, wie die Kasse mit \(s^e \bmod n\) prüft.
  3. Vereinbaren Sie mit den Kurier-Gruppen ein KEY-Format mit Signatur und bauen Sie die Prüfung in die Kasse ein (potenzMod genügt).
  4. Beurteilen Sie: Wie schwer ist es für Pizza Paradiso, zu einem gefälschten A eine passende Signatur zu finden – bei n = 33 und bei echten Schlüssellängen? Woher kennt die Kasse (n, e) von KURIR1 sicher?
Hilfe 1: Rechnen Sie schrittweise: \(8^2 \bmod 33 = 31\), dann immer mit 8 multiplizieren und mod 33 nehmen.
Hilfe 2: Gilt \(s^e \bmod n = A\), stammt die Signatur von jemandem, der d kennt. Anders als beim MAC braucht die Kasse dafür kein gemeinsames Geheimnis.

Pizza Paradiso sendet eine echte, signierte Zahlung einfach noch einmal (Replay). Was passiert? Vergleichen Sie außerdem Prüfsumme (FN/1), MAC und Verschlüsselung: Wogegen schützt jeweils was?

Hilfe 1: Die Signatur ist korrekt – aber was sagt das Kassenbuch?
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Ihre Erweiterung läuft (Meilenstein M4). Prüfen Sie:

Sicherung

Definition: Schlüsselproblem

Bei symmetrischen Verfahren wie Vigenère müssen Sender und Empfänger denselben geheimen Schlüssel besitzen. Ihn sicher zu übergeben, ohne dass Dritte ihn erfahren, ist das Schlüsselproblem.

Merke

Vigenère verschiebt jeden Großbuchstaben um den Wert des passenden Schlüsselbuchstabens; andere Zeichen bleiben stehen. Darum muss der Klartext entworfen werden: nur A–Z, feste Längen, keine Wortgrenzen. Mit bekanntem Klartext lässt sich der Schlüssel direkt zurückrechnen – auch Metadaten wie eine Statusmeldung können ihn verraten. Das Kassenbuch verhindert Doppelbuchungen in der Anwendung. eA Diffie-Hellman löst das Schlüsselproblem, aber nur, wenn die öffentlichen Werte echt sind; ein MAC sichert Zahlungen mit gemeinsamem Geheimnis, eine RSA-Signatur sichert Werte ohne gemeinsames Geheimnis.

Infobox: Schnittstelle zum Go-Live

Diese Pakete und Klassen tauscht die Kasse aus.

Tabelle KA1: Pakete und Klassen der Kasse
RichtungTypPartnerNutzdaten
empfängtZAHKURIRnverschlüsselter Klartext laut Vertrag; eA mit Signatur
eA empfängt / sendetKEYKURIRnöffentlicher Wert laut Vertrag, eA mit RSA-Signatur
liefert vorab–Kurier-GruppenKlassen Kasse, Zahlung; Schlüsselregel
Plan-Check

Vergleichen Sie Ihren Plan aus dem Einstieg mit Ihrer fertigen Kasse: Welche Plan-Punkte haben sich bestätigt, welche mussten Sie ändern – und warum?

Rückbezug: Alle lesen mit

Mit einem entworfenen Klartext aus festen Längen und Buchstaben statt Ziffern sieht Pizza Paradiso nur noch eine Buchstabenfolge ohne Wortgrenzen – kein Betrag, keine Bestellnummer. Das hilft aber nur, solange der Schlüssel geheim bleibt und keine Metadaten den Klartext verraten. Das Kassenbuch bucht jede Bestellung nur einmal, und im eA-Kurs ersetzt Diffie-Hellman den Schlüsselzettel.


Abteilung Funkstrecke eA

Worum es geht: Auf der Richtfunkstrecke zur Außenfiliale kippt jedes hundertste Bit, und Wiederholen hilft kaum. → Die Funkstrecke komprimiert Aufträge mit Huffman, schützt sie mit Hamming(7,4) und korrigiert Fehler beim Empfänger selbst.

Einstieg: Rauschen nach Hasbergen

Störung im Liefernetz (Gruppenarbeit)

Food Now! eröffnet eine Außenfiliale in Hasbergen. Dorthin gibt es nur eine Richtfunkstrecke über die Felder – und die rauscht: Ungefähr jedes hundertste Bit kommt falsch an. Die erste Probe mit FN/1 (Zeichen als 8-Bit-Folgen aus 0 und 1, gesichert mit Prüfsumme, NAK und Wiederholung):

18:00:00  RELAIS → AUSSEN  BIT  Auftrag 017 (136 Bit)
    // NAK
18:00:02  RELAIS → AUSSEN  BIT  Auftrag 017 (136 Bit)
    // NAK
18:00:04  RELAIS → AUSSEN  BIT  Auftrag 017 (136 Bit)
    // ACK
18:00:06  RELAIS → AUSSEN  BIT  Auftrag 018 (136 Bit)
    // NAK
…
18:00:16  RELAIS  Auftrag 018: Abbruch nach 5 Versuchen
Mitschnitt F1: Die erste Probe auf der Richtfunkstrecke

Bei 1 % Bitfehlern kommt ein Auftrag mit 136 Bit nur mit der Wahrscheinlichkeit \(0{,}99^{136} \approx 0{,}25\) unverfälscht an. Im Mittel braucht jeder Auftrag vier Versuche, und fast jeder vierte wird nach fünf Versuchen abgebrochen. Mehr Wiederholungen helfen kaum – jede Wiederholung ist wieder genauso gestört.

Leitfrage: Wie kommen Aufträge über eine Strecke, auf der jedes hundertste Bit kippt, trotzdem fast immer beim ersten Versuch richtig an?

Nebenfragen:

  1. Kann der Empfänger einen Fehler selbst korrigieren, statt um Wiederholung zu bitten? Was kostet das?
  2. Wie kann man einen Auftrag mit weniger Bits übertragen, damit weniger Fehler passieren können?

Unser Plan

Sammeln Sie in der Gruppe: Problem → Idee → offene Frage.

  • Erinnern Sie sich an den (7,4)-Hamming-Code (Codierungsseite, Kern Kapitel 4): Wie viele Fehler pro Block kann er korrigieren?
  • Welche Zeichen kommen in Bestelltexten häufig vor, welche selten? Was folgt daraus für die Länge ihrer Codes?
  • Skizzieren Sie, welche Station was tut: Wer codiert, wer verrauscht, wer decodiert?

Tragen Sie den Plan als Protokollblatt v0.1 ein (Abschnitte 2, 3 und 6) und zeigen Sie ihn der Lehrkraft (Plan-Ticket). Danach beginnt Aufgabe 1.

Bedingungskarte F-a
  1. Bitfehlerrate der Strecke: 1 % (Klasse Rauschen mit 10 Promille).
  2. Ein Auftrag braucht mit Fehlerschutz höchstens 1,5-mal so viele Bit wie der ungeschützte Text mit 7 Bit je Zeichen.
  3. Mindestens 90 % der Aufträge kommen ohne Wiederholung korrekt an.
Bedingungskarte F-b
  1. Bitfehlerrate der Strecke: 2 % (Klasse Rauschen mit 20 Promille).
  2. Ein Auftrag braucht mit Fehlerschutz höchstens 1,3-mal so viele Bit wie der ungeschützte Text mit 7 Bit je Zeichen.
  3. Mindestens 80 % der Aufträge kommen ohne Wiederholung korrekt an.

Aufgaben: Die Strecke entwerfen

Planen Sie Codierung, Fehlerschutz und das Paketformat der Strecke. Halten Sie alles im Protokollblatt fest.

Ihr Bearbeitungsfortschritt:0%
Aufgabe 1 (Gruppenarbeit): Fehler korrigieren, Bits sparen

Material: Codierungstheorie-Seite (Hamming, Huffman), Prüfgruppen nach den Abitur-Hinweisen (Reihenfolge p0 p1 d0 p2 d1 d2 d3, gerade Parität).

Tabelle F1: Welche Datenbits jedes Prüfbit sichert
Prüfbitd0d1d2d3
p0xx–x
p1x–xx
p2–xxx
  1. Codieren Sie die Datenbits 1011, 0100 und 1101.
  2. Empfangen wird 0110111. Bestimmen Sie mit den drei Prüfgruppen die Fehlerstelle und die Datenbits.
  3. Begründen Sie mit dem Mindestabstand, wie viele Fehler pro Block erkannt bzw. korrigiert werden.
Hilfe 1: p0 = (d0 + d1 + d3) mod 2, p1 = (d0 + d2 + d3) mod 2, p2 = (d1 + d2 + d3) mod 2.
Hilfe 2: Beim Prüfen bilden Sie für jede Gruppe die Summe einschließlich Prüfbit mod 2. Die Ergebnisse s0, s1, s2 ergeben die Fehlerstelle s0 + 2·s1 + 4·s2 (1 bis 7; 0 = fehlerfrei).

Erstellen Sie einen Huffman-Baum für PIZZA PIZZA PASTA (das Leerzeichen zählt mit), geben Sie die Codes an und vergleichen Sie die Länge mit 8 Bit je Zeichen. Warum braucht ein präfixfreier Code keine Trennzeichen?

Hilfe 1: Häufigkeiten: Z 4, A 4, P 3, I 2, Leerzeichen 2, S 1, T 1.
Hilfe 2: Immer die beiden seltensten Bäume zu einem neuen verbinden, bis nur noch einer übrig ist; links 0, rechts 1.

Entwerfen Sie den Pakettyp BIT: Was steht in den Nutzdaten, wie erkennt AUSSEN das Ende des Auftrags, woher kennt AUSSEN den Huffman-Baum? Prüfen Sie Bedingung 2 Ihrer Karte für den Auftrag 0172xPIZZA,1xCOLA (Bestellnummer + Bestelltext, 17 Zeichen) in drei Varianten: (1) ungeschützt mit 7 Bit je Zeichen, (2) 8 Bit je Zeichen mit Hamming, (3) Huffman mit Endezeichen (86 Bit) und dann Hamming. Bestimmen Sie für (2) und (3) die Informationsrate.

Hilfe 1: Huffman-Codes kann man nur decodieren, wenn man denselben Baum hat. Den Baum zu übertragen wäre teuer – was ist die Alternative?
Hilfe 2: Hamming braucht Blöcke aus 4 Bit. Die aufgefüllten Nullen könnten als Zeichen gelesen werden – wie verhindern Sie das?
Hilfe 3: 86 Bit werden auf ein Vielfaches von 4 aufgefüllt; jeder 4-Bit-Block wird zu 7 Bit.

Im Liefernetz läuft alles über den zuverlässigen WebSocket; Fehler macht nur der StoerKanal. Für die Funkstrecke verrauscht RELAIS die Hamming-Bits mit der Klasse Rauschen, bevor daraus FN/1-Pakete werden. Erklären Sie, warum die FN/1-Prüfsumme dieses Rauschen nicht bemerkt, und ordnen Sie Hamming, Prüfsumme mit ACK und Huffman den Schichten eines Netzes zu.

Hilfe 1: Über welche Zeichen wird die Prüfsumme berechnet – über die Bits vor oder nach dem Rauschen?
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Ihr Entwurf steht. Prüfen Sie ihn:

Aufgaben: Hamming und Huffman programmieren

Implementieren Sie die Klasse Funkstrecke (Datei Funkstrecke.java) und testen Sie ohne Netz (Bibliothek „Abiturklassen Niedersachsen“ einschalten).

Ihr Bearbeitungsfortschritt:0%
Aufgabe 2 (Partnerarbeit): Kodieren, prüfen, korrigieren

Material: Selbsttest und Gerüst

// ---- Selbsttest (Hauptprogramm) ----
Funkstrecke f = new Funkstrecke();
// erwartet: 0110011
println(f.hammingKodiere("1011"));
// erwartet: 1011 (d1 wird korrigiert)
println(f.hammingDekodiere("0110111"));
// erwartet: 01100111001100 (aufgefüllt zu 1011 0100)
println(f.bitsZuHamming("101101"));
// erwartet: 10110100
println(f.hammingZuBits("01100111001100"));
Listing F1: Selbsttest in Funkstrecke.java
Gerüst der Klasse Funkstrecke anzeigen
class Funkstrecke {

   // Zeichen '0'/'1' -> Zahl 0/1
   private int bit(String s, int i) {
      return (int) s.charAt(i) - 48;
   }

   // 4 Datenbits d0 d1 d2 d3 -> 7 Bit p0 p1 d0 p2 d1 d2 d3
   public String hammingKodiere(String daten) {
      // TODO Teil a
      return "";
   }

   // 7 Bit -> 4 Datenbits; ein Einzelfehler wird korrigiert
   public String hammingDekodiere(String c) {
      // TODO Teil b
      return "";
   }

   // mit 0 auf ein Vielfaches von 4 auffüllen, blockweise kodieren
   public String bitsZuHamming(String bits) {
      // TODO Teil c
      return "";
   }

   // blockweise decodieren; ein unvollständiger Rest entfällt
   public String hammingZuBits(String bits) {
      // TODO Teil c
      return "";
   }
}
Listing F2: Gerüst der Klasse Funkstrecke

Ziel: 4 Datenbits werden zu einem 7-Bit-Block. Fertig, wenn: Der Selbsttest 0110011 zeigt.

Implementieren Sie hammingKodiere. Statt XOR (in der Online-IDE für int nicht erlaubt) rechnen Sie mit Summe mod 2.

Hilfe 1: int d0 = bit(daten, 0); usw.
Hilfe 2: Ergebnis als Text: return "" + p0 + p1 + d0 + p2 + d1 + d2 + d3;

Ziel: Jeder Einzelfehler wird korrigiert. Fertig, wenn: Ein Test über alle 16 Datenblöcke mit jedem möglichen Einzelfehler (112 Fälle) jedes Mal die richtigen Datenbits liefert.

Implementieren Sie hammingDekodiere mit den drei Prüfgruppen (Positionen im 7-Bit-Wort: p0 = 0, p1 = 1, d0 = 2, p2 = 3, d1 = 4, d2 = 5, d3 = 6) und schreiben Sie den Test über alle 112 Fälle.

Hilfe 1: s0 prüft die Positionen 0, 2, 4, 6; s1 die Positionen 1, 2, 5, 6; s2 die Positionen 3, 4, 5, 6.
Hilfe 2: pos = s0 + 2 * s1 + 4 * s2 ist die Stelle (1 bis 7) des falschen Bits.
Hilfe 3: Bit an Stelle pos kippen: c = c.substring(0, pos - 1) + richtig + c.substring(pos); Die Datenbits stehen danach an den Positionen 2, 4, 5 und 6.

Ziel: Beliebig lange Bitfolgen werden geschützt übertragen. Fertig, wenn: Die letzten beiden Zeilen des Selbsttests stimmen.

Implementieren Sie bitsZuHamming (auffüllen, blockweise kodieren) und hammingZuBits (blockweise decodieren; ein unvollständiger Rest wird ignoriert).

Hilfe 1: Auffüllen: while (bits.length() % 4 != 0) { bits = bits + "0"; }
Hilfe 2: Die Schleife in hammingZuBits läuft, solange i + 7 <= bits.length().
Aufgabe 3 (Partnerarbeit): Baum, Codes, Decodieren

Material: Klasse HuffKnoten und die fertigen Methoden baueHuffman und fuegeSortiertEin (in die Klasse Funkstrecke übernehmen). Ein Knoten speichert alle Zeichen seines Teilbaums als Text, z. B. "ZA" mit Häufigkeit 8. Beide Stationen bauen den Baum aus demselben Kodierbuch Funkstrecke.kodierbuch():

// Text, aus dem RELAIS und AUSSEN denselben Huffman-Baum bauen
public static String kodierbuch() {
   return "2xPIZZA,1xCOLA#1xBURGER,2xPOMMES#3xPIZZA,2xSALAT#"
          + "1xPASTA,1xCOLA#1xMENUE(PIZZA(SALAMI,KAESE),COLA)#"
          + "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
}
Listing F3: Das Kodierbuch
Fertiger Code: HuffKnoten, baueHuffman, fuegeSortiertEin
class HuffKnoten {
   // alle Zeichen dieses Teilbaums
   private String zeichen;
   private int haeufigkeit;

   public HuffKnoten(String zeichen, int haeufigkeit) {
      this.zeichen = zeichen;
      this.haeufigkeit = haeufigkeit;
   }

   public String getZeichen() { return zeichen; }
   public int getHaeufigkeit() { return haeufigkeit; }
}

// in der Klasse Funkstrecke:
public BinTree baueHuffman(String text) {
   // Bäume, aufsteigend nach Häufigkeit sortiert
   DynArray liste = new DynArray();
   String gesehen = "";
   for (int i = 0; i < text.length(); i++) {
      char z = text.charAt(i);
      if (!gesehen.contains("" + z)) {
         gesehen = gesehen + z;
         int anzahl = 0;
         for (int j = 0; j < text.length(); j++) {
            if (text.charAt(j) == z) {
               anzahl++;
            }
         }
         HuffKnoten blatt = new HuffKnoten("" + z, anzahl);
         fuegeSortiertEin(liste, new BinTree(blatt));
      }
   }
   while (liste.getLength() > 1) {
      BinTree links = (BinTree) liste.getItem(0);
      BinTree rechts = (BinTree) liste.getItem(1);
      liste.delete(0);
      liste.delete(0);
      HuffKnoten l = (HuffKnoten) links.getItem();
      HuffKnoten r = (HuffKnoten) rechts.getItem();
      HuffKnoten k = new HuffKnoten(l.getZeichen() + r.getZeichen(),
                        l.getHaeufigkeit() + r.getHaeufigkeit());
      BinTree neu = new BinTree(k);
      neu.setLeft(links);
      neu.setRight(rechts);
      fuegeSortiertEin(liste, neu);
   }
   if (liste.isEmpty()) {
      return new BinTree();
   }
   return (BinTree) liste.getItem(0);
}

private void fuegeSortiertEin(DynArray liste, BinTree b) {
   int h = ((HuffKnoten) b.getItem()).getHaeufigkeit();
   int i = 0;
   while (i < liste.getLength() && haeufigkeit(liste, i) <= h) {
      i++;
   }
   liste.insertAt(i, b);
}

// Häufigkeit des Baums an Position i der Liste
private int haeufigkeit(DynArray liste, int i) {
   BinTree b = (BinTree) liste.getItem(i);
   return ((HuffKnoten) b.getItem()).getHaeufigkeit();
}
Listing F4: Fertiger Code zum Bau des Huffman-Baums

Erklären Sie im Protokollblatt Schritt für Schritt, wie baueHuffman den Algorithmus von der Codierungsseite umsetzt. Warum enthält das Kodierbuch am Ende alle Ziffern und Buchstaben?

Hilfe 1: Die dynamische Reihung liste ist immer aufsteigend nach Häufigkeit sortiert – die beiden seltensten Bäume stehen vorn.
Hilfe 2: Was passiert beim Codieren eines Zeichens, das im Kodierbuch nicht vorkommt?

Ziel: Jedes Zeichen bekommt seinen Code aus dem Baum. Fertig, wenn: huffmanKodiere(baum, "0172xPIZZA,1xCOLA#") genau 86 Bit liefert.

Implementieren Sie codeFuer(baum, z) (von der Wurzel aus: links, wenn das Zeichen im linken Teilbaum vorkommt, sonst rechts) und huffmanKodiere(baum, text).

Hilfe 1: Ob ein Zeichen links vorkommt: ((HuffKnoten) b.getLeft().getItem()).getZeichen().contains("" + z) – prüfen Sie vorher, ob der linke Teilbaum leer ist.
Hilfe 2: Sonderfall: Besteht der Baum nur aus einem Blatt, ist der Code "0".

Ziel: Die Rundreise gelingt. Fertig, wenn: bisEnde(huffmanDekodiere(baum, bits)) wieder 0172xPIZZA,1xCOLA liefert.

Implementieren Sie huffmanDekodiere(baum, bits) (Bits ablaufen, am Blatt Zeichen ausgeben, wieder an die Wurzel) und bisEnde(text) (Text bis vor das erste #).

Hilfe 1: Gerät die Suche in einen leeren Teilbaum, passt die Bitfolge nicht zum Baum – dann abbrechen und den bisherigen Text zurückgeben.
Hilfe 2: bisEnde ist eine Schleife mit charAt, die beim ersten # aufhört.
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Ihr Modul besteht den Selbsttest (Meilenstein M2). Prüfen Sie noch:

Aufgaben: Die Strecke in Betrieb nehmen

Jetzt laufen zwei Stationen: RELAIS in der Stadt und AUSSEN in Hasbergen (Station extends WebSocket, zwei Geräte bzw. Konten).

Ihr Bearbeitungsfortschritt:0%
Aufgabe 4 (Gruppenarbeit): RELAIS und AUSSEN

Material: Klasse Rauschen (fertig)

class Rauschen {
   // jedes Bit kippt mit der Wahrscheinlichkeit promille/1000
   public static String verrausche(String bits, int promille) {
      String ergebnis = "";
      for (int i = 0; i < bits.length(); i++) {
         char b = bits.charAt(i);
         if (Math.random() * 1000 < promille) {
            if (b == '0') { b = '1'; } else { b = '0'; }
         }
         ergebnis = ergebnis + b;
      }
      return ergebnis;
   }
}
Listing F5: Die Klasse Rauschen

RELAIS empfängt Lieferaufträge der Zentrale (BST im Format der Zentrale). Es baut daraus den Auftragstext „Bestellnummer + Bestelltext“, codiert ihn nach Ihrem BIT-Format (Huffman mit Endezeichen, dann Hamming), verrauscht ihn laut Bedingungskarte und sendet ihn als BIT an AUSSEN.

Hilfe 1: Bauen Sie den Baum einmal als Attribut, nicht bei jedem Auftrag: private BinTree baum = strecke.baueHuffman(Funkstrecke.kodierbuch()); – das Attribut strecke muss davor stehen.
Hilfe 2: Wo stehen Bestellnummer und Bestelltext im Lieferauftrag der Zentrale? Prüfen Sie die Länge, bevor Sie substring verwenden.

AUSSEN decodiert (Hamming, dann Huffman, dann bis zum Endezeichen), zeigt den Auftrag an und meldet nach einer simulierten Fahrt ABH und LIE für die Bestellnummer.

Hilfe 1: Die Bestellnummer sind die ersten drei Zeichen des decodierten Auftrags – prüfen Sie, ob es Ziffern sind, bevor Sie sie verwenden.
Hilfe 2: In verarbeite darf kein Thread.sleep stehen. Die Fahrt simulieren Sie mit Timer.executeLater(() -> …, 3000);, das danach LIE meldet.

Testen Sie mit der Zentrale (Kunden 9001/9002 im Kundenverzeichnis) und dem Bestellstatus. Wie viele BIT-Pakete erwarten Sie für den Auftrag 0171xPASTA? Vereinbaren Sie, was passiert, wenn trotz Hamming ein Auftrag falsch ankommt (z. B. unlesbare Bestellnummer). Halten Sie Testfall – erwartet – beobachtet – Ursache fest.

Hilfe 1: 0171xPASTA# ergibt Huffman-codiert 53 Bit. Wie viele Zeichen werden daraus nach Auffüllen und Hamming, und wie viele Pakete à 60 Zeichen?
Hilfe 2: Ein falsch decodierter Auftrag ist für FN/1 ein korrektes Paket – wer soll ihn erkennen?
Aufgabe 5 (Partnerarbeit): Messen und beurteilen

Schreiben Sie ein Messprogramm (ohne Netz): 1000-mal 0172xPIZZA,1xCOLA codieren, verrauschen (laut Bedingungskarte), decodieren; zählen Sie die korrekt angekommenen Aufträge – einmal mit Hamming, einmal nur mit Huffman. Vergleichen Sie mit der Rechnung und prüfen Sie Bedingung 3 Ihrer Karte.

Hilfe 1: Ohne Hamming: Wahrscheinlichkeit, dass keines der 86 Bit kippt, ist \((1 – q)^{86}\) bei Bitfehlerrate q.
Hilfe 2: Mit Hamming kommt ein Block richtig an, wenn höchstens ein Bit kippt: \((1-q)^7 + 7q(1-q)^6\); bei 22 Blöcken hoch 22.

Beurteilen Sie für drei Situationen, ob Vorwärtsfehlerkorrektur (FEC, hier Hamming) oder Prüfsumme mit Wiederholung (ARQ) besser ist: (1) Schulnetz, Bitfehlerrate 0,001 %, kurze Laufzeit; (2) unsere Funkstrecke; (3) Raumsonde in 20 Lichtminuten Entfernung. Nutzen Sie Informationsrate und Erfolgswahrscheinlichkeit.

Hilfe 1: Hamming kostet immer 3/7 der Bits, auch wenn kein Fehler auftritt. Wiederholung kostet nur, wenn ein Fehler auftritt – aber dann ein ganzes Paket und eine Wartezeit.
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Ihre Strecke ist in Betrieb (Meilensteine M3 und M4). Prüfen Sie:

Sicherung

Definition: Vorwärtsfehlerkorrektur (FEC)

Fehlerschutz, bei dem der Sender gezielt Prüfbits hinzufügt, sodass der Empfänger Fehler selbst korrigieren kann, ohne um Wiederholung zu bitten. Gegenstück: Fehlererkennung mit Wiederholung (ARQ).

Merke

Der (7,4)-Hamming-Code (Reihenfolge p0 p1 d0 p2 d1 d2 d3, gerade Parität) hat den Mindestabstand 3: Er erkennt zwei und korrigiert einen Fehler je Block; die Informationsrate ist 4/7. Die drei Prüfgruppen ergeben zusammen die Stelle des falschen Bits. Ein Huffman-Code ist präfixfrei und gibt häufigen Zeichen kurze Codes; Sender und Empfänger brauchen denselben Baum. Huffman entfernt Redundanz, Hamming fügt gezielt Redundanz hinzu: Erst komprimieren, dann gegen Fehler schützen.

Infobox: Schnittstelle zum Go-Live

Diese Pakete verarbeitet die Funkstrecke.

Tabelle F2: Pakete der Funkstrecke
StationRichtungTypPartnerNutzdaten
RELAISempfängtBSTZENTRALieferauftrag laut Vertrag (Außenfiliale)
RELAISsendetBITAUSSENlaut Ihrem BIT-Format
AUSSENsendetSTAALLE__NNN + ABH bzw. LIE
Plan-Check

Vergleichen Sie Ihren Plan aus dem Einstieg mit Ihrer fertigen Strecke: Welche Plan-Punkte haben sich bestätigt, welche mussten Sie ändern – und warum?

Rückbezug: Rauschen nach Hasbergen

Statt etwa 25 % kommen mit Huffman und Hamming die allermeisten Aufträge beim ersten Versuch richtig in Hasbergen an (bei 1 % Bitfehlern rund 96 %, bei 2 % noch über 80 %) – und jeder Auftrag ist dabei sogar kürzer als der ungeschützte 8-Bit-Text. Der Empfänger korrigiert einzelne Bitfehler selbst; nur Doppelfehler in einem Block bleiben ein Restrisiko, für das Ihr Protokollblatt eine Regel braucht.


Abteilung Bestellstatus

Worum es geht: Statusmeldungen kommen in unmöglicher Reihenfolge, gehen verloren oder widersprechen sich – und niemand merkt es. → Ein Automat je Bestellung prüft jede Meldung, die Statustafel zeigt den Stand aller Bestellungen und warnt bei unzulässigen Abläufen.

Einstieg: Geliefert, bevor abgeholt

Störung im Liefernetz (Gruppenarbeit)

Herr B. ruft an: „Wo bleibt mein Essen? Ihre App sagt seit zwanzig Minuten ‚wird gekocht‘!“ Ein Blick in die Statusmeldungen des Abends (alle an ALLE__):

19:40:02  ZENTRA → ALLE__  STA  017ANN
19:40:05  ZENTRA → ALLE__  STA  017KOC
19:48:30  KURIR1 → ALLE__  STA  017LIE
19:47:10  KURIR1 → ALLE__  STA  017ABH
    // kam verspätet an
19:52:00  ZENTRA → ALLE__  STA  018ANN
19:53:11  ZENTRA → ALLE__  STA  018STO
19:55:40  KURIR2 → ALLE__  STA  018ABH
20:01:15  ZENTRA → ALLE__  STA  019ANN
20:01:19  ZENTRA → ALLE__  STA  019KOC
    // danach nichts mehr zu 019
Mitschnitt S1: Statusmeldungen eines Abends

Bestellung 017 wurde angeblich geliefert, bevor sie abgeholt war. Bestellung 018 ist storniert – trotzdem fährt KURIR2 los. Und bei 019 weiß niemand, ob sie unterwegs ist oder ob nur die Meldung verloren ging: Rundrufe werden nicht quittiert.

Leitfrage: Wie kann eine Station automatisch erkennen, ob die Statusmeldungen einer Bestellung in einer zulässigen Reihenfolge kommen?

Nebenfragen:

  1. In welchen Reihenfolgen dürfen die Meldungen einer Bestellung kommen, in welchen nicht?
  2. Was soll passieren, wenn eine Meldung verloren gegangen ist?

Unser Plan

Sammeln Sie in der Gruppe: Problem → Idee → offene Frage.

  • Zeichnen Sie den „Lebenslauf“ einer Bestellung als Kreise (Zustände) und Pfeile (Meldungen).
  • Welche Meldung darf in welchem Zustand kommen? Was soll die Anzeige bei jedem Übergang zeigen?
  • Erinnern Sie sich an die Automatenseite: Welcher Automatentyp liefert zu jeder Eingabe eine Ausgabe?

Tragen Sie den Plan als Protokollblatt v0.1 ein (Abschnitte 2, 3 und 6) und zeigen Sie ihn der Lehrkraft (Plan-Ticket). Danach beginnt Aufgabe 1.

Bedingungskarte S-a
  1. Statuscodes nach Vorgabe; jede Statusmeldung enthält die Bestellnummer (NNNCCC).
  2. Jeder unzulässige Ablauf erzeugt eine Warnung; die Station stürzt nie ab.
  3. Die Station zeigt eine Anzeigetafel aller Bestellungen.
  4. eA Bestelltexte – auch Menüs mit verschachtelten Klammern – werden geprüft.
Bedingungskarte S-b
  1. Statuscodes nach Vorgabe; jede Statusmeldung enthält die Bestellnummer (NNNCCC).
  2. Eine verlorene Rundrufmeldung löst keine Warnung aus, ein unmöglicher Ablauf (z. B. ABH nach STO) dagegen schon.
  3. Die Anzeigetafel zeigt zusätzlich eine Zusammenfassung: geliefert, storniert, offen, fehlerhaft.
  4. eA Bestelltexte – auch Menüs mit verschachtelten Klammern – werden geprüft.

Aufgaben: Den Automaten entwerfen

Codes nach Vorgabe: ANN angenommen (Zentrale), KOC in Zubereitung (Zentrale, sobald die Adresse da ist), ABH abgeholt (Kurier), LIE geliefert (Kurier), STO storniert (Zentrale). Vor dem Code steht die dreistellige Bestellnummer.

Ihr Bearbeitungsfortschritt:0%
Aufgabe 1 (Gruppenarbeit): Der Lebenslauf einer Bestellung

Material: Automatenseite (Mealy, DEA), Mitschnitt S1, Ihre Bedingungskarte.

Geben Sie Eingabealphabet Σ und Ausgabealphabet Ω an und zeichnen Sie den Übergangsgraphen des Mealy-Automaten (Beschriftung „Eingabe / Ausgabe“). Stornieren ist nur möglich, solange noch nicht gekocht wird. Jede nicht vorgesehene Eingabe führt in einen Zustand FEHLER mit der Ausgabe „ungültig“; aus GELIEFERT, STORNIERT und FEHLER führt jede Eingabe nach FEHLER. Geben Sie zusätzlich die Übergangstabelle an.

Hilfe 1: Der Startzustand ist NEU. Der „normale“ Weg hat vier Übergänge.
Hilfe 2: Ein Mealy-Automat ist vollständig: Für jeden Zustand und jede Eingabe gibt es einen Übergang. Damit der Graph lesbar bleibt, zeichnen Sie eine Sammelkante „alle anderen / ungültig“ je Zustand nach FEHLER und eine Schleife an FEHLER.

Verfolgen Sie mit Ihrem Automaten die Meldungen aus dem Einstieg für 017 und 018 und geben Sie Zustände und Ausgaben an. Betrachten Sie den Graphen dann als DEA mit dem Endzustand GELIEFERT: Welche Wörter über Σ beschreiben eine erfolgreiche Lieferung? Ist ANN STO ein solches Wort?

Hilfe 1: Bei 017 kommt LIE im Zustand IN_KUECHE an.
Hilfe 2: Ein DEA akzeptiert ein Wort, wenn er danach in einem Endzustand ist.

STA an ALLE__ wird nicht quittiert. Geht KOC verloren und kommt dann ABH, landet der strenge Automat in FEHLER, obwohl alles in Ordnung ist. Entwerfen Sie eine Lösung, die zu Ihrer Bedingungskarte passt, vergleichen Sie mindestens zwei Varianten und begründen Sie Ihre Wahl im Protokollblatt.

Hilfe 1: Variante 1: Der Automat bekommt zusätzliche Übergänge „vorwärts mit Lücke“. Variante 2: Zentrale und Kurier schicken Statusmeldungen zusätzlich gezielt an STATUS (dann quittiert).
Hilfe 2: Was kostet Variante 2 für Zentrale und Kurier? Was kann Variante 1 nicht mehr unterscheiden?
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Ihr Entwurf steht. Prüfen Sie ihn:

Aufgaben: Automat und Statustafel programmieren

Implementieren Sie die Klassen Bestellstatus, Auftrag und Statustafel als eigene Datei Bestellstatus.java und testen Sie ohne Netz.

Ihr Bearbeitungsfortschritt:0%
Aufgabe 2 (Partnerarbeit): Der Mealy-Automat in Java

Material: Selbsttest und Gerüst. Die Zustandsnamen und Ausgaben übernehmen Sie aus Ihrem Entwurf.

// ---- Selbsttest (Hauptprogramm) ----
Bestellstatus s = new Bestellstatus();
String[] eingaben = {"ANN", "KOC", "ABH", "LIE"};
for (int i = 0; i < eingaben.length; i++) {
   // verarbeite in eigener Zeile aufrufen, nicht in der Verkettung
   String ausgabe = s.verarbeite(eingaben[i]);
   println(eingaben[i] + " / " + ausgabe + "  -> " + s.getZustand());
}
// erwartet: vier Zeilen, zuletzt im Zustand GELIEFERT
// erwartet: true
println(s.pruefeFolge("ANNKOCABHLIE"));
// erwartet: false
println(s.pruefeFolge("ANNLIE"));
// erwartet: false (nach STO ist Schluss)
println(s.pruefeFolge("ANNSTOABH"));
Listing S1: Selbsttest in Bestellstatus.java
Gerüst der Klasse Bestellstatus anzeigen
class Bestellstatus {
   private String zustand = "NEU";

   // Mealy: Eingabe verarbeiten, Ausgabe zurückgeben
   public String verarbeite(String eingabe) {
      // TODO Teil a
      return "";
   }

   public String getZustand() {
      return zustand;
   }

   public boolean istGeliefert() {
      return zustand.equals("GELIEFERT");
   }

   // zurück auf NEU (Nummer wird nach 999 neu vergeben)
   public void zuruecksetzen() {
      zustand = "NEU";
   }

   // DEA-Sicht: Folge aus 3er-Eingaben, Endzustand GELIEFERT
   public boolean pruefeFolge(String folge) {
      // TODO Teil b
      return false;
   }
}
Listing S2: Gerüst der Klasse Bestellstatus

Ziel: Der Automat aus Aufgabe 1 läuft als Code. Fertig, wenn: Die vier Zeilen des Selbsttests mit GELIEFERT enden.

Implementieren Sie verarbeite mit switch (zustand): zuerst neu = "FEHLER" und ausgabe = "ungültig" annehmen, dann je Zustand die erlaubten Eingaben behandeln.

Hilfe 1: So steht die Fehlerbehandlung nur an einer Stelle: Wer nicht passt, bleibt bei FEHLER / „ungültig“.
Hilfe 2: Zeichenketten vergleichen Sie mit equals, nicht mit ==. Am Ende: zustand = neu; return ausgabe;

Ziel: Derselbe Automat dient als DEA. Fertig, wenn: Der Selbsttest true, false, false zeigt.

Implementieren Sie pruefeFolge(folge): Die Folge besteht aus Dreiergruppen (ANNKOCABHLIE). Der Automat startet in NEU, verarbeitet alle Gruppen und akzeptiert, wenn er in GELIEFERT endet. Danach wird er wieder auf NEU gesetzt.

Hilfe 1: Schleife for (int i = 0; i + 3 <= folge.length(); i = i + 3) mit folge.substring(i, i + 3).
Aufgabe 3 (Partnerarbeit): Die Statustafel

Material: Gerüst (in dieselbe Datei)

class Auftrag {
   private int nr;
   private Bestellstatus status = new Bestellstatus();

   public Auftrag(int nr) {
      this.nr = nr;
   }

   public int getNr() { return nr; }
   public Bestellstatus getStatus() { return status; }
}

class Statustafel {
   private DynArray auftraege = new DynArray();

   // Nutzdaten eines STA-Pakets, z. B. "017ANN";
   // liefert die Anzeige bzw. eine Warnung
   public String verarbeite(String text) {
      // TODO Teil a
      return "";
   }

   private Auftrag finde(int nr) {
      // TODO Teil a
      return null;
   }

   public void zeige() {
      // TODO Teil b
   }
}
Listing S3: Gerüst der Klassen Auftrag und Statustafel

Ziel: Jede Meldung landet beim Automaten ihrer Bestellung. Fertig, wenn: Die Meldungen aus Mitschnitt S1 die erwarteten Anzeigen und Warnungen liefern und 01 nicht zum Absturz führt.

Implementieren Sie finde (lineare Suche nach der Bestellnummer) und verarbeite: Länge 6 und drei Ziffern prüfen, sonst „WARNUNG: unlesbare Statusmeldung“; Auftrag suchen oder neu anlegen; den Code an dessen Automaten geben; landet er in FEHLER, eine Warnung zurückgeben, sonst z. B. „Bestellung 17: geliefert“. Kommt ANN für eine Nummer, die es schon gibt, beginnt eine neue Bestellung (die Zentrale vergibt nach 999 wieder ab 1): Setzen Sie den Automaten mit zuruecksetzen() zurück.

Hilfe 1: Die Bestellnummer wandeln Sie Ziffer für Ziffer um wie mit zahlAus; den Code liefert text.substring(3, 6).
Hilfe 2: Beim Lesen aus der Reihung umwandeln: Auftrag a = (Auftrag) auftraege.getItem(i);

Ziel: Alle Bestellungen auf einen Blick. Fertig, wenn: Nach den Meldungen aus Mitschnitt S1 eine Zeile je Bestellung mit ihrem Zustand erscheint.

Implementieren Sie zeige() (eine Zeile je Bestellung mit Nummer und Zustand; Karte S-b zusätzlich die Zusammenfassung) und testen Sie mit den Meldungen aus dem Einstieg sowie mit 01 (zu kurz).

Hilfe 1: println(a.getNr() + ": " + a.getStatus().getZustand());

Ziel: Ihre Entwurfsentscheidung aus Aufgabe 1 c) ist umgesetzt. Fertig, wenn: 017ANN, 017ABH (ohne KOC) sich so verhält, wie Ihr Protokollblatt es festlegt.

Setzen Sie Ihre Regel aus Aufgabe 1 c) im Automaten oder in der Tafel um und ergänzen Sie den Selbsttest um zwei Fälle mit verlorener Meldung und einen unmöglichen Ablauf.

Hilfe 1: Variante 1 braucht nur zusätzliche if-Zeilen in einzelnen case-Blöcken. Unterscheiden Sie dabei die Ausgabe „übersprungen“ von „ungültig“.
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Ihr Modul besteht den Selbsttest (Meilenstein M2). Prüfen Sie noch:

Aufgaben: Station STATUS anbinden

Kopieren Sie Ihre Klassen ohne das Hauptprogramm in den Workspace mit Ihrer Station (rufzeichen = "STATUS").

Ihr Bearbeitungsfortschritt:0%
Aufgabe 4 (Gruppenarbeit): Die Statustafel geht auf Sendung

Material: Ihre Station

Ergänzen Sie verarbeite: Jede STA-Meldung wird an die Tafel gegeben; die Ausgabe wird angezeigt (Warnungen in Orange), nach jeder fünften Meldung die ganze Tafel.

Hilfe 1: Rundrufe an ALLE__ kommen bei jeder Station in verarbeite an – auch bei Ihnen.
Hilfe 2: Ob eine Ausgabe eine Warnung ist, erkennen Sie am Anfang des Textes. Prüfen Sie die Länge, bevor Sie substring aufrufen – oder nutzen Sie contains("WARNUNG").

Testen Sie mit Zentrale und Kurier im Gruppen-Sitzungscode: normaler Ablauf, Stornierung, unbekannter Kunde, eine absichtlich falsche Meldung, Störkanal mit 20 % Verlust. Halten Sie Testfall – erwartet – beobachtet – Ursache fest und zählen Sie, wie oft Warnungen nur wegen verlorener Rundrufe entstehen.

Hilfe 1: Eine falsche Meldung senden Sie, indem eine Person eine Station mit demo = false startet und an ALLE__ den Typ STA mit 017LIE sendet.
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Ihre Statustafel ist auf Sendung (Meilenstein M3). Prüfen Sie:

Aufgaben: Gültige Bestelltexte eA

Die Zentrale soll Bestellungen mit unsinnigem Bestelltext gleich stornieren. Ihre Abteilung liefert der Zentrale dafür die Prüfungen.

Ihr Bearbeitungsfortschritt:0%
Aufgabe 5 (Partnerarbeit): Eine Grammatik für Bestelltexte

Material: Bestelltexte ohne Klammern (z. B. 2xPIZZA,1xCOLA) beschreibt diese rechtsreguläre Grammatik (Nichtterminale in spitzen Klammern, G steht für einen beliebigen Großbuchstaben A–Z):

N = {⟨S⟩, ⟨A⟩, ⟨B⟩, ⟨K⟩}         Startsymbol ⟨S⟩
T = {1, 2, …, 9, x, Komma, A, B, …, Z}
⟨S⟩ → 1⟨A⟩ | 2⟨A⟩ | … | 9⟨A⟩
⟨A⟩ → x⟨B⟩
⟨B⟩ → G⟨B⟩ | G⟨K⟩ | G          für jedes G aus A … Z
⟨K⟩ → ,⟨S⟩

Leiten Sie 2xPIZZA,1xCOLA ab. Prüfen Sie, ob 0xCOLA, 2xpizza, 2xPIZZA, und 3xPASTA zur Sprache gehören. Zeichnen Sie einen DEA, der genau diese Sprache erkennt, mit Übergangstabelle.

Hilfe 1: Jede Regel einer rechtsregulären Grammatik erzeugt ein Terminal und höchstens ein Nichtterminal ganz rechts – das entspricht einem Übergang eines Automaten.
Hilfe 2: Die Nichtterminale werden zu Zuständen; eine Regel ohne Nichtterminal (⟨B⟩ → G) führt in einen Endzustand. Fassen Sie die Zustände so zusammen, dass nach mindestens einem Großbuchstaben ein Endzustand erreicht ist, von dem ein Komma zurück zum Start führt.

Implementieren Sie in der Klasse Bestellstatus die Methode istGueltigerBestelltext(text: Zeichenkette): Wahrheitswert als DEA mit Zustandsvariable und switch. Testen Sie mit den Wörtern aus Teil a) und einem leeren Text.

Hilfe 1: Wie in verarbeite: Zustand als Zeichenkette, für jedes Zeichen ein Übergang, alles Unerwartete führt in einen Fehlerzustand, aus dem es kein Zurück gibt.
Hilfe 2: Ziffer 1–9: c >= '1' && c <= '9'; Großbuchstabe: c >= 'A' && c <= 'Z'. Akzeptiert wird, wenn der Zustand am Ende der Endzustand ist.
Aufgabe 6 (Partnerarbeit): Menüs mit Klammern – ein Kellerautomat

Material: Menüs dürfen verschachtelt sein: 1xMENUE(PIZZA(SALAMI,KAESE),COLA). Eine rechtsreguläre Grammatik kann nicht prüfen, ob alle Klammern richtig geschlossen sind (wie bei aⁿbⁿ). Ein Kellerautomat kann es.

Zeichnen Sie einen Kellerautomaten (Notation der Abitur-Hinweise: Übergang „(oberstes Kellerzeichen, Eingabe) : abgelegte Zeichen“, Vorbelegung #), der genau die Wörter mit korrekt geschachtelten Klammern akzeptiert. Fassen Sie alle Zeichen außer ( und ) zur Eingabe a zusammen und verwenden Sie für eine offene Klammer das Kellerzeichen K. Geben Sie die Kellerinhalte für a(a(a)a) an.

Hilfe 1: Bei ( wird ein K auf den Keller gelegt, bei ) eines entfernt – aber nur, wenn oben eines liegt.
Hilfe 2: Akzeptiert wird, wenn am Ende nur noch # im Keller liegt: ε-Übergang in den Endzustand.

Implementieren Sie klammernOk(text) in der Klasse Bestellstatus mit einem Stack (Vorbelegung "#"). Testen Sie 1xMENUE(PIZZA(SALAMI,KAESE),COLA), 1xMENUE(PIZZA(SALAMI,COLA), PIZZA)( und 2xPIZZA. Geben Sie die Klasse an die Zentrale weiter (Zentrale, Aufgabe 5 c) und vereinbaren Sie, wann welche Prüfung gilt.

Hilfe 1: Vor top() und pop() immer prüfen, ob der Stapel leer ist bzw. ob oben # liegt.
Hilfe 2: top() liefert ein Object – Vergleich mit keller.top().equals("#").
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Ihre Erweiterung läuft (Meilenstein M4). Prüfen Sie:

Sicherung

Definition: Akzeptierte Sprache

Die Menge aller Wörter, nach deren Verarbeitung ein DEA in einem Endzustand ist. Der Graph des Bestellstatus akzeptiert als DEA genau die erfolgreichen Lieferungen.

Merke

Ein Mealy-Automat ordnet jedem Zustand und jeder Eingabe einen Folgezustand und eine Ausgabe zu (Schreibweise „Eingabe / Ausgabe“). In Java: eine Zustandsvariable und switch, die Fehlerbehandlung an einer Stelle. Weil Rundrufe verloren gehen können, ist die Strenge des Automaten eine Entwurfsentscheidung. eA Eine rechtsreguläre Grammatik und ein DEA beschreiben dieselbe Sprache; verschachtelte Klammern erkennt erst ein Kellerautomat.

Infobox: Schnittstelle zum Go-Live

Diese Pakete und Klassen verarbeitet der Bestellstatus.

Tabelle S1: Pakete und Klassen des Bestellstatus
RichtungTypPartnerNutzdaten
empfängtSTAalle (ALLE__)NNN + ANN/KOC/ABH/LIE/STO
eA liefert vorab–ZentraleKlasse Bestellstatus mit istGueltigerBestelltext und klammernOk
Plan-Check

Vergleichen Sie Ihren Plan aus dem Einstieg mit Ihrer fertigen Station: Welche Plan-Punkte haben sich bestätigt, welche mussten Sie ändern – und warum?

Rückbezug: Geliefert, bevor abgeholt

Die Statustafel meldet sofort, dass bei 017 „geliefert“ vor „abgeholt“ kam und dass 018 trotz Stornierung abgeholt wurde. Ob bei 019 nur eine Meldung verloren ging oder wirklich etwas hängt, entscheidet Ihre Regel aus Aufgabe 1 c) – ein strenger Automat warnt, ein toleranter zeigt „übersprungen“.


Abteilung Logbuch

Worum es geht: Nach dem Probelauf streiten die Abteilungen, und im Logbuch stehen alle Bestellungen, Adressen und Zahlungen – mehrfach. → Das Logbuch klärt Streitfragen mit SQL, speichert nur, was es darf, und zeigt im Go-Live die wichtigsten Zahlen.

Einstieg: Wer hat recht?

Störung im Liefernetz (Gruppenarbeit)

Nach dem ersten Probelauf gibt es Streit:

  • KURIR2: „Ich habe nie einen Auftrag bekommen!“
  • ZENTRA: „Doch, ich habe Bestellung 023 dreimal an KURIR2 gesendet!“
  • KASSE1: „Bestellung 021 wurde zweimal bezahlt – oder doch nicht?“
  • STATUS: „Wie lange dauert bei uns eigentlich eine Lieferung?“

Zum Glück schreibt jede Station mit der fertigen Klasse Logbuch jedes gesendete und jedes gehörte Paket in die Tabelle logbuch einer Datenbank. Ihre Gruppe schaut hinein – und erschrickt: In der Spalte nutzdaten stehen alle Bestellungen mit Kundennummer, alle Adressen und alle Zahlungen, und das nicht einmal, sondern bei jeder Station noch einmal.

Leitfrage: Wie lassen sich die Streitfragen mit dem Logbuch klären – und was darf ein Logbuch überhaupt speichern?

Nebenfragen:

  1. Warum steht jedes Paket mehrfach in der Tabelle? Was bedeutet das für das Zählen?
  2. Wer darf hineinschauen, und wie lange?

Unser Plan

Sammeln Sie in der Gruppe: Problem → Idee → offene Frage.

  • Lesen Sie die Spaltenliste (Tabelle L1): Wer schreibt wann eine Zeile?
  • Formulieren Sie jede Streitfrage als Frage an eine Tabelle („Zähle alle Zeilen, in denen …“).
  • Markieren Sie alle Spalten, in denen personenbezogene Daten stehen können.

Tragen Sie den Plan als Protokollblatt v0.1 ein (Abschnitte 2, 3 und 6) und zeigen Sie ihn der Lehrkraft (Plan-Ticket). Danach beginnt Aufgabe 1.

Bedingungskarte L-a
  1. Keine personenbezogenen Nutzdaten dauerhaft in der Datenbank (Bestellungen mit Kundennummer, Adressen, Zahlungen).
  2. Mindestens fünf Auswertungsabfragen für das Go-Live, davon zwei mit GROUP BY und eine mit HAVING.
  3. Eine Löschfrist ist festgelegt und begründet.
  4. eA Lieferzeiten lassen sich per SQL berechnen.
Bedingungskarte L-b
  1. Von den Nutzdaten wird nur gespeichert, was für die Auswertung der Statusmeldungen nötig ist; Rufzeichen von Kurieren werden nach dem Go-Live durch Platzhalter ersetzt (Mitarbeiterdatenschutz).
  2. Mindestens fünf Auswertungsabfragen für das Go-Live, davon je eine für Zentrale, Kurier und Kasse.
  3. Lese- und Schreibzugriff sind getrennt geregelt und begründet.
  4. eA Lieferzeiten lassen sich per SQL berechnen.

Material für alle Aufgaben: die Tabelle logbuch in Kurzschreibweise (Primärschlüssel unterstrichen) und ein Beispiel-Logbuch.

logbuch(nr, zeit, station, richtung, absender, empfaenger, typ, seq, teil, gesamt, laenge, nutzdaten, gueltig, roh)

Tabelle L1: Spalten der Tabelle logbuch
SpalteBedeutung
nrlaufende Nummer (Primärschlüssel)
zeitZeitpunkt in Unix-Sekunden
stationwer die Zeile schreibt
richtungAUS (gesendet) oder EIN (gehört)
absender … laengeFelder des FN/1-Kopfs
nutzdatenNutzdaten des Pakets
gueltig1 = Prüfsumme in Ordnung, 0 = defekt
rohkompletter Funktext

Beispiel-Logbuch eines Testlaufs mit den Stationen KUNDE1, ZENTRA, KUNDEN, KURIR1, KASSE1, STATUS (Bestellung 017; eine Adressanfrage ging verloren, ein Lieferauftrag kam verfälscht an). Gezeigt sind nur die AUS-Zeilen; station ist dort gleich absender.

Tabelle L2: Beispiel-Logbuch, AUS-Zeilen
nrzeitabsender → empfaenger, typ, seqnutzdatengueltig
11792000000KUNDE1 → ZENTRA BST 400423 2xPIZZA,1xCOLA1
71792000000ZENTRA → KUNDE1 ACK 41
131792000001ZENTRA → ALLE__ STA 11017ANN1
191792000001ZENTRA → KUNDEN ADR 12‹Anfrage›1
201792000003ZENTRA → KUNDEN ADR 12‹Anfrage›1
261792000003KUNDEN → ZENTRA ACK 121
321792000003KUNDEN → ZENTRA ADR 3‹Antwort›1
381792000003ZENTRA → KUNDEN ACK 31
441792000004ZENTRA → ALLE__ STA 13017KOC1
501792000004ZENTRA → KURIR1 BST 14‹Lieferauftrag›1
561792000004KURIR1 → ZENTRA NAK 141
621792000004ZENTRA → KURIR1 BST 14‹Lieferauftrag›1
681792000004KURIR1 → ZENTRA ACK 141
741792000005KURIR1 → ALLE__ STA 21017ABH1
801792000007KURIR1 → ALLE__ STA 22017LIE1
861792000007KURIR1 → KASSE1 ZAH 23‹Zahlung›1
921792000007KASSE1 → KURIR1 ACK 231
981792000009KURIR1 → ZENTRA POS 24‹frei›1
1041792000009ZENTRA → KURIR1 ACK 241

Zu jeder AUS-Zeile gibt es EIN-Zeilen der fünf anderen Stationen, weil alle alles hören – außer bei der verlorenen Anfrage (Nr. 19). Beim verfälschten Lieferauftrag (Nr. 50) steht in den EIN-Zeilen gueltig = 0. Insgesamt hat die Tabelle 109 Zeilen. Die Nutzdaten in ‹…› hängen vom Format ab, das Ihr Kurs vereinbart; in der Beispieldatenbank der Lehrkraft stehen die Formate dieses Testlaufs.

Aufgaben: Das Logbuch verstehen und schützen

Klären Sie, was im Logbuch steht und was darin stehen darf. Halten Sie Ihre Regeln im Protokollblatt fest.

Ihr Bearbeitungsfortschritt:0%
Aufgabe 1 (Gruppenarbeit): Was im Logbuch steht

Material: Tabellen L1 und L2. Die Klasse Logbuch wird vom Funkgerät bei jedem Senden mit AUS und bei jedem Empfangen mit EIN aufgerufen.

Erklären Sie, warum zu einem Paket bis zu sechs Zeilen gehören. Wie viele Zeilen gehören zum Lieferauftrag mit Seq 14 (einschließlich der Wiederholung)? Welche Zeilen muss man zählen, um (1) die Anzahl gesendeter Pakete, (2) die Anzahl defekt empfangener Pakete einer Station zu bestimmen?

Hilfe 1: Das Funkgerät protokolliert jede empfangene FN/1-Nachricht als EIN – noch bevor die Station prüft, ob sie an sie gerichtet ist.
Hilfe 2: Im gemeinsamen Medium hört jede Station jedes Paket der anderen.

Untersuchen Sie für jeden Pakettyp, ob seine Nutzdaten personenbezogen sind, und beurteilen Sie die Spalte roh. Legen Sie nach den Grundsätzen Datensparsamkeit, Zweckbindung und Speicherbegrenzung fest, was das Logbuch speichern darf und wann gelöscht wird. Regeln Sie, wer den Schreib-Code und wer nur einen Lese-Code bekommt. Beachten Sie Ihre Bedingungskarte.

Hilfe 1: Personenbezogen sind auch Daten, die man mit Zusatzwissen einer Person zuordnen kann (Kundennummer, Lage im Stadtplan, Rufzeichen eines Kuriers). Auch Metadaten können viel verraten.
Hilfe 2: Wozu braucht das Liefernetz das Logbuch eigentlich? Welche Spalten braucht man dafür? Mit dem Schreib-Code kann man auch DELETE ausführen.

Legen Sie in der SQL-IDE die Datenbank des Kurses an (das CREATE TABLE steht im Kopfkommentar der Datei Logbuch.java) und prüfen Sie, ob ein Testeintrag ankommt.

Hilfe 1: Ohne diese Challenge legt die Lehrkraft die Datenbank an und gibt Ihnen die Codes.
Aufgabe 2 (Partnerarbeit): Die Streitfragen klären

Material: Beispieldatenbank in der SQL-IDE (Lese-Code von der Lehrkraft). Nur der Sprachumfang der Abitur-Hinweise: keine Unterabfragen; mehrere Tabellen über FROM t1, t2 WHERE …. Schreiben Sie jede Abfrage ins Protokollblatt.

Fertig, wenn: Ihre Abfrage für ACK die Anzahl 6 liefert und absteigend sortiert ist.

Wie viele Pakete jedes Typs wurden gesendet? Sortieren Sie absteigend nach Anzahl.

Hilfe 1: Welche Zeilen zählen Sie (Aufgabe 1 a)? Wonach gruppieren Sie?
Hilfe 2: COUNT(*) zählt die Zeilen einer Gruppe; ORDER BY anzahl DESC sortiert absteigend, wenn Sie die Spalte mit AS anzahl benennen.

Fertig, wenn: Ihre Abfrage genau zwei Zeilen liefert.

Welche Datenpakete (also nicht ACK/NAK) wurden mehrfach gesendet? Geben Sie Absender, Typ, Seq und Anzahl der Versuche aus. Erklären Sie, wie dieselbe Abfrage im Go-Live den Streit zwischen Zentrale und KURIR2 klärt.

Hilfe 1: Dasselbe Paket hat denselben Absender, denselben Typ und dieselbe Seq. Gruppieren Sie nach allen drei.
Hilfe 2: Bedingungen an Gruppen stehen in HAVING, nicht in WHERE.

Fertig, wenn: Ihre Abfrage sechs Zeilen liefert und ZENTRA 0 defekte Pakete hat.

Geben Sie für jede Station die Anzahl gehörter Pakete und die Anzahl defekter Pakete aus. Erklären Sie, warum die Zentrale keinen Defekt hat.

Hilfe 1: gueltig ist 1 oder 0. Die Summe von gueltig zählt die heilen Pakete.

Fertig, wenn: Sie für Bestellung 017 eine Dauer von 6 Sekunden und insgesamt eine Lieferung erhalten.

Geben Sie die Statusmeldungen der Bestellung 017 in zeitlicher Reihenfolge aus und berechnen Sie die Dauer von der ersten bis zur letzten Meldung in Sekunden. Wie viele Lieferungen wurden insgesamt gemeldet?

Hilfe 1: LIKE '017%' findet alle Nutzdaten, die mit 017 beginnen; _ steht für genau ein Zeichen.
Hilfe 2: Dauer = MAX(zeit) - MIN(zeit).

Formulieren Sie zwei Abfragen, die ohne Nutzdaten etwas über das Verhalten im Liefernetz verraten (z. B. „Wer funkt wie oft mit wem?“), und eine, die zeigt, welche Stationen die Bestellung von Kunde 0042 gehört haben.

Hilfe 1: Gruppieren Sie nach absender und empfaenger; lassen Sie Quittungen und Rundrufe weg.
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Die Streitfragen sind geklärt. Prüfen Sie:

Aufgaben: Logbuch und Leitstand programmieren

Ihre Regeln werden zu Code: ein datensparsames Logbuch für alle Stationen und ein Leitstand für das Go-Live.

Ihr Bearbeitungsfortschritt:0%
Aufgabe 3 (Partnerarbeit): Datensparsam protokollieren und auswerten

Material: Datei Logbuch.java, Methode speichere (Auszug)

         einfuegen.setString(11, p.getNutzdaten());
         // ...
      einfuegen.setString(13, text);
Listing L1: Wo Logbuch Nutzdaten und Rohtext speichert

Ziel: Das Logbuch hält Ihre Datenschutzregel ein. Fertig, wenn: Ein Probelauf mit ZAH und STA nur die erlaubten Nutzdaten speichert und roh leer bleibt.

Ändern Sie speichere nach Ihrer Regel aus Aufgabe 1 b): Nutzdaten nur für erlaubte Typen, roh nie. Schreiben Sie dazu eine Methode darfNutzdatenSpeichern(typ). Geben Sie die geänderte Klasse allen Gruppen (neue Version im Schnittstellenvertrag).

Hilfe 1: Statt p.getNutzdaten() speichern Sie bei nicht erlaubten Typen "".
Hilfe 2: Alle Gruppen müssen Ihre Version vor dem Go-Live einspielen. Prüfen Sie im Startcheck mit einer Abfrage, ob noch verbotene Nutzdaten auftauchen.

Entwerfen Sie die Auswertungsabfragen für das Go-Live nach Bedingung 2 Ihrer Karte – mindestens Lieferquote, Wiederholungen und Defekte je Station, Lieferdauer – und testen Sie sie auf der Beispieldatenbank. Notieren Sie zu jeder Abfrage, welche Frage sie beantwortet und welche Abteilung sie braucht. Prüfen Sie, ob Ihre Datenschutzregel eine der Abfragen unmöglich macht.

Hilfe 1: Lieferquote = Anzahl …LIE / Anzahl …ANN aus den STA-Meldungen. Zeiträume schränken Sie mit zeit BETWEEN … AND … ein.
Hilfe 2: Testpakete mit der Bestellnummer 999 schließen Sie mit nutzdaten NOT LIKE '999%' aus.

Ziel: Im Go-Live zeigt ein Programm laufend die wichtigsten Zahlen. Fertig, wenn: Ihre Abfragen alle 30 Sekunden neu in der Konsole erscheinen.

Schreiben Sie eine Klasse Leitstand, die mit dem Lese-Code eine Verbindung aufbaut und mit zeige(titel, sql) eine Abfrage mit zwei Ergebnisspalten (Text, Zahl) ausgibt. Das Hauptprogramm zeigt Ihre Go-Live-Abfragen alle 30 Sekunden neu an.

Hilfe 1: Muster: PreparedStatement st = verbindung.prepareStatement(sql); ResultSet rs = st.executeQuery(); while (rs.next()) { … } – die Werte liefern rs.getString(1) und rs.getInt(2).
Hilfe 2: Wiederholen im Hauptprogramm: Schleife mit Thread.sleep(30000).
Aufgabe 4 (Gruppenarbeit): Schnittstellentest mit allen

Verteilen Sie den Schreib-Code an zwei Partnergruppen, lassen Sie einen kurzen Probelauf laufen (Störkanal 10 %) und prüfen Sie: Kommen Einträge an? Stimmen die Zeitstempel? Werden Ihre Datenschutzregeln eingehalten? Lassen Sie Ihre Go-Live-Abfragen auf den echten Daten laufen. Halten Sie Testfall – erwartet – beobachtet – Ursache fest.

Hilfe 1: Prüfabfrage für den Datenschutz: SELECT typ, COUNT(*) FROM logbuch WHERE nutzdaten != '' GROUP BY typ; – hier dürfen nur erlaubte Typen erscheinen.
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Ihr Logbuch ist einsatzbereit (Meilensteine M2 und M3). Prüfen Sie:

Aufgaben: Datenmodell und sichere Abfragen eA

Eine Tabelle für alles ist bequem, aber redundant. Und Texte aus dem Funk dürfen nie zu SQL-Befehlen werden.

Ihr Bearbeitungsfortschritt:0%
Aufgabe 5 (Partnerarbeit): Ein ER-Modell für das Liefernetz

Entwerfen Sie ein ER-Modell mit den Entitätstypen Station, Paket, Bestellung und Statusmeldung (Attribute, Schlüssel, Beziehungen mit Kardinalitäten) und setzen Sie es in ein relationales Schema in Kurzschreibweise um (Primärschlüssel unterstrichen, Fremdschlüssel mit ↑).

Hilfe 1: Ein Paket wird von einer Station gesendet und von vielen gehört. Wie modelliert man „hört“?
Hilfe 2: Eine Bestellung hat mehrere Statusmeldungen; jede Statusmeldung wird von genau einer Station gemeldet.

Beurteilen Sie die Tabelle logbuch: Welche Redundanzen gibt es, und welche Änderungs- oder Löschanomalien können auftreten? Was spricht trotzdem für eine einzige Tabelle?

Hilfe 1: Wie oft steht der Kopf eines Pakets in der Tabelle? Was passiert, wenn man die Zeilen einer Station löscht?
Aufgabe 6 (Partnerarbeit): Statusmeldungen sicher speichern

Material: neue Tabelle statusmeldung(nr, bestellnr, code, zeit, station). Ihre eigene Station LOGBUC (Station extends WebSocket) hört alle Rundrufe mit und trägt jede Statusmeldung ein.

Ergänzen Sie das Logbuch um meldeStatus(int bestellnr, String code, String station) und Ihre Station LOGBUC um den Aufruf für jede STA-Meldung. Erklären Sie an einem Beispiel, warum die Werte über Platzhalter ? übergeben werden und nicht in den SQL-Text geklebt (SQL-Injection).

Hilfe 1: Muster: prepareStatement("INSERT INTO statusmeldung (bestellnr, code, zeit, station) VALUES (?, ?, ?, ?)"), dann setInt, setString, executeUpdate().
Hilfe 2: Was würde "… VALUES (" + bestellnr + ", '" + code + "', …" aus einem Code wie X'); DELETE FROM statusmeldung; -- machen? Wer kann solche Texte in den Funk schicken?

Berechnen Sie für jede gelieferte Bestellung die Zeit von ANN bis LIE und die durchschnittliche Lieferzeit (Bedingung 4 Ihrer Karte).

Hilfe 1: Die Tabelle wird mit sich selbst verbunden: FROM statusmeldung a, statusmeldung b WHERE a.bestellnr = b.bestellnr AND ….
Hilfe 2: Was passiert, wenn eine Meldung doppelt eingetragen wird? Warum trägt deshalb nur eine Station ein?
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Ihre Erweiterung läuft (Meilenstein M4). Prüfen Sie:

Sicherung

Definition: Speicherbegrenzung

Grundsatz des Datenschutzes: Personenbezogene Daten werden nur so lange gespeichert, wie es für den Zweck nötig ist; danach werden sie gelöscht (Löschfrist).

Merke

Ein Logbuch protokolliert aus der Sicht jeder Station; im gemeinsamen Medium erscheint ein Paket deshalb mehrfach. Für Auswertungen nutzt man GROUP BY mit Aggregatfunktionen (COUNT, SUM, MAX, MIN, AVG), HAVING für Bedingungen an Gruppen und LIKE mit _ und % für Muster. Datenschutz heißt: nur speichern, was für den Zweck nötig ist (Datensparsamkeit, Zweckbindung), rechtzeitig löschen (Speicherbegrenzung) und den Zugriff regeln. Auch Metadaten sind personenbezogen. eA Werte aus dem Netz kommen nur über PreparedStatement in SQL.

Infobox: Schnittstelle zum Go-Live

Das liefert das Logbuch an alle Abteilungen.

Tabelle L3: Was das Logbuch liefert
Wasan wenInhalt
Datenbank, Schreib-Codealle StationenTabelle logbuch (eA zusätzlich statusmeldung)
geänderte Klasse Logbuchalle Gruppendatensparsames Speichern (eA meldeStatus)
Lese-Code, Leitstand, Abfragenalle Gruppen, BeamerAuswertung im Go-Live
Plan-Check

Vergleichen Sie Ihren Plan aus dem Einstieg mit Ihrem fertigen Logbuch: Welche Plan-Punkte haben sich bestätigt, welche mussten Sie ändern – und warum?

Rückbezug: Wer hat recht?

Die Wiederholungsabfrage zeigt, ob die Zentrale den Auftrag wirklich mehrfach gesendet hat und ob KURIR2 ihn je gültig gehört hat. Die ZAH-Zeilen klären, ob eine Zahlung zweimal ankam, und die Statusmeldungen liefern die Lieferzeit. Dafür muss das Logbuch weder Bestellungen noch Adressen noch Zahlungen dauerhaft speichern.


Go-Live: Der erste echte Abend

Worum es geht: Jede Abteilung hat ihren Schnittstellentest bestanden – trotzdem läuft das Ganze nicht von selbst. → Mit Startcheck, Rauchtest und einem Bestelllauf unter Störung zeigt der Kurs, dass das Liefernetz im Verbund arbeitet, und belegt Erfolge und Fehler mit SQL.

Einstieg: 6 Bestellungen, 1 geliefert

Störung im Liefernetz (Plenum)

Generalprobe am Ende der letzten Abteilungsstunde: Alle starten gleichzeitig ihre Stationen, KUNDE1 schickt sechs Bestellungen. Die Ausgaben der Stationen am Beamer:

ZENTRA  Abbruch: KUNDEN antwortet nicht.
ZENTRA  001: wartet auf Adresse …
KURIR1  BST verworfen – noch kein Stadtplan
KASSE1  Zahlung von KURIR2 unlesbar: QWBTMEKS
STATUS  WARNUNG Bestellung 3: ABH ist hier nicht erlaubt
STATUS  WARNUNG Bestellung 4: LIE ist hier nicht erlaubt
LOGBUC  0 Einträge
Ergebnis: 6 Bestellungen, 1 geliefert.

Jede Abteilung hatte ihren Schnittstellentest bestanden – trotzdem funktioniert das Ganze nicht.

Leitfrage: Warum scheitert ein Netz aus lauter getesteten Stationen – und was muss geprüft sein, bevor der erste Kunde bestellt?

Nebenfragen:

  1. Welche Fehler liegen an der Spezifikation, welche an der Implementierung, welche nur am Betrieb (Startreihenfolge, Codes, Schlüssel, Versionen)?
  2. Woran messen wir, ob der Abend ein Erfolg war?

Unser Plan

Sammeln Sie im Kurs: Ausgabe → vermutete Ursache → Kategorie.

  • Ordnen Sie jeder Zeile der Generalprobe eine vermutete Ursache zu.
  • Zeichnen Sie die Abhängigkeiten als Startreihenfolge: Wer muss schon laufen, damit eine Station sinnvoll arbeiten kann?
  • Legen Sie drei bis fünf Kennzahlen fest, die Sie hinterher per SQL bestimmen.

Die Lehrkraft hält die Startreihenfolge des Kurses an der Tafel fest; sie gilt für den Startcheck.

Hinweis

Ablauf des Abends. gA: Startcheck und Rauchtest → ein Bestelllauf mit Störung (scheitert der Rauchtest, vorher ein kurzer Lauf ohne Störung) → Auswertung per SQL → Sicherung; Fehlerprotokoll als Hausaufgabe. eA: wie gA, danach Hotfix der wichtigsten Fehler → zweiter Lauf mit Angriffen der Konkurrenz und vielen Bestellungen → Auswertung mit der Tabelle statusmeldung. Jede Gruppe teilt sich auf: Betrieb der Station und Beobachtung. Zwei Freiwillige können als Integrationsteam den Rauchtest leiten und die Tafelliste führen.

Hinweis

Wenn eine Station ausfällt: Die Lehrkraft startet für jede Abteilung eine Ersatzstation mit den Referenzformaten. Fällt Ihre Station aus und lässt sie sich nicht in wenigen Minuten wieder starten, übernimmt die Ersatzstation Ihr Rufzeichen, und der Lauf geht weiter. Ihre Gruppe beobachtet weiter und analysiert den Ausfall im Fehlerprotokoll – ein Ausfall ist kein Scheitern, sondern Material.

Aufgaben: Startklar

Vor dem ersten Kunden muss klar sein, dass jede Station läuft und ihre Partner versteht.

Ihr Bearbeitungsfortschritt:0%
Aufgabe 1 (Gruppenarbeit): Startcheck und Rauchtest

Material: Startreihenfolge an der Tafel, Ihre Station, Schnittstellenvertrag.

Gehen Sie vor dem Start diese Liste durch und haken Sie ab: Rufzeichen (6 Zeichen, eindeutig); Sitzungscode FN-<Kurs>-LIVE; Datenbank-Code; Störprofil laut Ansage; Schlüssel (Kasse, Kurier); aktuelle Klassenversionen (Logbuch, Partnerklassen); demo = false; Geschwindigkeitsregler der IDE auf Maximum. Starten Sie erst, wenn Sie laut Startreihenfolge dran sind, und tragen Sie „gestartet“ in die Tafelliste ein. Legen Sie außerdem einen Beobachtungsbogen an.

Hilfe 1: Die Reihenfolge ergibt sich aus der Frage: „Wem schicke ich als Erstes etwas – läuft der schon?“
Hilfe 2: Spalten des Beobachtungsbogens: Uhrzeit | Station | Ereignis (was sehe ich?) | Bestellnummer | Vermutung. Ohne Bestellnummer finden Sie ein Ereignis später im Logbuch nicht wieder.

Schicken Sie Ihren Partnerabteilungen je ein Testpaket nach Schnittstellenvertrag und prüfen Sie die Reaktion (z. B. Zentrale → Kundenverzeichnis: Anfrage zu Bestellung 999; Kurier → Kasse: Testzahlung für Bestellung 999 über 1 Cent). Melden Sie dem Integrationsteam „Rauchtest bestanden“ oder den Fehler.

Hilfe 1: Testpakete mit der Bestellnummer 999 lassen sich in der Auswertung leicht herausfiltern (nutzdaten NOT LIKE '999%').
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Ihre Station ist startklar. Prüfen Sie:

Aufgaben: Der Bestelllauf

Jetzt bestellt die Kundschaft – und der Störkanal ist an.

Ihr Bearbeitungsfortschritt:0%
Aufgabe 2 (Gruppenarbeit): Lauf mit Störung

Betreiben Sie Ihre Station während des Laufs mit dem angesagten Störprofil und führen Sie den Beobachtungsbogen. Notieren Sie die Unix-Zeit von Start und Ende des Laufs. Achten Sie besonders auf Wiederholungen, Abbrüche, Warnungen der Statustafel und Doppelbuchungen. Ordnen Sie nach dem Lauf jede Auffälligkeit einer Kategorie zu: Spezifikation (Absprache unklar oder widersprüchlich), Implementierung (Programm hält sich nicht an die Absprache) oder Betrieb (falscher Code, falsche Reihenfolge, alte Version).

Hilfe 1: Unix-Sekunden: println((int) (System.currentTimeMillis() / 1000)); – oder die Lehrkraft schreibt beide Werte an die Tafel.
Hilfe 2: Bei Verlust gehen auch Rundrufe (STA) verloren – Warnungen der Statustafel sind dann nicht unbedingt ein Programmfehler.
Hilfe 3: Testfrage für die Kategorie: Würde eine andere Gruppe, die nur das Protokollblatt kennt, denselben Fehler machen? Dann liegt er in der Spezifikation.
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Der Lauf ist vorbei. Prüfen Sie:

Aufgaben: Auswertung im Logbuch

Messen statt vermuten: Belegen Sie Erfolg und Probleme des Abends mit Abfragen.

Ihr Bearbeitungsfortschritt:0%
Aufgabe 3 (Partnerarbeit): Kennzahlen per SQL

Material: Lese-Code der Kurs-Datenbank, Start- und Endzeit des Laufs, die Go-Live-Abfragen der Abteilung Logbuch (Leitstand). Notieren Sie jede Abfrage mit ihrem Ergebnis.

Bestimmen Sie für den Lauf, wie viele Bestellungen angenommen (ANN), geliefert (LIE) und storniert (STO) wurden, und berechnen Sie die Lieferquote. Deuten Sie das Ergebnis: Welche nicht gelieferten Bestellungen sind ein Fehler des Liefernetzes, welche nicht?

Hilfe 1: Jede Statusmeldung steht als AUS-Zeile genau einmal im Logbuch – bei der Station, die sie gesendet hat.
Hilfe 2: nutzdaten LIKE '___LIE' passt auf jede Bestellnummer mit dem Code LIE; den Zeitraum begrenzt zeit BETWEEN … AND ….

Formulieren und beantworten Sie eine Frage zu Ihrer Abteilung, z. B. Zentrale: „Wie lange warteten Aufträge auf einen Kurier?“ (KOC bis ABH); Kurier: „Wie viele KRT-Pakete wurden gesendet?“; Kasse: „Wie viele Zahlungen gingen ein?“; Kundenverzeichnis: „Wie viele Anfragen kamen an?“; Bestellstatus: „Bei welchen Bestellungen fehlen Meldungen?“; Logbuch: „Hält sich jede Station an die Datenschutzregel?“.

Hilfe 1: Manche Fragen lassen sich wegen der Datenschutzregel des Logbuchs nicht beantworten. Halten Sie das fest – es ist ein bewusster Preis der Datensparsamkeit.

Bestimmen Sie für den Lauf (1) die Anzahl gesendeter Datenpakete je Station, (2) die defekt empfangenen Pakete je Station, (3) die Pakete, die mehr als zweimal gesendet wurden. Welche davon wurden abgebrochen?

Hilfe 1: Datenpakete sind alle außer ACK und NAK. Pakete mit fünf Versuchen sind Abbrüche.

Bestimmen Sie für drei Bestellungen Ihrer Wahl die Dauer von ANN bis LIE. Dauern eilige Bestellungen im Mittel kürzer?

Hilfe 1: Für eine einzelne Bestellung: MAX(zeit) - MIN(zeit) über alle AUS-Statusmeldungen mit nutzdaten LIKE '005%'.
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Die Kennzahlen stehen. Prüfen Sie:

Aufgaben: Fehler analysieren

Aus den Kennzahlen werden Verbesserungen. Diese Aufgaben erledigen Sie als Hausaufgabe im Protokollblatt.

Ihr Bearbeitungsfortschritt:0%
Aufgabe 4 (Gruppenarbeit): Fehleranalyse und Verbesserung

Wählen Sie die zwei wichtigsten Probleme, die Ihre Abteilung betreffen (auch einen Ausfall Ihrer Station), und halten Sie je fest: Symptom, Beleg (Abfrage mit Ergebnis oder Logbuch-Zeilen), Ursache, Kategorie (Spezifikation / Implementierung / Betrieb), Verbesserung.

Hilfe 1: Ein Beleg ist etwas, das andere nachprüfen können – eine Abfrage samt Ergebnis, nicht „bei uns ging es“.

Ergänzen Sie im Protokollblatt die Regeln, die gefehlt haben, erhöhen Sie die Versionsnummer und informieren Sie betroffene Partnerabteilungen.

Hilfe 1: Formulieren Sie jede neue Regel als „Wenn … eintrifft / ausbleibt, dann sendet die Station … und …“.
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Ihre Analyse ist fertig. Prüfen Sie:

Aufgaben: Hotfix, Angriff und Last eA

Der zweite Abend: Die wichtigsten Fehler sind behoben, die Konkurrenz greift an, und es wird voll.

Ihr Bearbeitungsfortschritt:0%
Aufgabe 5 (Gruppenarbeit): Der zweite Abend

Beheben Sie die zwei wichtigsten Fehler aus dem ersten Lauf. Ändern Sie nur, was nötig ist, erhöhen Sie die Versionsnummer und informieren Sie die Partner, bevor der nächste Lauf startet.

Hilfe 1: Ein Hotfix ändert keine Formate ohne Zustimmung. Lässt sich ein Fehler nur durch eine Formatänderung beheben, gehört er ins Protokollblatt v2.0, nicht in den Hotfix.

Betreiben Sie Ihre Station in einem Lauf, in dem die Konkurrenz PIZPAR angreift und KUNDE1 viele Bestellungen in kurzer Zeit schickt (zwei Kuriere, Außenfiliale aktiv). Halten Sie für jeden Vorfall fest: Was haben Sie beobachtet? Welche Station hat ihn bemerkt, und wie (Ausgabe, Logbuch)? Welches Schutzziel war betroffen (Vertraulichkeit, Integrität, Authentizität, Verfügbarkeit)?

Hilfe 1: Gefälschte Absender erkennt FN/1 nicht – das Absenderfeld kann jeder beschreiben.

Wählen Sie zwei Angriffe, die im Lauf nicht abgewehrt wurden, und schlagen Sie je eine Abwehr vor, die mit Mitteln aus dem Unterricht umsetzbar ist. Beurteilen Sie den Aufwand.

Hilfe 1: Wie könnte eine Station prüfen, ob ein Paket wirklich vom angegebenen Absender kommt? Was müsste dafür vorher ausgetauscht werden?

Bestimmen Sie per SQL, wie viele Datenpakete pro Minute das Liefernetz im Lastlauf gesendet hat und wie lange Aufträge im Mittel auf einen Kurier warteten (KOC bis ABH, mit der Tabelle statusmeldung). Wo liegt der Engpass – im Funkprotokoll oder anderswo?

Hilfe 1: Durchsatz = Anzahl AUS-Datenpakete / Dauer in Minuten.
Hilfe 2: Die Wartezeit berechnen Sie mit einem Verbund der Tabelle statusmeldung mit sich selbst (Logbuch, Aufgabe 6).

Die Zentrale sendet jedes Paket mit Stop-and-Wait. Schätzen Sie ab: Bei 200 ms Laufzeit hin und zurück und 20 % Verlust – wie viele Pakete pro Sekunde schafft eine Station höchstens? Beschreiben Sie, was ein Schiebefenster (mehrere unquittierte Pakete) ändern würde.

Hilfe 1: Ein erfolgreicher Versuch dauert eine Rundlaufzeit, ein verlorener den Timeout von 2 s plus eine Rundlaufzeit.
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Der zweite Abend ist vorbei. Prüfen Sie:

Sicherung

Definition: Rauchtest

Ein kurzer Test unmittelbar vor dem Betrieb: Jede Partnerschaft tauscht ein Testpaket aus und prüft die Reaktion. Er findet Betriebsfehler (falsche Codes, Reihenfolge, Versionen) in Minuten statt erst im laufenden Betrieb.

Merke

Ein Protokoll bewährt sich erst im Zusammenspiel: Neben Spezifikation und Implementierung braucht es geregelten Betrieb – Startreihenfolge, Rauchtest, gleiche Versionen. Prüfsumme, Quittung, Wiederholung und Sequenznummer fangen Störungen im Kanal auf; was dann noch schiefgeht, liegt meist an Nutzdaten, unquittierten Rundrufen oder am Betrieb. Fehler belegt man mit Daten (Logbuch, SQL) und ordnet sie Spezifikation, Implementierung oder Betrieb zu. Jede Regel, die im Go-Live fehlte, gehört danach ins Protokollblatt.

Plan-Check

Vergleichen Sie Ihre Startreihenfolge und Ihre Kennzahlen aus dem Einstieg mit dem Abend: Was hat gestimmt, was hat gefehlt? Beantworten Sie danach die Leitfrage der Einheit in fünf Sätzen mit Beispielen aus Ihrem Go-Live: Wie können sich Zentrale, Kurierinnen und Kuriere, Kasse und Kundschaft über einen gemeinsamen, gestörten Funkkanal eindeutig und zuverlässig verständigen – und wer legt die Regeln dafür fest?

Rückbezug: 6 Bestellungen, 1 geliefert

Aus „6 Bestellungen, 1 geliefert“ wird ein Abend, dessen Lieferquote, Dauer und Fehler Sie mit SQL belegen können. Die Fehler der Generalprobe lagen fast alle im Betrieb – Startreihenfolge, Codes, Schlüssel – und verschwinden mit Startcheck und Rauchtest. Was im Lauf trotzdem schiefging, steht jetzt mit Beleg und Verbesserung im Protokollblatt, das damit auch den Fehlerfall regelt.


Präsentation und Reflexion eA

Worum es geht: Nächstes Jahr soll ein anderer Kurs das Liefernetz übernehmen – ohne Quelltext, nur mit den Protokollblättern. → Sie prüfen gegenseitig Ihre Protokollblätter, verteidigen eine zentrale Entwurfsentscheidung und ordnen das Liefernetz in echte Netze ein.

Einstieg: Der Probeleser

Störung im Liefernetz (Plenum)

Ein Probeleser aus dem Parallelkurs hat drei Protokollblätter gelesen und schreibt zurück:

  • Zentrale: „Was machen Sie, wenn die Adressanfrage abbricht? Steht nirgends.“
  • Kasse: „Ist der Betrag in Euro oder in Cent? Ihr Beispiel passt nicht zur Tabelle.“
  • Kurier: „Warum RLE und nicht Huffman? Sie schreiben nur ‚weil es geht‘.“

Leitfrage: Was muss in einem Protokollblatt stehen, damit eine andere Gruppe ohne Rückfrage eine passende Station bauen kann?

Nebenfragen:

  1. Welche Ihrer Entscheidungen waren wirklich Entwurfsentscheidungen – mit Alternativen und Begründung?
  2. Wo findet man die Ideen unseres Liefernetzes in echten Netzen wieder, und was haben wir nicht gelöst?

Unser Plan

Sammeln Sie im Kurs: Was fehlt dem Probeleser → was muss im Protokollblatt stehen?

  • Lesen Sie Ihr eigenes Protokollblatt so, als müssten Sie danach programmieren. Wo müssten Sie raten?
  • Suchen Sie die drei Entscheidungen, auf die Sie am meisten stolz sind – und eine, die Sie heute anders treffen würden.

Hinweis

Ablauf. Probelesen und Vortragsvorbereitung erledigen Sie als Hausaufgabe; die Protokollblätter werden vorher getauscht. In der Präsentationsstunde halten alle Gruppen ihren Vortrag, direkt danach folgt das Kolloquium Ihrer Gruppe. Danach vergleicht der Kurs das Liefernetz mit echten Netzen. Die Reflexion schreiben Sie einzeln als Hausaufgabe.

Aufgaben: Vorbereitung

Diese Aufgaben erledigen Sie vor der Präsentationsstunde.

Ihr Bearbeitungsfortschritt:0%
Aufgabe 1 (Gruppenarbeit): Gegenlesen und Vortrag vorbereiten

Material: das Protokollblatt einer anderen Gruppe (Tausch nach Losverfahren), Ihr eigenes Protokollblatt, Vorlage Tabelle Ü8.

Lesen Sie das fremde Blatt so, als müssten Sie danach eine kompatible Station bauen. Notieren Sie jede Stelle, an der Sie raten müssten, und prüfen Sie die Beispiele gegen die Formattabellen. Geben Sie Ihre Rückmeldung schriftlich an die Gruppe.

Hilfe 1: Prüfen Sie besonders: Gibt es für jedes Format ein Beispiel? Ist geregelt, was bei Fehlern passiert? Stimmen Längen und Positionen mit den Beispielen überein? Ist jede Bedingung der Karte belegt?

Bereiten Sie einen Kurzvortrag vor: (1) das Problem Ihrer Abteilung in einem Satz, (2) eine zentrale Entwurfsentscheidung mit Alternativen und Begründung, (3) einen Beleg aus Test oder Go-Live (Abfrage mit Ergebnis), (4) was Sie in Version 2 ändern würden. Jede Person spricht.

Hilfe 1: Gute Entscheidungen zum Vorstellen: Zentrale – Sortierung gegen mehrere Schlangen, Fairness; Kurier – RLE gegen Huffman, Tiefensuche gegen Breitensuche; Kundenverzeichnis – Einfügereihenfolge, Datensparsamkeit; Kasse – Klartextformat, Diffie-Hellman und seine Schwächen; Funkstrecke – Korrektur gegen Wiederholung, Bitbudget; Bestellstatus – strenger gegen toleranten Automaten; Logbuch – was gespeichert wird.
Hilfe 2: Zeigen Sie keinen Quelltext außer höchstens einer Methode, die die Entscheidung umsetzt.
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Sie sind vorbereitet. Prüfen Sie:

Aufgaben: Präsentation und Kolloquium

Jede Gruppe stellt ihre Entscheidung vor und beantwortet anschließend Fragen.

Ihr Bearbeitungsfortschritt:0%
Aufgabe 2 (Gruppenarbeit): Präsentation

Halten Sie Ihren Vortrag. Danach zieht jedes Gruppenmitglied eine Fragekarte der Lehrkraft (Kolloquium) und beantwortet sie am Protokollblatt oder am Code.

Hilfe 1: Typische Kolloquiumsfragen: „Was passiert, wenn … verloren geht / doppelt kommt / gefälscht ist?“, „Zeigen Sie im Code, wo …“, „Warum haben Sie … und nicht … gewählt?“, dazu eine Frage zum Kern.

Stellen Sie einer anderen Gruppe mindestens eine „Was passiert, wenn …?“-Frage zu deren Protokollblatt und notieren Sie die Antwort.

Hilfe 1: Fragemuster: „Was passiert, wenn das Paket … verloren geht / doppelt kommt / gefälscht ist / zu lang ist?“, „Was passiert, wenn zwei Stationen dasselbe Rufzeichen haben?“
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Die Präsentationen sind gehalten. Prüfen Sie:

Aufgaben: Unser Liefernetz und das Internet

Unser Liefernetz ist ein kleines Modell echter Netze. Ordnen Sie es ein.

Ihr Bearbeitungsfortschritt:0%
Aufgabe 3 (Partnerarbeit): Vergleich mit echten Protokollen

Material: Ein Schichtenmodell in vereinfachter Form: Bitübertragung, Sicherung, Vermittlung, Transport, Anwendung.

Ordnen Sie die Bausteine unseres Liefernetzes den Schichten zu und nennen Sie jeweils ein echtes Protokoll mit einer ähnlichen Aufgabe: Rauschen und Hamming (Funkstrecke); Prüfsumme mit NAK und Wiederholung; Rufzeichen und ALLE__; Sequenznummer; Teil/Gesamt; ADR (Kundenverzeichnis); Vigenère, Diffie-Hellman und Signatur (Kasse); BST, STA, ZAH.

Hilfe 1: Das Kundenverzeichnis übersetzt eine Nummer in einen Ort – welcher Internetdienst übersetzt Namen in Adressen?
Hilfe 2: Bei TCP gibt es keine NAKs; der Empfänger bestätigt, bis zu welchem Byte alles angekommen ist.

Nennen Sie drei Dinge, die echte Netze anders oder besser lösen als FN/1, und begründen Sie, warum wir sie im Unterricht weggelassen haben.

Hilfe 1: Denken Sie an den Durchsatz, an die Prüfsumme und an das gemeinsame Medium.
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Der Vergleich steht. Prüfen Sie:

Aufgaben: Reflexion

Diese Aufgaben bearbeiten Sie einzeln als Hausaufgabe und geben sie mit dem Protokollblatt ab.

Ihr Bearbeitungsfortschritt:0%
Aufgabe 4 (Einzelarbeit): Reflexion

Beurteilen Sie auf einer halben Seite: Welche personenbezogenen Daten fallen im Liefernetz an (auch Metadaten und die Klarnamen der Online-IDE)? Was haben wir geschützt, was nicht? Was müsste ein echter Lieferdienst zusätzlich tun?

Hilfe 1: Denken Sie an getFirstName() und getLastName() des WebSocket-Clients, an das Logbuch, an Kurierpositionen und an Pizza Paradiso.

Beschreiben Sie in fünf bis acht Sätzen Ihren eigenen Beitrag (konkret: welche Methode, welcher Test, welcher Fehler), Ihre wichtigste fachliche Erkenntnis und eine überprüfbare Verbesserung für Version 2.

Hilfe 1: Satzanfänge: „Ich habe … implementiert / entworfen.“ – „Schwierig war …, weil … Gelöst habe ich es, indem …“ – „In Version 2 würde ich …“
Ausgezeichnet – Alle Aufgaben abgeschlossen!

Ihre Reflexion ist fertig. Prüfen Sie:

Sicherung

Definition: Schichtenmodell

Aufteilung der Aufgaben eines Netzes auf übereinanderliegende Schichten (vereinfacht: Bitübertragung, Sicherung, Vermittlung, Transport, Anwendung). Jede Schicht löst ein Teilproblem und nutzt die Dienste der Schicht darunter.

Merke

Entwerfen heißt, unter vorgegebenen Bedingungen begründet zwischen Alternativen zu entscheiden und das Ergebnis so zu beschreiben, dass andere es umsetzen können – Formattabellen mit Beispielen, Regeln für Normal- und Fehlerfall, begründete Entscheidungen, Versionen. Die Ideen unseres Liefernetzes finden sich in echten Netzen in verschiedenen Schichten wieder – dort schneller, sicherer und sauber getrennt.

Plan-Check

Vergleichen Sie Ihre Liste „Was ein gutes Protokollblatt braucht“ mit den Rückmeldungen, die Ihre Gruppe beim Probelesen bekommen hat: Was hat gefehlt? Was ändern Sie bis zur Abgabe?

Rückbezug: Der Probeleser

Mit vollständigen Formattabellen samt passenden Beispielen, einer Regel für jeden Fehlerfall und Entscheidungen, die gegen Alternativen begründet sind, hätte der Probeleser keine seiner drei Fragen stellen müssen. Die Ideen unseres Liefernetzes – Fehlerkorrektur, Prüfsumme, Quittung, Sequenznummer, Fragmentierung, Namensdienst, Verschlüsselung – stecken in jedem echten Netz, dort nur schneller, sicherer und in Schichten getrennt.

Abiturtraining: Ein fremdes Protokoll

Worum es geht: Sie übertragen, was Sie an FN/1 gelernt haben, auf ein Protokoll, das Sie nicht kennen – mit Aufgaben im Abiturformat (Papier, ohne IDE).

Einstieg: Das Datenblatt der Wetterstation

Problem (Einzelarbeit, dann Plenum)

Das GSG baut auf dem Schuldach und im Schulgarten ein Netz aus Wetterstationen auf. Jede Station funkt ihre Messwerte an einen Schulserver. Der Hersteller liefert das Protokoll WS/1 mit – unten steht sein Datenblatt. Ein Mitschüler meint: „Das ist doch dasselbe wie FN/1, nur kürzer.“

Leitfrage: Ist WS/1 so zuverlässig wie FN/1? Legen Sie sich nach dem ersten Lesen des Datenblatts fest und nennen Sie einen Grund.

Unser Plan
  • Welche Fragen haben Sie an FN/1 gestellt, bevor Sie ihm vertraut haben?

Nr.Plan-PunktAufgabe
1Pakete zerlegen und bauen1
2Prüfverfahren an Fehlerarten testen2
3Zerlegen und Prüfen programmieren bzw. als Struktogramm3
4Abläufe mit Verlust darstellen, Entwurf bewerten und mit FN/1 vergleichen4, 5

Material: Datenblatt WS/1

Ein WS/1-Paket ist ein Text aus genau 19 Zeichen mit festen Feldern.

Tabelle A.1: Paketformat WS/1
FeldPos.LängeInhalt
Kennung0–23immer WS1
Station3–42Nummer der Wetterstation 01–99
Typ51M Messung (Station → Server), Q Quittung (Server → Station)
Seq61laufende Nummer 0–9, nach 9 folgt 0
Temperatur7–104Vorzeichen und Zehntelgrad: +215 = 21,5 °C, -035 = −3,5 °C
Feuchte11–133relative Luftfeuchte in % 000–100
Druck14–174Luftdruck in hPa, z. B. 1013
Prüfziffer181siehe unten

Prüfziffer: Betrachtet werden die Positionen 3 bis 17. Jede Ziffer wird mit ihrem Gewicht multipliziert: Gewicht 3 an geraden Positionen, Gewicht 1 an ungeraden Positionen. Zeichen, die keine Ziffern sind, zählen nicht. Die Prüfziffer ist die Summe dieser Produkte mod 10.

Ablauf: Station und Server halten sich an folgende Regeln.

  1. Die Station sendet eine Messung M an alle (geteiltes Medium) und wartet höchstens 5 Sekunden auf eine Quittung Q mit ihrer Stationsnummer und derselben Seq. Sonst sendet sie dasselbe Paket erneut, höchstens dreimal insgesamt.
  2. Der Server quittiert jede gültige Messung – auch eine Wiederholung. Er speichert eine Messung nur, wenn die Seq von der zuletzt gespeicherten Seq dieser Station abweicht.
  3. Ein ungültiges Paket ignoriert der Server; eine negative Quittung gibt es nicht.
  4. Quittungen tragen die Messwerte +0000000000, z. B. WS107Q3+00000000000.

Aufgaben: Pakete und Prüfziffer

Bearbeiten Sie die Aufgaben auf Papier. Die Bewertungseinheiten (BE) dienen der Orientierung wie im Abitur.

Ihr Bearbeitungsfortschritt:0%
Aufgabe 1 (Einzelarbeit): Ein Messpaket analysieren

AFB I · 7 BE

Zerlegen Sie das Paket WS107M3+21507210134 in seine Felder und geben Sie die Messwerte mit Einheiten an.

Hilfe 1: Zählen Sie ab Position 0. Die Temperatur beginnt mit dem Vorzeichen.
Hilfe 2: Die Temperatur steht in Zehntelgrad: 215 Zehntelgrad sind 21,5 °C.
Musterlösung

Station 7 meldet mit Seq 3: 21,5 °C, 72 % Luftfeuchte, 1013 hPa, Prüfziffer 4.

Erstellen Sie das vollständige Paket: Station 12 meldet mit Seq 4 eine Temperatur von −3,5 °C, 88 % Luftfeuchte und 998 hPa. Berechnen Sie die Prüfziffer nachvollziehbar.

Hilfe 1: Alle Zahlenfelder werden mit führenden Nullen auf ihre Breite gebracht. Wie schreiben Sie 998 hPa in vier Stellen?
Hilfe 2: Gehen Sie Feld für Feld vor: Ziffer · Gewicht (gerade Position 3, ungerade 1). An welcher Position steht das Vorzeichen, und zählt es mit?

Vor dem Vergleich: Prüfen Sie, ob Ihr Paket genau 19 Zeichen hat.

Musterlösung

Ohne Prüfziffer: WS112M4-0350880998.

Feld (Positionen)Ziffern · GewichtSumme
Station 12 (3–4)1·1 + 2·37
Typ M (5)keine Ziffer0
Seq 4 (6)4·312
Temperatur -035 (7–10)Vorzeichen zählt nicht; 0·3 + 3·1 + 5·318
Feuchte 088 (11–13)0·1 + 8·3 + 8·132
Druck 0998 (14–17)0·3 + 9·1 + 9·3 + 8·144

Summe 113, Prüfziffer 3. Paket: WS112M4-03508809983.

Aufgabe 2 (Einzelarbeit): Was erkennt die Prüfziffer?

AFB II · 6 BE

Gesendet wurde WS107M3+21507210134 (Summe 84, Prüfziffer 4). Untersuchen Sie, ob der Server die folgenden Verfälschungen erkennt. Begründen Sie jeweils mit der Änderung der Summe.

Tabelle A.2: Empfangene Varianten
Nr.empfangenFehlerart
(1)WS107M3+22507210134eine Ziffer verfälscht
(2)WS107M3+12507210134zwei Ziffern vertauscht
(3)WS107M3+21502710134zwei Ziffern vertauscht
(4)WS107M3-21507210134Vorzeichen verfälscht
Hilfe 1: Bei (1) ändert sich an Position 9 (Gewicht 1) eine 1 in eine 2. Um wie viel ändert sich die Summe?
Hilfe 2: Bei einer Vertauschung zweier Nachbarziffern a (Gewicht 3) und b (Gewicht 1) ändert sich die Summe von 3a + b auf 3b + a. Wann ist die Änderung durch 10 teilbar?

Vor dem Vergleich: Formulieren Sie für jede Variante, was der Server speichern würde.

Musterlösung
Nr.Änderung der Summeneue Prüfziffererkannt?
✓ (1)+1 → 855 ≠ 4ja
✓ (2)(3·1 + 2) − (3·2 + 1) = −2 → 822 ≠ 4ja
✗ (3)(3·2 + 7) − (3·7 + 2) = −10 → 744 = 4nein: 27 % statt 72 %
✗ (4)0 (Vorzeichen zählt nicht)4 = 4nein: −21,5 °C statt 21,5 °C

Allgemein: Eine Vertauschung benachbarter Ziffern a, b ändert die Summe um 2(a − b). Sie bleibt unerkannt, wenn a − b durch 5 teilbar ist (z. B. 7 und 2).

Ausgezeichnet – Alle Aufgaben abgeschlossen!

Sie können WS/1-Pakete lesen, bauen und prüfen.

Aufgaben: Programmieren und Abläufe

Die folgenden Methoden gehören zu einer Klasse WS1 (alle public static). Verwenden Sie nur die im Abitur zugelassenen String-Operationen (length, charAt, substring, equals, ASCII-Umwandlung, Integer.parseInt).

Ihr Bearbeitungsfortschritt:0%
Aufgabe 3 (Einzelarbeit): Zerlegen und prüfen

AFB II · 11 BE

Implementieren Sie temperatur(String paket): int, die die Temperatur in Zehntelgrad mit Vorzeichen liefert (+215 → 215, -035 → −35). Das Paket hat sicher 19 Zeichen.

Hilfe 1: Trennen Sie Vorzeichen (Position 7) und Betrag (Positionen 8–10).
Hilfe 2: paket.substring(8, 11) liefert den Betrag als Text; Integer.parseInt macht daraus eine Zahl.
Musterlösung
public static int temperatur(String paket) {
   int betrag = Integer.parseInt(paket.substring(8, 11));
   if (paket.charAt(7) == '-') {
      return -betrag;
   }
   return betrag;
}
Listing A.1: temperatur

Stellen Sie die Methode pruefziffer(String paket): int als Struktogramm dar. Sie berechnet die Prüfziffer nach dem Datenblatt aus den Positionen 3 bis 17.

Hilfe 1: Woran erkennen Sie mit ASCII-Werten, ob ein Zeichen eine Ziffer ist? (Vgl. zahlAus aus Kapitel 2.)

Hilfe 2: Ergänzen Sie:

summe ← 0
für i von 3 bis 17
c ← Zeichen an Position i von paket
____wahrfalsch
i mod 2 = 0wahrfalsch
summe ← ____
summe ← ____
–
gib summe mod 10 zurück
Struktogramm A.1: pruefziffer(paket: Zeichenkette): Ganzzahl
Musterlösung
summe ← 0
für i von 3 bis 17
c ← Zeichen an Position i von paket
c ≥ ‚0‘ und c ≤ ‚9‘wahrfalsch
i mod 2 = 0wahrfalsch
summe ← summe + 3 · (ASCII-Wert von c − 48)
summe ← summe + (ASCII-Wert von c − 48)
–
gib summe mod 10 zurück
Struktogramm A.2: pruefziffer(paket: Zeichenkette): Ganzzahl

Implementieren Sie istGueltig(String paket): boolean. Ein Paket ist gültig, wenn es genau 19 Zeichen hat, mit WS1 beginnt, den Typ M oder Q hat und die Prüfziffer an Position 18 mit pruefziffer(paket) übereinstimmt. Laufzeitfehler müssen ausgeschlossen sein.

Hilfe 1: In welcher Reihenfolge müssen Sie prüfen, damit charAt(18) keinen Laufzeitfehler auslöst?
Hilfe 2: Die Prüfziffer als Zahl: (int) paket.charAt(18) - 48. Was ergibt das, wenn dort keine Ziffer steht – und ist das ein Problem?

Vor dem Vergleich: Testen Sie Ihre Methode gedanklich mit "WS1" (zu kurz) und mit Variante (4) aus Aufgabe 2.

Musterlösung
public static boolean istGueltig(String paket) {
   if (paket == null || paket.length() != 19) {
      return false;
   }
   if (!paket.substring(0, 3).equals("WS1")) {
      return false;
   }
   char typ = paket.charAt(5);
   if (typ != 'M' && typ != 'Q') {
      return false;
   }
   int pz = (int) paket.charAt(18) - 48;
   return pz == pruefziffer(paket);
}
Listing A.2: istGueltig

Die Längenprüfung steht zuerst, sonst droht bei kurzen Texten ein Laufzeitfehler. Steht an Position 18 keine Ziffer, liegt pz außerhalb von 0–9 und ist nie gleich der berechneten Prüfziffer – das Paket ist ungültig. Variante (4) gilt als gültig.

Aufgabe 4 (Einzelarbeit): Ein Ablauf mit Verlust

AFB II · 7 BE

Station 07 sendet die Messung mit Seq 3. Der erste Versuch geht verloren. Der zweite kommt an, aber die Quittung geht verloren. Der dritte kommt an, die Quittung auch. Stellen Sie den Ablauf als Sequenzdiagramm dar (Zeit von oben nach unten) und beschreiben Sie, was der Server jeweils tut.

Hilfe 1: Wann wiederholt die Station? Welche Seq hat der Server von Station 07 zuletzt gespeichert, bevor der dritte Versuch ankommt?
Musterlösung

Als Tabelle notiert; gezeichnet stehen die Station und der Server nebeneinander.

ZeitStation 07KanalServer
✗ 0 ssendet M 3 (Versuch 1), wartet→ ✗ verloren
5 sTimeout → M 3 (Versuch 2)→
✗ 5,1 s✗ verloren ←gültig, Seq 3 neu → speichern, Q 3
10 sTimeout → M 3 (Versuch 3)→
10,2 sgültig, Seq 3 = letzte Seq von 07 → Duplikat: nicht speichern, aber Q 3
10,3 sQ 3 passt → fertig←

Beschreiben Sie, was dann bei Station und Server passiert, und beurteilen Sie die Folge.

Hilfe 1: Wie viele Versuche hat die Station insgesamt?
Musterlösung

Nach dem dritten Versuch und weiteren 5 s gibt die Station auf und meldet einen Fehler. Die Messung ist trotzdem gespeichert (seit Versuch 2). Die Station kann nicht unterscheiden, ob die Messung oder nur die Quittungen verloren gingen. Für Wetterdaten ist das unkritisch: Die nächste Messung kommt ohnehin.

Ausgezeichnet – Alle Aufgaben abgeschlossen!

Sie können ein fremdes Protokoll auf Papier analysieren und umsetzen.

Aufgaben: Bewerten und vergleichen

Zum Schluss beurteilen Sie WS/1 als Ganzes und vergleichen es mit FN/1.

Ihr Bearbeitungsfortschritt:0%
Aufgabe 5 (Einzelarbeit): WS/1 und FN/1

AFB III · 10 BE

Beurteilen Sie das Prüfverfahren von WS/1 im Vergleich zur Prüfsumme von FN/1. Gehen Sie auf einzelne Fehler, Vertauschungen und ungeschützte Zeichen ein und schlagen Sie eine begründete Verbesserung vor.

Hilfe 1: Nutzen Sie Ihre Ergebnisse aus Aufgabe 2 und aus Kapitel 4 (Aufgabe 4.1).
Hilfe 2: Strukturieren Sie mit einer Tabelle: Fehlerart | WS/1 | FN/1. Denken Sie auch daran, wie viele Prüfstellen es gibt.

Vor dem Vergleich: Haben Sie ein Urteil formuliert (nicht nur Unterschiede aufgezählt)?

Musterlösung
FehlerartWS/1FN/1
eine Ziffer verfälschtimmer erkannt (Gewicht 1 oder 3 mal Änderung 1–9 ist nie durch 10 teilbar)immer erkannt
ein Buchstabe/Vorzeichen verfälschtnie erkannt (zählt nicht mit)immer erkannt
Nachbarn vertauschterkannt, außer bei Differenz 5nie erkannt
zufällige Mehrfachfehleretwa jeder zehnte unerkannt (eine Prüfziffer)etwa jeder tausendste (drei Stellen)

Urteil: WS/1 ist bei Vertauschungen besser, hat aber eine gefährliche Lücke: Ein verfälschtes Vorzeichen macht aus 21,5 °C unbemerkt −21,5 °C, und Kennung und Typ sind ungeschützt. Mit nur einer Prüfziffer ist der Schutz insgesamt schwächer. Verbesserung z. B.: Vorzeichen als Ziffer kodieren (0 = +, 1 = −) und mitzählen, oder eine gewichtete Summe der ASCII-Werte aller Zeichen mod 97 als zweistellige Prüfzahl.

Bewerten Sie (1) die einstellige Seq und (2) den Verzicht auf negative Quittungen.

Hilfe 1: Mit welcher Seq vergleicht der Server bei Stop-and-Wait überhaupt? Wie viele verschiedene Werte braucht man dafür mindestens?
Hilfe 2: Was passiert bei FN/1 nach einem NAK, was bei WS/1 nach einem verfälschten Paket?
Musterlösung

(1) Bei Stop-and-Wait vergleicht der Server nur mit der zuletzt gespeicherten Seq derselben Station; eine Wiederholung trägt dieselbe Seq, die nächste Messung eine andere. Dafür reichen sogar zwei Werte (0/1, Alternating-Bit-Verfahren) – eine Ziffer genügt. Problematisch wird es nur, wenn eine Station neu startet und mit der zuletzt gespeicherten Seq beginnt. (2) Ohne NAK wartet die Station bei einem verfälschten Paket den Timeout von 5 s ab, statt sofort zu wiederholen: langsamer, aber einfacher, und ein Quittungs-Pingpong ist ausgeschlossen. Bei Messwerten im Minutentakt ist die Verzögerung unerheblich – die Entscheidung passt zum Einsatzzweck.

Ausgezeichnet – Alle Aufgaben abgeschlossen!

Sie haben WS/1 begründet bewertet.

Sicherung

Merke

Ein fremdes Protokoll untersuchen Sie mit vier Fragen: (1) Format: Welche Felder stehen wo, fest oder variabel? (2) Fehlererkennung: Welche Zeichen sind geschützt, welche Fehlerarten fallen auf? (3) Zuverlässigkeit: Quittung, Seq, Timeout, Wiederholung, Duplikaterkennung? (4) Zweck: Passen die Abwägungen zum Einsatz?

Plan-Check

Lesen Sie Ihre Festlegung aus dem Einstieg. Wo lag Ihr Mitschüler richtig, wo nicht?

Rückbezug: Das Datenblatt der Wetterstation

WS/1 benutzt dieselben Ideen wie FN/1 – feste Felder, Prüfwert, Stop-and-Wait mit Seq und Duplikaterkennung –, wägt aber anders ab: kürzer, kein NAK, eine Prüfziffer. „Genauso zuverlässig“ stimmt nicht: Vertauschungen erkennt WS/1 besser, ein verfälschtes Vorzeichen oder einen falschen Typ gar nicht.