diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index a9cdd0d88a066b473ec56f66313bb51bd2456464..ea3af64831862d96dafb73e1aab21617d45b76bf 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -1,14 +1,11 @@
 image: maven:latest
 
+cache:
+  key: EnigmaCache
+
 stages:
-  - clean
   - build
   - test
-  - deploy
-
-Clean Project files:
-  stage: clean
-  script: mvn clean
 
 Compile new version:
   stage: build
@@ -21,10 +18,4 @@ Run JUnit tests and verify:
     reports:
       junit:
       - target/surefire-reports/TEST-*.xml
-      - target/failsafe-reports/TEST-*.xml
-
-Deploy new version as Release:
-  stage: deploy
-  script:
-    - mvn versions:set -DnewVersion=$CI_COMMIT_TAG
-    - mvn assembly:assembly
+      - target/failsafe-reports/TEST-*.xml
\ No newline at end of file
diff --git a/src/main/java/projekt/enigma/GuiController.java b/src/main/java/projekt/enigma/GuiController.java
index d88fdd57956dae55db68d58c67429ce1bd56fd9a..3fa825e7a815dfe33bea548ab772e9da533466b1 100644
--- a/src/main/java/projekt/enigma/GuiController.java
+++ b/src/main/java/projekt/enigma/GuiController.java
@@ -221,16 +221,16 @@ public class GuiController {
      * mit dem Werten die die Klasse Codierer zur Verfügung stellt gefüllt.
      */
     private void setzeSteckverbindungen() {
-        tfStecker1.setText(codierer.getSteckverbindungen()[0][0] + "" + codierer.getSteckverbindungen()[0][1]);
-        tfStecker2.setText(codierer.getSteckverbindungen()[1][0] + "" + codierer.getSteckverbindungen()[1][1]);
-        tfStecker3.setText(codierer.getSteckverbindungen()[2][0] + "" + codierer.getSteckverbindungen()[2][1]);
-        tfStecker4.setText(codierer.getSteckverbindungen()[3][0] + "" + codierer.getSteckverbindungen()[3][1]);
-        tfStecker5.setText(codierer.getSteckverbindungen()[4][0] + "" + codierer.getSteckverbindungen()[4][1]);
-        tfStecker6.setText(codierer.getSteckverbindungen()[5][0] + "" + codierer.getSteckverbindungen()[5][1]);
-        tfStecker7.setText(codierer.getSteckverbindungen()[6][0] + "" + codierer.getSteckverbindungen()[6][1]);
-        tfStecker8.setText(codierer.getSteckverbindungen()[7][0] + "" + codierer.getSteckverbindungen()[7][1]);
-        tfStecker9.setText(codierer.getSteckverbindungen()[8][0] + "" + codierer.getSteckverbindungen()[8][1]);
-        tfStecker10.setText(codierer.getSteckverbindungen()[9][0] + "" + codierer.getSteckverbindungen()[9][1]);
+        tfStecker1.setText(codierer.fetchSteckverbindungen()[0][0] + "" + codierer.fetchSteckverbindungen()[0][1]);
+        tfStecker2.setText(codierer.fetchSteckverbindungen()[1][0] + "" + codierer.fetchSteckverbindungen()[1][1]);
+        tfStecker3.setText(codierer.fetchSteckverbindungen()[2][0] + "" + codierer.fetchSteckverbindungen()[2][1]);
+        tfStecker4.setText(codierer.fetchSteckverbindungen()[3][0] + "" + codierer.fetchSteckverbindungen()[3][1]);
+        tfStecker5.setText(codierer.fetchSteckverbindungen()[4][0] + "" + codierer.fetchSteckverbindungen()[4][1]);
+        tfStecker6.setText(codierer.fetchSteckverbindungen()[5][0] + "" + codierer.fetchSteckverbindungen()[5][1]);
+        tfStecker7.setText(codierer.fetchSteckverbindungen()[6][0] + "" + codierer.fetchSteckverbindungen()[6][1]);
+        tfStecker8.setText(codierer.fetchSteckverbindungen()[7][0] + "" + codierer.fetchSteckverbindungen()[7][1]);
+        tfStecker9.setText(codierer.fetchSteckverbindungen()[8][0] + "" + codierer.fetchSteckverbindungen()[8][1]);
+        tfStecker10.setText(codierer.fetchSteckverbindungen()[9][0] + "" + codierer.fetchSteckverbindungen()[9][1]);
     }
 
     /**
@@ -247,9 +247,9 @@ public class GuiController {
             tfKlartext.setText(textEingabe);
             tfCodiert.setText(textCodiert);
             codierer.letztesZeichenLoeschen();
-            mBtnStartPos1.setText(String.valueOf(this.codierer.getWalzen()[0]));
-            mBtnStartPos2.setText(String.valueOf(this.codierer.getWalzen()[1]));
-            mBtnStartPos3.setText(String.valueOf(this.codierer.getWalzen()[2]));
+            mBtnStartPos1.setText(String.valueOf(this.codierer.fetchWalzen()[0]));
+            mBtnStartPos2.setText(String.valueOf(this.codierer.fetchWalzen()[1]));
+            mBtnStartPos3.setText(String.valueOf(this.codierer.fetchWalzen()[2]));
         }
     }
 
@@ -311,9 +311,9 @@ public class GuiController {
             tfCodiert.setText(textCodiert);
 
             // Position der Walzen aktuallisieren
-            mBtnStartPos1.setText(String.valueOf(this.codierer.getWalzen()[0]));
-            mBtnStartPos2.setText(String.valueOf(this.codierer.getWalzen()[1]));
-            mBtnStartPos3.setText(String.valueOf(this.codierer.getWalzen()[2]));
+            mBtnStartPos1.setText(String.valueOf(this.codierer.fetchWalzen()[0]));
+            mBtnStartPos2.setText(String.valueOf(this.codierer.fetchWalzen()[1]));
+            mBtnStartPos3.setText(String.valueOf(this.codierer.fetchWalzen()[2]));
         }
     }
 
@@ -418,34 +418,34 @@ public class GuiController {
         mBtnNotchPos2.setText(String.valueOf(this.codierer.fetchRingstellung()[1]));
         mBtnNotchPos3.setText(String.valueOf(this.codierer.fetchRingstellung()[2]));
         // Walzennummern anzeigen
-        mBtnWalzPos1.setText(String.valueOf(this.codierer.getchWalzenNr()[0]));
-        mBtnWalzPos2.setText(String.valueOf(this.codierer.getchWalzenNr()[1]));
-        mBtnWalzPos3.setText(String.valueOf(this.codierer.getchWalzenNr()[2]));
+        mBtnWalzPos1.setText(String.valueOf(this.codierer.fetchWalzenNr()[0]));
+        mBtnWalzPos2.setText(String.valueOf(this.codierer.fetchWalzenNr()[1]));
+        mBtnWalzPos3.setText(String.valueOf(this.codierer.fetchWalzenNr()[2]));
         // Position der Walzen anzeigen
-        mBtnStartPos1.setText(String.valueOf(this.codierer.getWalzen()[0]));
-        mBtnStartPos2.setText(String.valueOf(this.codierer.getWalzen()[1]));
-        mBtnStartPos3.setText(String.valueOf(this.codierer.getWalzen()[2]));
+        mBtnStartPos1.setText(String.valueOf(this.codierer.fetchWalzen()[0]));
+        mBtnStartPos2.setText(String.valueOf(this.codierer.fetchWalzen()[1]));
+        mBtnStartPos3.setText(String.valueOf(this.codierer.fetchWalzen()[2]));
         // Steckbrett Felder setzen
-        tfStecker1.setText(this.codierer.getSteckverbindungen()[0][0] + "" +
-                this.codierer.getSteckverbindungen()[0][1]);
-        tfStecker2.setText(this.codierer.getSteckverbindungen()[1][0] + "" +
-                this.codierer.getSteckverbindungen()[1][1]);
-        tfStecker3.setText(this.codierer.getSteckverbindungen()[2][0] + "" +
-                this.codierer.getSteckverbindungen()[2][1]);
-        tfStecker4.setText(this.codierer.getSteckverbindungen()[3][0] + "" +
-                this.codierer.getSteckverbindungen()[3][1]);
-        tfStecker5.setText(this.codierer.getSteckverbindungen()[4][0] + "" +
-                this.codierer.getSteckverbindungen()[4][1]);
-        tfStecker6.setText(this.codierer.getSteckverbindungen()[5][0] + "" +
-                this.codierer.getSteckverbindungen()[5][1]);
-        tfStecker7.setText(this.codierer.getSteckverbindungen()[6][0] + "" +
-                this.codierer.getSteckverbindungen()[6][1]);
-        tfStecker8.setText(this.codierer.getSteckverbindungen()[7][0] + "" +
-                this.codierer.getSteckverbindungen()[7][1]);
-        tfStecker9.setText(this.codierer.getSteckverbindungen()[8][0] + "" +
-                this.codierer.getSteckverbindungen()[8][1]);
-        tfStecker10.setText(this.codierer.getSteckverbindungen()[9][0] + "" +
-                this.codierer.getSteckverbindungen()[9][1]);
+        tfStecker1.setText(this.codierer.fetchSteckverbindungen()[0][0] + "" +
+                this.codierer.fetchSteckverbindungen()[0][1]);
+        tfStecker2.setText(this.codierer.fetchSteckverbindungen()[1][0] + "" +
+                this.codierer.fetchSteckverbindungen()[1][1]);
+        tfStecker3.setText(this.codierer.fetchSteckverbindungen()[2][0] + "" +
+                this.codierer.fetchSteckverbindungen()[2][1]);
+        tfStecker4.setText(this.codierer.fetchSteckverbindungen()[3][0] + "" +
+                this.codierer.fetchSteckverbindungen()[3][1]);
+        tfStecker5.setText(this.codierer.fetchSteckverbindungen()[4][0] + "" +
+                this.codierer.fetchSteckverbindungen()[4][1]);
+        tfStecker6.setText(this.codierer.fetchSteckverbindungen()[5][0] + "" +
+                this.codierer.fetchSteckverbindungen()[5][1]);
+        tfStecker7.setText(this.codierer.fetchSteckverbindungen()[6][0] + "" +
+                this.codierer.fetchSteckverbindungen()[6][1]);
+        tfStecker8.setText(this.codierer.fetchSteckverbindungen()[7][0] + "" +
+                this.codierer.fetchSteckverbindungen()[7][1]);
+        tfStecker9.setText(this.codierer.fetchSteckverbindungen()[8][0] + "" +
+                this.codierer.fetchSteckverbindungen()[8][1]);
+        tfStecker10.setText(this.codierer.fetchSteckverbindungen()[9][0] + "" +
+                this.codierer.fetchSteckverbindungen()[9][1]);
     }
     //endregion
 }
diff --git a/src/main/java/projekt/enigma/model/Codebuch.java b/src/main/java/projekt/enigma/model/Codebuch.java
index 9ded525e6d41617d76f148556b5c8f278bb88a63..8971dd7af85df192f23b32d3102710e6dc789b65 100644
--- a/src/main/java/projekt/enigma/model/Codebuch.java
+++ b/src/main/java/projekt/enigma/model/Codebuch.java
@@ -23,6 +23,7 @@ import java.time.ZoneId;
  */
 public class Codebuch {
 
+	//region Variablen
 	/**
 	 * TODO: Dokumentieren tag
 	 * tag : int : gibt den Tag an
@@ -43,7 +44,9 @@ public class Codebuch {
 	 * steckverbindung : char[][] : stellt die Steckverbindungen im Steckbrett dar
 	 */
 	private char[][] steckverbindung;
+	//endregion
 
+	//region Konstruktor
 	/**
 	 * Im Konstruktor werden die Standardwerte gesetzt
 	 * <p>
@@ -64,7 +67,9 @@ public class Codebuch {
 			this.steckverbindung[i][1] = 'A';
 		}
 	}
+	//endregion
 
+	//region Funktionen & Methoden
 	/**
 	 * TODO: Dokumentieren
 	 * Holt den Tagesschluessel aus dem Codebuch ab. Ist kein Tag angegeben, wird der aktuelle Tag genutzt.
@@ -143,14 +148,46 @@ public class Codebuch {
 
 		return sb.toString();
 	}
+	//endregion
 
+	//region Setter
 	/**
-	 * Gibt den Tag dieser Instanz zurück
+	 * Setzt die Steckverbindung dieser Instanz
 	 *
-	 * @return int : Tag
+	 * @param kabel : String[] :  Die Steckverbindungen die gesteckt werden sollen.
+	 *              Jeder Eintrag im Array ist ein String mit zwei Zeichen.
+	 *              Diese werden in zwei chars zerlegt und anschließend im globalen
+	 *              Array gespeichert.
 	 */
-	public int getTag() {
-		return tag;
+	private void setSteckverbindung(String[] kabel) {
+		int counter = 0;
+
+		for (String stecker : kabel) {
+			char[] verbindung = new char[2];
+			verbindung[0] = stecker.charAt(0);
+			verbindung[1] = stecker.charAt(1);
+			this.steckverbindung[counter++] = verbindung;
+		}
+	}
+
+	/**
+	 * Setzt die Walzenlage dieser Instanz
+	 *
+	 * @param position   : int : Position der Walze
+	 * @param walzenlage : int : Welche Walze wurde eingesetzt
+	 */
+	private void setWalzenlage(int position, int walzenlage) {
+		this.walzenlage[position] = walzenlage;
+	}
+
+	/**
+	 * Setzt die Ringstellung dieser Instanz
+	 *
+	 * @param position     : int : Auf welche Walze wird der Ring aufgesetzt?
+	 * @param ringstellung : char : An dieser Position soll die nächste Walze weiter gedreht werden.TODO: String[] || int[]?
+	 */
+	private void setRingstellung(int position, int ringstellung) {
+		this.ringstellung[position] = ringstellung;
 	}
 
 	/**
@@ -159,6 +196,17 @@ public class Codebuch {
 	 * @param tag : int : Tag
 	 */
 	void setTag(int tag) { this.tag = tag; }
+	//endregion
+
+	//region Getter
+	/**
+	 * Gibt den Tag dieser Instanz zurück
+	 *
+	 * @return int : Tag
+	 */
+	public int getTag() {
+		return tag;
+	}
 
 	/**
 	 * Gibt die Walzenlage dieser Instanz zurück
@@ -187,43 +235,5 @@ public class Codebuch {
 	public char[][] getSteckverbindung() {
 		return this.steckverbindung;
 	}
-
-	/**
-	 * Setzt die Steckverbindung dieser Instanz
-	 *
-	 * @param kabel : String[] :  Die Steckverbindungen die gesteckt werden sollen.
-	 *              Jeder Eintrag im Array ist ein String mit zwei Zeichen.
-	 *              Diese werden in zwei chars zerlegt und anschließend im globalen
-	 *              Array gespeichert.
-	 */
-	private void setSteckverbindung(String[] kabel) {
-		int counter = 0;
-
-		for (String stecker : kabel) {
-			char[] verbindung = new char[2];
-			verbindung[0] = stecker.charAt(0);
-			verbindung[1] = stecker.charAt(1);
-			this.steckverbindung[counter++] = verbindung;
-		}
-	}
-
-	/**
-	 * Setzt die Walzenlage dieser Instanz
-	 *
-	 * @param position   : int : Position der Walze
-	 * @param walzenlage : int : Welche Walze wurde eingesetzt
-	 */
-	private void setWalzenlage(int position, int walzenlage) {
-		this.walzenlage[position] = walzenlage;
-	}
-
-	/**
-	 * Setzt die Ringstellung dieser Instanz
-	 *
-	 * @param position     : int : Auf welche Walze wird der Ring aufgesetzt?
-	 * @param ringstellung : char : An dieser Position soll die nächste Walze weiter gedreht werden.TODO: String[] || int[]?
-	 */
-	private void setRingstellung(int position, int ringstellung) {
-		this.ringstellung[position] = ringstellung;
-	}
+	//endregion
 }
diff --git a/src/main/java/projekt/enigma/model/Codierer.java b/src/main/java/projekt/enigma/model/Codierer.java
index 724cb462b9b6034bd2544aed4bd3446ebb7b1d0d..bf1c2aa20132b34479d75b51830aa1bb4164d836 100644
--- a/src/main/java/projekt/enigma/model/Codierer.java
+++ b/src/main/java/projekt/enigma/model/Codierer.java
@@ -14,463 +14,504 @@ import java.util.Random;
  */
 public class Codierer {
 
-	/**
-	 * Der Klartext Spruchschlüssel zur codierung der Nachricht
-	 */
-	private String spruchschluessel;
-	/**
-	 * Der Spruchschlüssel, mit den Tageswerten aus dem Codebuch, codiert
-	 */
-	private String spruchschluesselCodiert;
-	/**
-	 * Die Kenngruppe für die versendeten Nachrichten gedacht sind. Diese ist relevant für den Webservice (Funkraum)
-	 */
-	private String kenngruppe;
-	/**
-	 * Die Nachricht, welche der Benutzer eingibt, wird als String nachricht gespeichert
-	 * und im laufe der Benutzung ergänzt
-	 */
-	private String nachricht;
-	/**
-	 * Das Hardware Objekt. Hier werden alle Hardware relevanten Baugruppen gespeichert und verarbeitet.
-	 */
-	private Hardware hardware;
-	/**
-	 * Im Codebuch sind die Tageswerte zu finden. Über dieses Objekt kann darauf zugegriffen werden.
-	 */
-	private Codebuch codebuch;
-	/**
-	 * Der aktuelle Tagesschluessel. Dieser wird aus dem Codebuch ausgelesen und hier hinterlegt.
-	 */
-	private String tagesSchluessel;
-
-	/**
-	 * Der Konstruktor des Codierers
-	 * Hier werden die globalen Variablen auf ihre Standart Werte gesetzt sowie die Objekte Initialisiert.
-	 */
-	public Codierer() {
-
-		this.nachricht = "";
-		this.spruchschluessel = "";
-		this.spruchschluesselCodiert = "";
-		this.kenngruppe = "";
-		this.codebuch = new Codebuch();
-		this.codebuch.fetchTagesschluessel();
-	}
-
-	/**
-	 * Hier lesen wir den heutigen Eintrag aus dem Codebuch aus und erstellen ein Codebuch Objekt
-	 * Nach dem Codebuch werden dann die Ringe auf die Walzen gesteckt und die Walzen anschließend
-	 * in die Hardware gebaut.
-	 * <br>
-	 * Ein Reflektor wird definiert, jedoch keine Werte zugewisen, da wir nur einen besitzen und
-	 * deshalb alle Einstellungen hierfür Statisch im Reflektor definiert haben.
-	 * <br>
-	 * Das Steck wird ebenfalls definiert und die notwendigen Kabel eingesteckt laut dem heutigen
-	 * Codebuch Eintrag.
-	 */
-	private void initialisiereHardware() {
-
-		// Das Steckbrett initialisieren
-		Steckbrett sb = new Steckbrett();
-		char[][] verbinder = this.codebuch.getSteckverbindung();
-
-		// Für jedes Kabel eine Verbindung auf dem Steckbrett setzen
-		for (char[] kabel : verbinder) {
-			sb.setzeVertauschung(kabel[0], kabel[1]);
-		}
-
-		// Die Hardware aus dem Koffer holen (initialisieren)
-		this.hardware = new Hardware();
-
-		// Den Ring an der Walze anbringen und die Walze dann in die Hardware einsetzen
-		this.hardware.setWalzen(0, this.codebuch.getWalzenlage()[0], this.codebuch.getRingstellung()[0]);
-		this.hardware.setWalzen(1, this.codebuch.getWalzenlage()[1], this.codebuch.getRingstellung()[1]);
-		this.hardware.setWalzen(2, this.codebuch.getWalzenlage()[2], this.codebuch.getRingstellung()[2]);
-
-		// Der Hardware das gesetzte Steckbrett zuweisen
-		this.hardware.setSteckbrett(sb);
-
-		// Ein Reflektor Objekt erstellen und der Hardware bekannt geben
-		this.hardware.setReflektor(new Reflektor());
-
-	}
-
-	/**
-	 * Hier wird ein neuer Spruchschlüssel generiert.
-	 * <p>
-	 * Mit diesem werden die Walzen auf eine neue Startposition gestellt und dem Kopf, mit dem
-	 * Tagesschlüssel codiert, hinzugefügt.
-	 * <br>
-	 * Hierfür wird mittels der Funktion "randomBuchstabe" ein zufälliger Buchstabe generiert,
-	 * und geschaut ob dieser bereits in der globalen Variable (this.spruchschluessel) vorhanden ist.
-	 * Wenn nicht, wird der Buchstabe dem Spruchschlüssel hinzugefügt.
-	 * <br>
-	 * Dies wir nun so lange gemacht bis der Spruchschlüssel eine länge von drei Zeichen hat.
-	 */
-	public void generateSpruchschluessel() {
-
-		String klartext = "";
-
-		while (klartext.length() < 3) {
-			String temp = this.randomBuchstabe();
-			if (!klartext.contains(temp)) {
-				klartext += temp;
-			}
-		}
-
-		this.spruchschluessel = klartext;
-		this.spruchschluesselCodiert = this.codiere(klartext + klartext, false);
-
-		// Walzen auf den Spruchschlüssel stellen
-		this.hardware.setzePosition(0, this.spruchschluessel.charAt(0));
-		this.hardware.setzePosition(1, this.spruchschluessel.charAt(1));
-		this.hardware.setzePosition(2, this.spruchschluessel.charAt(2));
-
-		// Die Kenngruppe codieren und in der Nachricht speichern
-		this.codiere(this.kenngruppe, true);
-	}
-
-	/**
-	 * Der Spruchschlüssel wird, zur internen Verwendung, auch im Klartext gespeichert.
-	 * Wir brauchen diesen dann zum codieren der eigentlichen Nachricht.
-	 *
-	 * @return String : Der klartext Spruchschlüssel
-	 */
-	public String getSpruchschluessel() {
-		return this.spruchschluessel;
-	}
-
-	/**
-	 * Erstellen des Nachrichten Kopfes.
-	 * Hierfür wird die aktuelle Uhrzeit ausgelesen, die Länge der Nachricht sowie der, mit den
-	 * Tagescodes codierte, Spruchschlüssel.
-	 */
-	private String generateKopf() {
-		Calendar cal = Calendar.getInstance();
-
-		// Uhrzeit an den Kopf hängen
-		return String.format("%02d%02d", cal.get(Calendar.HOUR), cal.get(Calendar.MINUTE)) + " " +
-
-				// Zeichen Anzahl der Nachricht
-				this.nachricht.length() + " " +
-
-				// Spruchschlüssel anhängen
-				this.spruchschluesselCodiert.substring(0, 3) + " " + this.spruchschluesselCodiert.substring(3, 6) + " ";
-	}
-
-	/**
-	 * Einen zufälligen Buchstaben aus dem Alphabet generieren.
-	 * In der Funktion gibt es den String Alphabet, in welchem alle zulässigen Zeichen eingetragen sind.
-	 * Aus diesem String wird nun zufällig ein Zeichen ausgewählt und zurück gegeben.
-	 *
-	 * @return String : ein zufällig generierter Buchstabe
-	 */
-	private String randomBuchstabe() {
-		return String.valueOf((char) ('A' + new Random().nextInt(26)));
-	}
-
-	/**
-	 * Befehl die Nachricht an den Funker zu übergeben
-	 *
-	 * @throws IOException   : Die Antwort konnte nicht gelesen werden
-	 * @throws HttpException : Die Nachricht konnte nicht abgesendet werden
-	 */
-	public void sendeNachricht() throws IOException, HttpException {
-		String kopf = this.generateKopf();
-		new Funkraum().sendeFunkspruch(new Morsecode().convertBuchstabeToMorsecode(kopf + this.nachricht), this.kenngruppe);
-		this.nachricht = "";
-	}
-
-	/**
-	 * Gibt die letzte empfangene Nachricht zurück
-	 * <br>
-	 * String[0] Tag wann die Nachricht gesendet wurde
-	 * String[1] = Die verschlüsselte Nachricht
-	 * String[2] = Nachricht im Klartext
-	 */
-	public String[] empfangeNachricht() {
-
-		this.nachricht = "";
-		Morsecode mc = new Morsecode();
-		String[] nachricht = new String[4];
-		String[] codierteNachricht = new Funkraum().empfangeFunkspruch(this.kenngruppe);
-
-		if (codierteNachricht.length > 1 && codierteNachricht[1].split(" ").length > 3) {
-			nachricht[0] = codierteNachricht[0];
-			nachricht[1] = mc.convertMorsecodeToBuchstabe(codierteNachricht[1]);
-			nachricht[2] = this.decodiere(nachricht[1], Integer.parseInt(nachricht[0]));
-			StringBuilder sb = new StringBuilder();
-
-			sb.append(nachricht[1], 0, 16);
-			for (int i = 17; i <= nachricht[1].length(); ) {
-				if ((i + 5) < nachricht[1].length()) {
-					sb.append(nachricht[1], i, i + 5).append(" ");
-					i += 5;
-				} else {
-					sb.append(nachricht[1].substring(i));
-					break;
-				}
-			}
-			nachricht[1] = sb.toString();
-		} else {
-			nachricht[0] = "";
-			nachricht[1] = "";
-			nachricht[2] = "Es liegen keine neuen Nachrichten im Funkraum für Sie vor.";
-		}
-
-		return nachricht;
-	}
-
-	/**
-	 * Liest die Kenngruppe aus welche die Maschine gerade besitzt. Früher war dies eine eindeutige Nummer
-	 * die einer Einheit zugewiesen war. Wir hinterlegen hier einen Benutzernamen.
-	 *
-	 * @return String : Kenngruppe
-	 */
-	public String getKenngruppe() {
-		return kenngruppe;
-	}
-
-	/**
-	 * Setzt die Kenngruppe welche die Enigma gerade benutzt.
-	 *
-	 * @param kenngruppe : String : Kenngruppe welche die Enigma gerade benutzt
-	 */
-	public void setKenngruppe(String kenngruppe) {
-
-		this.kenngruppe = kenngruppe;
-		this.initialisiereHardware();
-
-	}
-
-	/**
-	 * Gibt die bisher erstellte Nachricht zurück
-	 *
-	 * @return String : Erstellte Nachricht
-	 */
-	public String getNachricht() {
-		return nachricht;
-	}
-
-	/**
-	 * Gibt die aktuellen Buchstaben auf den Walzen zurück
-	 *
-	 * @return char[] : Walzen Array mit der aktuellen Position
-	 */
-	public char[] getWalzen() {
-		char[] walzen = new char[3];
-		walzen[0] = this.hardware.getWalzen()[0].getPosition();
-		walzen[1] = this.hardware.getWalzen()[1].getPosition();
-		walzen[2] = this.hardware.getWalzen()[2].getPosition();
-
-		return walzen;
-	}
-
-	/**
-	 * Hier wird ein einzelner Buchstabe verschlüsselt.
-	 * Man muss hier ebenfalls mitgeben ob der codierte String in Codierer.nachricht gespeichert werden soll oder nicht.
-	 * In der Regel ist dies der Fall.
-	 *
-	 * @param buchstabe : char : Der zu codierende Buchstabe
-	 * @param save      : boolean : Nachricht speichern oder nicht
-	 * @return char     : Der codierte Buchstabe
-	 */
-	public char codiere(char buchstabe, boolean save) {
-		char codiert = this.hardware.codiere(buchstabe);
-		if (save) {
-			this.nachricht += codiert;
-		}
-
-		return codiert;
-	}
-
-	/**
-	 * Codiert den Übergebenen String.
-	 * Man muss hier ebenfalls mitgeben ob der codierte String in Codierer.nachricht gespeichert werden soll oder nicht.
-	 * In der Regel ist dies der Fall.
-	 *
-	 * @param klartext : String : Der zu codierende Text
-	 * @param save     : boolean : Nachricht speichern oder nicht
-	 * @return String : Der codierte Text zusätzlich als Rückgabe
-	 */
-	public String codiere(String klartext, boolean save) {
-
-		StringBuilder sb = new StringBuilder();
-
-		for (char buchstabe : klartext.toCharArray()) {
-			sb.append(this.codiere(buchstabe, save));
-		}
-
-		return sb.toString();
-	}
-
-	/**
-	 * Diese Funktion erwartet als (codierteNachricht) eine korrekte Enigma Nachricht.
-	 * Ihr muss auch der Tag der codierung mitgegeben werden. Dieser weiß dein Funker im Funkraum.
-	 * In der Regel ist dies der Tag des Nachrichten empfangs.
-	 *
-	 * @param codierteNachricht : String : Enigma codierte Nachricht
-	 * @param tag               : int : Tag der Nachricht
-	 * @return String : decodierte Nachricht
-	 */
-	private String decodiere(String codierteNachricht, int tag) {
-
-		// Hardware reseten und Tageseinstellungen aus dem Codebuch laden
-		this.initialisiereHardware();
-		this.codebuch.fetchTagesschluessel(tag);
-
-		String[] nachricht = codierteNachricht.split(" ");
-		StringBuilder sb = new StringBuilder();
-
-		// Uhrzeit
-		sb.append(nachricht[0]).append(" ");
-
-		// Zeichen Anzahl der Nachricht
-		sb.append(nachricht[1]).append(" ");
-
-		// Spruchschlüssel
-		String spruchschluessel = this.decodiereString(nachricht[2]);
-		sb.append(spruchschluessel).append(" ");
-		sb.append(this.decodiereString(nachricht[3])).append(" ");
-
-		// Walzen neu einstellen mit dem Spruchschlüssel
-		this.hardware.setzePosition(0, spruchschluessel.charAt(0));
-		this.hardware.setzePosition(1, spruchschluessel.charAt(1));
-		this.hardware.setzePosition(2, spruchschluessel.charAt(2));
-
-		// Nachricht decodieren
-		sb.append(this.decodiereString(nachricht[4]));
-
-		return sb.toString();
-	}
-
-	/**
-	 * Zerlegt den übergebenen String in einen char Array und decodiert jedes Zeichen.
-	 * Der String wird dann decodiert zurück gegeben.
-	 *
-	 * @param nachricht : String : Der zu decodierende Text
-	 * @return String : Der decodierte Text
-	 */
-	private String decodiereString(String nachricht) {
-
-		StringBuilder sb = new StringBuilder();
-
-		for (char buchstabe : nachricht.toCharArray()) {
-			if (buchstabe > 0) {
-				sb.append(this.hardware.codiere(buchstabe));
-			}
-		}
-
-		return sb.toString();
-	}
-
-	/**
-	 * Setzt die Enigma auf die Einstellungen des aktuellen Tages, aus dem Codebuch zurück.
-	 */
-	public void resetHardware() {
-		this.initialisiereHardware();
-	}
-
-	/**
-	 * Setzt den anzuzeigenden Buchstaben (buchstabe) auf der Walze (wlazenPosition)
-	 * TODO: Wenn die Walzen, Notches, Kabel, etc. verändert werden, muss die bisherige Nachricht (this.nachricht) gelöscht werden.
-	 *
-	 * @param walzenPosition : int : Nummer der Walze
-	 * @param buchstabe      : char : Buchstabe der zugewiesen soll
-	 */
-	public void setWalze(int walzenPosition, char buchstabe) {
-		this.hardware.setzePosition(walzenPosition, buchstabe);
-	}
-
-	/**
-	 * Setzt den Ring auf der Walze auf einen neuen Umstprungwert.
-	 *
-	 * @param walzenPosition : int : Walze auf die der Ring gesteckt wird
-	 * @param umsprungPunkt  : int : Buchstabe auf dem der Notch sitzt
-	 */
-	public void setRing(int walzenPosition, int umsprungPunkt) {
-		this.hardware.setzeRing(walzenPosition, umsprungPunkt);
-	}
-
-	/**
-	 * Setzt die Walze (walzeNr) in die Position (walzenPosition) der Enigma ein.
-	 * Mit (ringstellung) gibt man die Position des Umsprungpunktes an.
-	 *
-	 * @param walzenPosition : int : Position der Walze in der Enigma (1-2-3)
-	 * @param walzeNr        : int : Nummer der Walze die eingesetzt wird
-	 * @param ringstellung   : int : Stellung des Ringes
-	 */
-	public void setWalzeNr(int walzenPosition, int walzeNr, int ringstellung) {
-		this.hardware.setzeWalzenNr(walzenPosition, walzeNr, ringstellung);
-	}
-
-	/**
-	 * Setzt das Kabel in beide Ports ein und fügt es dem Steckbrett Array hinzu.
-	 *
-	 * @param port       : int : Kabel Nummer welches am Steckbrett eingesteckt wird
-	 * @param verbindung : String : Verbindung welche die vertauschten Buchstaben angibt
-	 * @return boolean : Wenn true, darf das Kabel gesteckt werden, wenn nicht, steckt da bereits schon eines
-	 */
-	public boolean setSteckbrett(int port, String verbindung) {
-		return this.hardware.getSteckbrett().setzeVertauschung(port, verbindung.charAt(0), verbindung.charAt(1));
-	}
-
-	/**
-	 * Prüft ob der Port auf den das Kabel gesteckt werden soll, noch frei ist.
-	 * <p>
-	 * setSteckbrett ausführen mit beiden Buchstaben als String
-	 *
-	 * @param buchstabe : char : Der zuletzt eingegebene Buchstabe
-	 * @return boolean : Wenn der Buchstabe nicht vorhanden ist, wird true zurückgegeben, ansonsten false
-	 */
-	public boolean pruefeSteckbrettPort(char buchstabe) {
-		return this.hardware.getSteckbrett().ueberpruefeVertauschungen(buchstabe);
-	}
-
-	/**
-	 * Ließt aus der empfangenen Nachricht den Spruchschlüssel aus und gibt ihn zurück.
-	 *
-	 * @param empfangeneNachricht : String : Die empfangene Nachricht als String
-	 * @return String : Der Spruchschlüssel mit welcher die Nachricht codiert wurde.
-	 */
-	public String empfangenerSpruchschluessel(String empfangeneNachricht) {
-		String[] nachricht = empfangeneNachricht.split(" ");
-
-		return nachricht[2];
-	}
-
-	/**
-	 * Gibt die Ringstellungen aus dem Codebuch zurück
-	 *
-	 * @return int[] : Array mit den Ringstellungen der drei eingesetzten Walzen
-	 */
-	public int[] fetchRingstellung() {
-		return this.codebuch.getRingstellung();
-	}
-
-	/**
-	 * Gibt die Walzennummer aus dem Codebuch zurück
-	 *
-	 * @return int[] : Array mit den Nummern der drei eingesetzten Walzen
-	 */
-	public int[] getchWalzenNr() {
-		return this.codebuch.getWalzenlage();
-	}
-
-	/**
-	 * Gibt die Steckverbindungen aus dem Codebuch zurück
-	 *
-	 * @return char[][] : Array mit den gesteckten Verbindungen im Steckbrett
-	 */
-	public char[][] getSteckverbindungen() {
-		return this.codebuch.getSteckverbindung();
-	}
-
-	/**
-	 * Löscht das letzte Zeichen aus der Nachricht und dreht die Walzen eine Position zurück.
-	 */
-	public void letztesZeichenLoeschen() {
-		this.hardware.dreheWalzen(-1);
-	}
+    //region Variablen
+    /**
+     * Der Klartext Spruchschlüssel zur codierung der Nachricht
+     */
+    private String spruchschluessel;
+
+    /**
+     * Der Spruchschlüssel, mit den Tageswerten aus dem Codebuch, codiert
+     */
+    private String spruchschluesselCodiert;
+
+    /**
+     * Die Kenngruppe für die versendeten Nachrichten gedacht sind. Diese ist relevant für den Webservice (Funkraum)
+     */
+    private String kenngruppe;
+
+    /**
+     * Die Nachricht, welche der Benutzer eingibt, wird als String nachricht gespeichert
+     * und im laufe der Benutzung ergänzt
+     */
+    private String nachricht;
+
+    /**
+     * Das Hardware Objekt. Hier werden alle Hardware relevanten Baugruppen gespeichert und verarbeitet.
+     */
+    private Hardware hardware;
+
+    /**
+     * Im Codebuch sind die Tageswerte zu finden. Über dieses Objekt kann darauf zugegriffen werden.
+     */
+    private Codebuch codebuch;
+    //endregion
+
+    //region Konstruktor
+    /**
+     * Der Konstruktor des Codierers
+     * Hier werden die globalen Variablen auf ihre Standart Werte gesetzt sowie die Objekte Initialisiert.
+     */
+    public Codierer() {
+
+        this.nachricht = "";
+        this.spruchschluessel = "";
+        this.spruchschluesselCodiert = "";
+        this.kenngruppe = "";
+        this.codebuch = new Codebuch();
+        this.codebuch.fetchTagesschluessel();
+    }
+    //endregion
+
+    //region Funktionen & Methoden
+
+    //region Reset & Initialisieren
+    /**
+     * Hier lesen wir den heutigen Eintrag aus dem Codebuch aus und erstellen ein Codebuch Objekt
+     * Nach dem Codebuch werden dann die Ringe auf die Walzen gesteckt und die Walzen anschließend
+     * in die Hardware gebaut.
+     * <br>
+     * Ein Reflektor wird definiert, jedoch keine Werte zugewisen, da wir nur einen besitzen und
+     * deshalb alle Einstellungen hierfür Statisch im Reflektor definiert haben.
+     * <br>
+     * Das Steck wird ebenfalls definiert und die notwendigen Kabel eingesteckt laut dem heutigen
+     * Codebuch Eintrag.
+     */
+    private void initialisiereHardware() {
+
+        // Das Steckbrett initialisieren
+        Steckbrett sb = new Steckbrett();
+        char[][] verbinder = this.codebuch.getSteckverbindung();
+
+        // Für jedes Kabel eine Verbindung auf dem Steckbrett setzen
+        for (char[] kabel : verbinder) {
+            sb.setzeVertauschung(kabel[0], kabel[1]);
+        }
+
+        // Die Hardware aus dem Koffer holen (initialisieren)
+        this.hardware = new Hardware();
+
+        // Den Ring an der Walze anbringen und die Walze dann in die Hardware einsetzen
+        this.hardware.setWalzen(0, this.codebuch.getWalzenlage()[0], this.codebuch.getRingstellung()[0]);
+        this.hardware.setWalzen(1, this.codebuch.getWalzenlage()[1], this.codebuch.getRingstellung()[1]);
+        this.hardware.setWalzen(2, this.codebuch.getWalzenlage()[2], this.codebuch.getRingstellung()[2]);
+
+        // Der Hardware das gesetzte Steckbrett zuweisen
+        this.hardware.setSteckbrett(sb);
+
+        // Ein Reflektor Objekt erstellen und der Hardware bekannt geben
+        this.hardware.setReflektor(new Reflektor());
+    }
+
+    /**
+     * Setzt die Enigma auf die Einstellungen des aktuellen Tages, aus dem Codebuch zurück.
+     */
+    public void resetHardware() {
+        this.initialisiereHardware();
+    }
+    //endregion
+
+    //region Nachrichten handler
+    /**
+     * Befehl die Nachricht an den Funker zu übergeben
+     *
+     * @throws IOException   : Die Antwort konnte nicht gelesen werden
+     * @throws HttpException : Die Nachricht konnte nicht abgesendet werden
+     */
+    public void sendeNachricht() throws IOException, HttpException {
+        String kopf = this.generateKopf();
+        new Funkraum().sendeFunkspruch(new Morsecode().convertBuchstabeToMorsecode(kopf + this.nachricht), this.kenngruppe);
+        this.nachricht = "";
+        this.resetHardware();
+    }
+
+    /**
+     * Gibt die letzte empfangene Nachricht zurück
+     * <br>
+     * String[0] Tag wann die Nachricht gesendet wurde
+     * String[1] = Die verschlüsselte Nachricht
+     * String[2] = Nachricht im Klartext
+     */
+    public String[] empfangeNachricht() {
+
+        // Alte Nachrichten Variable erstmal leeren
+        this.nachricht = "";
+        // Morsecode Objekt initialisieren
+        Morsecode mc = new Morsecode();
+        // Unser Nachrichten Array soll drei Einträge erhalten
+        String[] nachricht = new String[4];
+        // Abrufen der letzten Nachricht, für unsere Kenngruppe, aus dem Funkraum
+        String[] codierteNachricht = new Funkraum().empfangeFunkspruch(this.kenngruppe);
+
+        // Prüfen ob Nachrichtenlänge > 1 und die codierte Nachricht mehr als drei Felder (" ") hat
+        if (codierteNachricht.length > 1 && codierteNachricht[1].split(" ").length > 3) {
+            // Den Tag der Nachricht speichern
+            nachricht[0] = codierteNachricht[0];
+            // Die Nachricht von Morsecode in Buchstaben konvertieren
+            nachricht[1] = mc.convertMorsecodeToBuchstabe(codierteNachricht[1]);
+            // Die Enigma Nachricht (nachricht[1]) mittels der Tageseinstellungen (nachricht[0]) decodieren
+            nachricht[2] = this.decodiere(nachricht[1], Integer.parseInt(nachricht[0]));
+            // StringBuilder initialisieren
+            StringBuilder sb = new StringBuilder();
+
+            sb.append(nachricht[1], 0, 16);
+            for (int i = 17; i <= nachricht[1].length(); ) {
+                if ((i + 5) < nachricht[1].length()) {
+                    sb.append(nachricht[1], i, i + 5).append(" ");
+                    i += 5;
+                } else {
+                    sb.append(nachricht[1].substring(i));
+                    break;
+                }
+            }
+            nachricht[1] = sb.toString();
+        } else {
+            nachricht[0] = "";
+            nachricht[1] = "";
+            nachricht[2] = "Es liegen keine neuen Nachrichten im Funkraum für Sie vor.";
+        }
+
+        return nachricht;
+    }
+    //endregion
+
+    //region Generatoren
+    /**
+     * Hier wird ein neuer Spruchschlüssel generiert.
+     * <p>
+     * Mit diesem werden die Walzen auf eine neue Startposition gestellt und dem Kopf, mit dem
+     * Tagesschlüssel codiert, hinzugefügt.
+     * <br>
+     * Hierfür wird mittels der Funktion "randomBuchstabe" ein zufälliger Buchstabe generiert,
+     * und geschaut ob dieser bereits in der globalen Variable (this.spruchschluessel) vorhanden ist.
+     * Wenn nicht, wird der Buchstabe dem Spruchschlüssel hinzugefügt.
+     * <br>
+     * Dies wir nun so lange gemacht bis der Spruchschlüssel eine länge von drei Zeichen hat.
+     */
+    public void generateSpruchschluessel() {
+
+        String klartext = "";
+
+        while (klartext.length() < 3) {
+            String temp = this.randomBuchstabe();
+            if (!klartext.contains(temp)) {
+                klartext += temp;
+            }
+        }
+
+        this.spruchschluessel = klartext;
+        this.spruchschluesselCodiert = this.codiere(klartext + klartext, false);
+
+        // Walzen auf den Spruchschlüssel stellen
+        this.hardware.setzePosition(0, this.spruchschluessel.charAt(0));
+        this.hardware.setzePosition(1, this.spruchschluessel.charAt(1));
+        this.hardware.setzePosition(2, this.spruchschluessel.charAt(2));
+
+        // Die Kenngruppe codieren und in der Nachricht speichern
+        this.codiere(this.kenngruppe, true);
+    }
+
+    /**
+     * Erstellen des Nachrichten Kopfes.
+     * Hierfür wird die aktuelle Uhrzeit ausgelesen, die Länge der Nachricht sowie der, mit den
+     * Tagescodes codierte, Spruchschlüssel.
+     */
+    private String generateKopf() {
+        Calendar cal = Calendar.getInstance();
+
+        // Uhrzeit an den Kopf hängen
+        return String.format("%02d%02d", cal.get(Calendar.HOUR), cal.get(Calendar.MINUTE)) + " " +
+                // Zeichen Anzahl der Nachricht
+                this.nachricht.length() + " " +
+                // Spruchschlüssel anhängen
+                this.spruchschluesselCodiert.substring(0, 3) + " " + this.spruchschluesselCodiert.substring(3, 6) + " ";
+    }
+
+    /**
+     * Einen zufälligen Buchstaben aus dem Alphabet generieren.
+     * In der Funktion gibt es den String Alphabet, in welchem alle zulässigen Zeichen eingetragen sind.
+     * Aus diesem String wird nun zufällig ein Zeichen ausgewählt und zurück gegeben.
+     *
+     * @return String : ein zufällig generierter Buchstabe
+     */
+    private String randomBuchstabe() {
+        return String.valueOf((char) ('A' + new Random().nextInt(26)));
+    }
+    //endregion
+
+    //region setzte Funktionen
+    /**
+     * Setzt den anzuzeigenden Buchstaben (buchstabe) auf der Walze (wlazenPosition)
+     * TODO: Wenn die Walzen, Notches, Kabel, etc. verändert werden, muss die bisherige Nachricht (this.nachricht) gelöscht werden.
+     *
+     * @param walzenPosition : int : Nummer der Walze
+     * @param buchstabe      : char : Buchstabe der zugewiesen soll
+     */
+    public void setzeWalze(int walzenPosition, char buchstabe) {
+        this.hardware.setzePosition(walzenPosition, buchstabe);
+    }
+
+    /**
+     * Setzt den Ring auf der Walze auf einen neuen Umstprungwert.
+     *
+     * @param walzenPosition : int : Walze auf die der Ring gesteckt wird
+     * @param umsprungPunkt  : int : Buchstabe auf dem der Notch sitzt
+     */
+    public void setzeRing(int walzenPosition, int umsprungPunkt) {
+        this.hardware.setzeRing(walzenPosition, umsprungPunkt);
+    }
+
+    /**
+     * Setzt die Walze (walzeNr) in die Position (walzenPosition) der Enigma ein.
+     * Mit (ringstellung) gibt man die Position des Umsprungpunktes an.
+     *
+     * @param walzenPosition : int : Position der Walze in der Enigma (1-2-3)
+     * @param walzeNr        : int : Nummer der Walze die eingesetzt wird
+     * @param ringstellung   : int : Stellung des Ringes
+     */
+    public void setzeWalzeNr(int walzenPosition, int walzeNr, int ringstellung) {
+        this.hardware.setzeWalzenNr(walzenPosition, walzeNr, ringstellung);
+    }
+
+    /**
+     * Setzt das Kabel in beide Ports ein und fügt es dem Steckbrett Array hinzu.
+     *
+     * @param port       : int : Kabel Nummer welches am Steckbrett eingesteckt wird
+     * @param verbindung : String : Verbindung welche die vertauschten Buchstaben angibt
+     * @return boolean : Wenn true, darf das Kabel gesteckt werden, wenn nicht, steckt da bereits schon eines
+     */
+    public boolean setzeSteckbrett(int port, String verbindung) {
+        return this.hardware.getSteckbrett().setzeVertauschung(port, verbindung.charAt(0), verbindung.charAt(1));
+    }
+    //endregion
+
+    //region fetch Funktionen
+
+    /**
+     * Gibt die Ringstellungen aus dem Codebuch zurück
+     *
+     * @return int[] : Array mit den Ringstellungen der drei eingesetzten Walzen
+     */
+    public int[] fetchRingstellung() {
+        return this.codebuch.getRingstellung();
+    }
+
+    /**
+     * Gibt die Walzennummer aus dem Codebuch zurück
+     *
+     * @return int[] : Array mit den Nummern der drei eingesetzten Walzen
+     */
+    public int[] fetchWalzenNr() {
+        return this.codebuch.getWalzenlage();
+    }
+
+    /**
+     * Gibt die Steckverbindungen aus dem Codebuch zurück
+     *
+     * @return char[][] : Array mit den gesteckten Verbindungen im Steckbrett
+     */
+    public char[][] fetchSteckverbindungen() {
+        return this.codebuch.getSteckverbindung();
+    }
+
+    /**
+     * Gibt die aktuellen Buchstaben auf den Walzen zurück
+     *
+     * @return char[] : Walzen Array mit der aktuellen Position
+     */
+    public char[] fetchWalzen() {
+        char[] walzen = new char[3];
+        walzen[0] = this.hardware.getWalzen()[0].getPosition();
+        walzen[1] = this.hardware.getWalzen()[1].getPosition();
+        walzen[2] = this.hardware.getWalzen()[2].getPosition();
+
+        return walzen;
+    }
+    //endregion
+
+    //region codierer
+    /**
+     * Hier wird ein einzelner Buchstabe verschlüsselt.
+     * Man muss hier ebenfalls mitgeben ob der codierte String in Codierer.nachricht gespeichert werden soll oder nicht.
+     * In der Regel ist dies der Fall.
+     *
+     * @param buchstabe : char : Der zu codierende Buchstabe
+     * @param save      : boolean : Nachricht speichern oder nicht
+     * @return char     : Der codierte Buchstabe
+     */
+    public char codiere(char buchstabe, boolean save) {
+
+        char codiert = this.hardware.codiere(buchstabe);
+
+        if (save) {
+            this.nachricht += codiert;
+        }
+
+        return codiert;
+    }
+
+    /**
+     * Codiert den Übergebenen String.
+     * Man muss hier ebenfalls mitgeben ob der codierte String in Codierer.nachricht gespeichert werden soll oder nicht.
+     * In der Regel ist dies der Fall.
+     *
+     * @param klartext : String : Der zu codierende Text
+     * @param save     : boolean : Nachricht speichern oder nicht
+     * @return String : Der codierte Text zusätzlich als Rückgabe
+     */
+    public String codiere(String klartext, boolean save) {
+
+        StringBuilder sb = new StringBuilder();
+
+        for (char buchstabe : klartext.toCharArray()) {
+            sb.append(this.codiere(buchstabe, save));
+        }
+
+        return sb.toString();
+    }
+
+    /**
+     * Diese Funktion erwartet als (codierteNachricht) eine korrekte Enigma Nachricht.
+     * Ihr muss auch der Tag der codierung mitgegeben werden. Dieser weiß dein Funker im Funkraum.
+     * In der Regel ist dies der Tag des Nachrichten empfangs.
+     *
+     * @param codierteNachricht : String : Enigma codierte Nachricht
+     * @param tag               : int : Tag der Nachricht
+     * @return String : decodierte Nachricht
+     */
+    private String decodiere(String codierteNachricht, int tag) {
+
+        // Hardware reseten und Tageseinstellungen aus dem Codebuch laden
+        this.initialisiereHardware();
+        this.codebuch.fetchTagesschluessel(tag);
+
+        // Nachricht splitten mit whitespace als delimiter
+        String[] nachricht = codierteNachricht.split(" ");
+        StringBuilder sb = new StringBuilder();
+
+        // Uhrzeit
+        sb.append(nachricht[0]).append(" ");
+
+        // Zeichen Anzahl der Nachricht
+        sb.append(nachricht[1]).append(" ");
+
+        // Spruchschlüssel
+        String spruchschluessel = this.decodiereString(nachricht[2]);
+
+        sb.append(spruchschluessel).append(" ");
+        sb.append(this.decodiereString(nachricht[3])).append(" ");
+
+        // Walzen neu einstellen mit dem Spruchschlüssel
+        this.hardware.setzePosition(0, spruchschluessel.charAt(0));
+        this.hardware.setzePosition(1, spruchschluessel.charAt(1));
+        this.hardware.setzePosition(2, spruchschluessel.charAt(2));
+
+        // Nachricht decodieren
+        sb.append(this.decodiereString(nachricht[4]));
+
+        return sb.toString();
+    }
+
+    /**
+     * Zerlegt den übergebenen String in einen char Array und decodiert jedes Zeichen.
+     * Der String wird dann decodiert zurück gegeben.
+     *
+     * @param nachricht : String : Der zu decodierende Text
+     * @return String : Der decodierte Text
+     */
+    private String decodiereString(String nachricht) {
+
+        StringBuilder sb = new StringBuilder();
+
+        for (char buchstabe : nachricht.toCharArray()) {
+            if (buchstabe > 0) {
+                sb.append(this.hardware.codiere(buchstabe));
+            }
+        }
+
+        return sb.toString();
+    }
+    //endregion
+
+    //region Sonstige
+
+    /**
+     * Prüft ob der Port auf den das Kabel gesteckt werden soll, noch frei ist.
+     * <p>
+     * setSteckbrett ausführen mit beiden Buchstaben als String
+     *
+     * @param buchstabe : char : Der zuletzt eingegebene Buchstabe
+     * @return boolean : Wenn der Buchstabe nicht vorhanden ist, wird true zurückgegeben, ansonsten false
+     */
+    public boolean pruefeSteckbrettPort(char buchstabe) {
+        return this.hardware.getSteckbrett().ueberpruefeVertauschungen(buchstabe);
+    }
+
+    /**
+     * Ließt aus der empfangenen Nachricht den Spruchschlüssel aus und gibt ihn zurück.
+     *
+     * @param empfangeneNachricht : String : Die empfangene Nachricht als String
+     * @return String : Der Spruchschlüssel mit welcher die Nachricht codiert wurde.
+     */
+    public String empfangenerSpruchschluessel(String empfangeneNachricht) {
+        String[] nachricht = empfangeneNachricht.split(" ");
+
+        return nachricht[2];
+    }
+
+    /**
+     * Löscht das letzte Zeichen aus der Nachricht und dreht die Walzen eine Position zurück.
+     */
+    public void letztesZeichenLoeschen() {
+        this.hardware.dreheWalzen(-1);
+    }
+    //endregion
+    //endregion
+
+    //region Setter
+
+    /**
+     * Setzt die Kenngruppe welche die Enigma gerade benutzt.
+     *
+     * @param kenngruppe : String : Kenngruppe welche die Enigma gerade benutzt
+     */
+    public void setKenngruppe(String kenngruppe) {
+
+        this.kenngruppe = kenngruppe;
+        this.initialisiereHardware();
+
+    }
+    //endregion
+
+    //region Getter
+
+    /**
+     * Gibt die bisher erstellte Nachricht zurück
+     *
+     * @return String : Erstellte Nachricht
+     */
+    public String getNachricht() {
+        return nachricht;
+    }
+
+    /**
+     * Liest die Kenngruppe aus welche die Maschine gerade besitzt. Früher war dies eine eindeutige Nummer
+     * die einer Einheit zugewiesen war. Wir hinterlegen hier einen Benutzernamen.
+     *
+     * @return String : Kenngruppe
+     */
+    public String getKenngruppe() {
+        return kenngruppe;
+    }
+
+    /**
+     * Der Spruchschlüssel wird, zur internen Verwendung, auch im Klartext gespeichert.
+     * Wir brauchen diesen dann zum codieren der eigentlichen Nachricht.
+     *
+     * @return String : Der klartext Spruchschlüssel
+     */
+    public String getSpruchschluessel() {
+        return this.spruchschluessel;
+    }
+    //endregion
 }
diff --git a/src/main/java/projekt/enigma/model/Hardware.java b/src/main/java/projekt/enigma/model/Hardware.java
index 58ac07827ed796bc9bfa9605f9b8c1bfe31dff84..4fc0c5ba2b22eac34592a1ea65f32105ff53dec9 100644
--- a/src/main/java/projekt/enigma/model/Hardware.java
+++ b/src/main/java/projekt/enigma/model/Hardware.java
@@ -15,161 +15,174 @@ package projekt.enigma.model;
  */
 public class Hardware {
 
-	/**
-	 * TODO: Dokumentieren
-	 */
-	private Walze[] walzen;
-	private Steckbrett steckbrett;
-	private Reflektor reflektor;
-
-	/**
-	 * Im Konstruktor legen wir die Anzahl der Walzen fest welche die Hardware aufnehmen kann.
-	 * Die Enigma I welche hier nachgebildet werden soll, konnte drei Walzen aufnehmen.
-	 */
-	public Hardware() {
-		this.walzen = new Walze[3];
-	}
-
-	/**
-	 * Setzt eine Walze ein
-	 *
-	 * @param walze    : int : Setzt die Walze mit der angegebenen Nummer ein
-	 * @param walzenNr : int : Die Nummer der einzusetzenden Walze
-	 */
-	public void setzeWalzenNr(int walze, int walzenNr, int ringstellung) {
-		this.walzen[walze] = new Walze(walzenNr, ringstellung);
-	}
-
-	/**
-	 * Setzt den Notch der Walze
-	 *
-	 * @param walze    : int : Position der Walze
-	 * @param position : int : Umspringpunkt auf der Walze
-	 */
-	public void setzeRing(int walze, int position) {
-		this.walzen[walze].setRingstellung(position);
-	}
-
-	/**
-	 * Setzt den Startwert (position) der Walze (walze)
-	 *
-	 * @param walze     : int : Nummer der Walze
-	 * @param buchstabe : char : Buchstabe der zugewiesen soll
-	 */
-	public void setzePosition(int walze, char buchstabe) {
-		this.walzen[walze].setPosition(buchstabe);
-	}
-
-	/**
-	 * Verschlüsselt den übergebenen Buchstaben und fügt ihn der Nachricht hinzu
-	 *
-	 * @param buchstabe char : Der zu ver/entschlüsselnde Buchstabe
-	 * @return char : Der ver/entschlüsselte Buchstabe
-	 */
-	public char codiere(char buchstabe) {
-		this.dreheWalzen(1);
-
-		buchstabe = this.steckbrett.codiere(Character.toUpperCase(buchstabe));
-		buchstabe = this.walzen[2].codiere(buchstabe);
-		buchstabe = this.walzen[1].codiere(buchstabe);
-		buchstabe = this.walzen[0].codiere(buchstabe);
-		buchstabe = this.reflektor.codiere(buchstabe);
-		buchstabe = this.walzen[0].codiere2(buchstabe);
-		buchstabe = this.walzen[1].codiere2(buchstabe);
-		buchstabe = this.walzen[2].codiere2(buchstabe);
-		buchstabe = this.steckbrett.codiere(buchstabe);
-
-		return buchstabe;
-	}
-
-	/**
-	 * Nach jeder codierung eines Buchstabens müssen die Walzen gedreht werden.
-	 * Hier überprüfen wir welche der Walzen gedreht werden müssen und stoßen die Vorgang an.
-	 */
-	public void dreheWalzen(int richtung) {
-		if (richtung > 0) {
-			for (int i = 0; i < richtung; i++) {
-				if (this.walzen[2].dreheWalze(1) && this.walzen[1].dreheWalze(1)) {
-					this.walzen[0].dreheWalze(1);
-				}
-			}
-		} else {
-			for (int i = 0; i > richtung; richtung++) {
-				if (this.walzen[2].dreheWalze(-1) && this.walzen[1].dreheWalze(-1)) {
-					this.walzen[0].dreheWalze(-1);
-				}
-			}
-		}
-	}
-
-	/**
-	 * Gibt die verbauten Walzen Objekte zurück
-	 *
-	 * @return Walze[] : Array mit den Walzen Objekten
-	 */
-	public Walze[] getWalzen() {
-		return this.walzen;
-	}
-
-	/**
-	 * Setzt eine Walze ein und speichert das Objekt im Walzen Array
-	 *
-	 * @param position     : int : Position der Walze
-	 * @param walze        : int : Die Nummer der Walze
-	 * @param ringstellung : int : Umsprung Punkt der Walze
-	 */
-	public void setWalzen(int position, int walze, int ringstellung) {
-		this.walzen[position] = new Walze(walze, ringstellung);
-	}
-
-	/**
-	 * Gibt das Objekt des Steckbretts zurück
-	 *
-	 * @return Steckbrett : Das eingesetzte Steckbrett mit seinen Kabeln wenn eingesteckt
-	 */
-	public Steckbrett getSteckbrett() {
-		return steckbrett;
-	}
-
-	/**
-	 * Setzt das übergebene Steckbrett Objekt in die Hardware ein
-	 *
-	 * @param steckbrett : Steckbrett : Objekt des Steckbretts mit allen verbundenen Kabeln
-	 */
-	public void setSteckbrett(Steckbrett steckbrett) {
-		this.steckbrett = steckbrett;
-	}
-
-	/**
-	 * Liest den Reflektor aus und gibt ihn zurück
-	 *
-	 * @return Reflektor : Objekt des Reflektors
-	 */
-	public Reflektor getReflektor() {
-		return reflektor;
-	}
-
-	/**
-	 * Setzt den Reflektor ein.
-	 * In der Enigma I welche hier nachgebaut wird, gab es nur einen Reflektor.
-	 * Spätere Versionen haten zwei oder mehr, deshalb haben wir hier auch schon ein Objekt dafür erstellt,
-	 * welches ausgetauscht werden kann.
-	 *
-	 * @param reflektor : Reflektor : Das Obejtk des Reflektors
-	 */
-	public void setReflektor(Reflektor reflektor) {
-		this.reflektor = reflektor;
-	}
-
-	/**
-	 * Diese Funktion setzt die Walzen auf ihren Anfangswert zurück.
-	 * Hierfür ist der Buchstabe "A" festgelegt.
-	 * Dies wird benötigt um zB einen neuen Spruchschlüssel einzustellen oder eine neue Nachricht zu verfassen.
-	 */
-	public void resetWalzen() {
-		this.getWalzen()[0].setPosition('A');
-		this.getWalzen()[1].setPosition('A');
-		this.getWalzen()[2].setPosition('A');
-	}
+    //region Variablen
+    /**
+     * TODO: Dokumentieren
+     */
+    private Walze[] walzen;
+    private Steckbrett steckbrett;
+    private Reflektor reflektor;
+    //endregion
+
+    //region Konstruktor
+    /**
+     * Im Konstruktor legen wir die Anzahl der Walzen fest welche die Hardware aufnehmen kann.
+     * Die Enigma I welche hier nachgebildet werden soll, konnte drei Walzen aufnehmen.
+     */
+    public Hardware() {
+        this.walzen = new Walze[3];
+    }
+    //endregion
+
+    //region Funktionen & Methoden
+    /**
+     * Setzt eine Walze ein
+     *
+     * @param walze    : int : Setzt die Walze mit der angegebenen Nummer ein
+     * @param walzenNr : int : Die Nummer der einzusetzenden Walze
+     */
+    public void setzeWalzenNr(int walze, int walzenNr, int ringstellung) {
+        this.walzen[walze] = new Walze(walzenNr, ringstellung);
+    }
+
+    /**
+     * Setzt den Notch der Walze
+     *
+     * @param walze    : int : Position der Walze
+     * @param position : int : Umspringpunkt auf der Walze
+     */
+    public void setzeRing(int walze, int position) {
+        this.walzen[walze].setRingstellung(position);
+    }
+
+    /**
+     * Setzt den Startwert (position) der Walze (walze)
+     *
+     * @param walze     : int : Nummer der Walze
+     * @param buchstabe : char : Buchstabe der zugewiesen soll
+     */
+    public void setzePosition(int walze, char buchstabe) {
+        this.walzen[walze].setPosition(buchstabe);
+    }
+
+    /**
+     * Verschlüsselt den übergebenen Buchstaben und fügt ihn der Nachricht hinzu
+     *
+     * @param buchstabe char : Der zu ver/entschlüsselnde Buchstabe
+     * @return char : Der ver/entschlüsselte Buchstabe
+     */
+    public char codiere(char buchstabe) {
+
+        buchstabe = Character.toUpperCase(buchstabe);
+        this.dreheWalzen(1);
+
+        buchstabe = this.steckbrett.codiere(Character.toUpperCase(buchstabe));
+        buchstabe = this.walzen[2].codiere(buchstabe);
+        buchstabe = this.walzen[1].codiere(buchstabe);
+        buchstabe = this.walzen[0].codiere(buchstabe);
+        buchstabe = this.reflektor.codiere(buchstabe);
+        buchstabe = this.walzen[0].codiere2(buchstabe);
+        buchstabe = this.walzen[1].codiere2(buchstabe);
+        buchstabe = this.walzen[2].codiere2(buchstabe);
+        buchstabe = this.steckbrett.codiere(buchstabe);
+
+        return buchstabe;
+    }
+
+    /**
+     * Nach jeder codierung eines Buchstabens müssen die Walzen gedreht werden.
+     * Hier überprüfen wir welche der Walzen gedreht werden müssen und stoßen die Vorgang an.
+     */
+    public void dreheWalzen(int richtung) {
+        if (richtung > 0) {
+            for (int i = 0; i < richtung; i++) {
+                if (this.walzen[2].dreheWalze(1) && this.walzen[1].dreheWalze(1)) {
+                    this.walzen[0].dreheWalze(1);
+                }
+            }
+        } else {
+            for (int i = 0; i > richtung; richtung++) {
+                if (this.walzen[2].dreheWalze(-1) && this.walzen[1].dreheWalze(-1)) {
+                    this.walzen[0].dreheWalze(-1);
+                }
+            }
+        }
+    }
+
+    /**
+     * Diese Funktion setzt die Walzen auf ihren Anfangswert zurück.
+     * Hierfür ist der Buchstabe "A" festgelegt.
+     * Dies wird benötigt um zB einen neuen Spruchschlüssel einzustellen oder eine neue Nachricht zu verfassen.
+     */
+    public void resetWalzen() {
+        this.getWalzen()[0].setPosition('A');
+        this.getWalzen()[1].setPosition('A');
+        this.getWalzen()[2].setPosition('A');
+    }
+    //endregion
+
+    //region Setter
+    /**
+     * Setzt eine Walze ein und speichert das Objekt im Walzen Array
+     *
+     * @param position     : int : Position der Walze
+     * @param walze        : int : Die Nummer der Walze
+     * @param ringstellung : int : Umsprung Punkt der Walze
+     */
+    public void setWalzen(int position, int walze, int ringstellung) {
+        this.walzen[position] = new Walze(walze, ringstellung);
+    }
+
+    /**
+     * Setzt den Reflektor ein.
+     * In der Enigma I welche hier nachgebaut wird, gab es nur einen Reflektor.
+     * Spätere Versionen haten zwei oder mehr, deshalb haben wir hier auch schon ein Objekt dafür erstellt,
+     * welches ausgetauscht werden kann.
+     *
+     * @param reflektor : Reflektor : Das Obejtk des Reflektors
+     */
+    public void setReflektor(Reflektor reflektor) {
+        this.reflektor = reflektor;
+    }
+
+    /**
+     * Setzt das übergebene Steckbrett Objekt in die Hardware ein
+     *
+     * @param steckbrett : Steckbrett : Objekt des Steckbretts mit allen verbundenen Kabeln
+     */
+    public void setSteckbrett(Steckbrett steckbrett) {
+        this.steckbrett = steckbrett;
+    }
+    //endregion
+
+    //region Getter
+
+    /**
+     * Gibt das Objekt des Steckbretts zurück
+     *
+     * @return Steckbrett : Das eingesetzte Steckbrett mit seinen Kabeln wenn eingesteckt
+     */
+    public Steckbrett getSteckbrett() {
+        return steckbrett;
+    }
+
+    /**
+     * Liest den Reflektor aus und gibt ihn zurück
+     *
+     * @return Reflektor : Objekt des Reflektors
+     */
+    public Reflektor getReflektor() {
+        return reflektor;
+    }
+
+    /**
+     * Gibt die verbauten Walzen Objekte zurück
+     *
+     * @return Walze[] : Array mit den Walzen Objekten
+     */
+    public Walze[] getWalzen() {
+        return this.walzen;
+    }
+    //endregion
 
 }
diff --git a/src/main/java/projekt/enigma/model/Reflektor.java b/src/main/java/projekt/enigma/model/Reflektor.java
index 9e5e6b1424852c8ee063179f8a8d216aac9c969a..dca62412c87722b6660ae8118899662c636aee04 100644
--- a/src/main/java/projekt/enigma/model/Reflektor.java
+++ b/src/main/java/projekt/enigma/model/Reflektor.java
@@ -1,6 +1,7 @@
 package projekt.enigma.model;
 
 /**
+ * TODO: Dokumentation aktuallisieren
  * Klasse Reflektor
  * <br>
  * Der Reflektor nimmt einen Buchstaben der Klasse Walze entgegen und und kodiert diesen.
@@ -12,17 +13,6 @@ package projekt.enigma.model;
  */
 public class Reflektor {
 
-    /**
-     * WALZE_ALPHABET : konstanter Char-Array mit den Werten des Alphabeths (26 Werte)
-     */
-    private final Character[] WALZE_ALPHABET = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
-
-    /**
-     * WALZE_REFLEKTOR : konstanter Char-Array mit den Werten des Reflektors (26 Werte)
-     */
-    private final Character[] WALZE_REFLEKTOR = {'E', 'J', 'M', 'Z', 'A', 'L', 'Y', 'X', 'V', 'B', 'W', 'F', 'C', 'R', 'Q', 'U', 'O', 'N', 'T', 'S', 'P', 'I', 'K', 'H', 'G', 'D'};
-
-
     /**
      * Funktion codiere
      * <br>
@@ -33,16 +23,11 @@ public class Reflektor {
      * @return WALZE_REFLEKTOR[iPositionReflektor]: Character: Der kodierte Buchstabe aus dem Reflektor
      */
     public char codiere(Character buchstabe) {
-        int iPositionReflektor = 0;
-
-        //Ermittelt die Position des Buchstaben "buchstabe" auf der Alphabetswalze
-        for (int index = 0; index < WALZE_ALPHABET.length; index++) {
-            if (buchstabe.equals(WALZE_ALPHABET[index])) {
-                iPositionReflektor = index;
-                break;
-            }
-        }
+        // alphabet : String mit den Werten des Alphabeths (26 Werte)
+        String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        // reflektor : String mit den Werten des Reflektors (26 Werte)
+        String reflektor = "EJMZALYXVBWFCRQUONTSPIKHGD";
 
-        return WALZE_REFLEKTOR[iPositionReflektor];
+        return reflektor.charAt(alphabet.indexOf(buchstabe));
     }
 }
diff --git a/src/main/java/projekt/enigma/model/Steckbrett.java b/src/main/java/projekt/enigma/model/Steckbrett.java
index ec18c7ae9aed17c12a2bd361eda796f0c6cb5497..b2d698f7b576b685230f97dd524b8e7767e60147 100644
--- a/src/main/java/projekt/enigma/model/Steckbrett.java
+++ b/src/main/java/projekt/enigma/model/Steckbrett.java
@@ -1,6 +1,8 @@
 package projekt.enigma.model;
 
 /**
+ * TODO: Dokumentation aktuallisieren
+ * <p>
  * Klasse Steckbrett
  * <br>
  * Das Steckbrett diente dazu Buchstaben paarweise zu vertauschen noch bevor diese durch die Walzen codiert werden.
@@ -9,134 +11,125 @@ package projekt.enigma.model;
  */
 public class Steckbrett {
 
-	/**
-	 * zaehler: Int, der als Laufvariable für die gesteckten Kabel genutzt wird
-	 */
-	private int zaehler;
-
-	/**
-	 * orginalBuchstaben: Character-Array, der jeweils den ersten zu vertauschenden Buchstaben enthält
-	 */
-	private Character[] orginalBuchstaben;
-
-	/**
-	 * getauschteBuchstaben: Character-Array, der jeweils den zweiten zu vertauschenden Buchstaben enthält
-	 */
-	private Character[] getauschteBuchstaben;
-
-
-	/**
-	 * Konstruktor Steckbrett
-	 * <br>
-	 * Erzeugt zwei Charakter-Arrays (orginalBuchstaben und getauschteBuchstaben) der Länge 10.
-	 */
-	public Steckbrett() {
-
-		orginalBuchstaben = new Character[10];
-		getauschteBuchstaben = new Character[10];
-	}
-
-	/**
-	 * Funktion setzeVertauschung
-	 * <br>
-	 * Der Funktion setzeVertauschung werden 2 Buchstaben (buchstabe1 und buchstabe2) übergeben.
-	 * Zuerst wird überprüft ob einer der beiden Buchstaben bereits enthalten ist, was unzulässig wäre.
-	 * <br>
-	 * Anschließend wird:
-	 * <p>
-	 * buchstabe1 in das Array orginalBuchstaben auf den nächsten, freien Index geschrieben
-	 * buchstabe2 in das Array getauschteBuchstaben auf den nächsten, freien Index geschrieben.
-	 * </p>
-	 *
-	 * @param buchstabe1 : char: Gibt den ersten Buchstaben an, der getauscht werden soll.
-	 * @param buchstabe2 : char: gibt den zweiten Buchstaben an, mit dem der erste getauscht werden soll.
-	 * @return boolean : Wenn die Vertauschung zulässig ist, true, ansonsten false
-	 */
-	public boolean setzeVertauschung(char buchstabe1, char buchstabe2) {
-
-		if (!ueberpruefeVertauschungen(buchstabe1) && !ueberpruefeVertauschungen(buchstabe2) && (zaehler < orginalBuchstaben.length)) {
-			orginalBuchstaben[zaehler] = buchstabe1;
-			getauschteBuchstaben[zaehler++] = buchstabe2;
-
-			return true;
-		} else {
-			return false;
-		}
-	}
-
-	/**
-	 * Funktion setzeVertauschung mit angabe eines Ports von 1 - 10
-	 * <br>
-	 * Der Funktion setzeVertauschung werden 2 Buchstaben (buchstabe1 und buchstabe2) sowie der Port übergeben.
-	 * Zuerst wird überprüft ob einer der beiden Buchstaben bereits enthalten ist, was unzulässig wäre.
-	 * <br>
-	 * Anschließend wird:
-	 * <p>
-	 * buchstabe1 in das Array orginalBuchstaben auf den Index (steckbrettPort) geschrieben
-	 * buchstabe2 in das Array getauschteBuchstaben auf den Index (steckbrettPort) geschrieben.
-	 * </p>
-	 *
-	 * @param buchstabe1 : char: Gibt den ersten Buchstaben an, der getauscht werden soll.
-	 * @param buchstabe2 : char: gibt den zweiten Buchstaben an, mit dem der erste getauscht werden soll.
-	 * @return boolean : Wenn die Vertauschung zulässig ist, true, ansonsten false
-	 */
-	public boolean setzeVertauschung(int steckbrettPort, char buchstabe1, char buchstabe2) {
-
-		if (!ueberpruefeVertauschungen(buchstabe1) && !ueberpruefeVertauschungen(buchstabe2)) {
-			orginalBuchstaben[steckbrettPort - 1] = buchstabe1;
-			getauschteBuchstaben[steckbrettPort - 1] = buchstabe2;
-
-			return true;
-		} else {
-
-			return false;
-		}
-
-	}
-
-	/**
-	 * Funktion ueberpruefeVertauschungen
-	 * <br>
-	 * Die Funktion ueberpruefeVertauschungen prueft ob der übergebene Buchstabe bereits in den beiden Arrays
-	 * (orginalBuchstaben) und (getauschteBuchstaben) vorhanden ist.
-	 * Eine Buchstabenvertauschung ist zulaessig, wenn keine Dopplungen der zu vertauschenden Buchstaben auftritt
-	 * (ein Buchstabe nicht mehrmals vertauscht wird).
-	 *
-	 * @return boolean :    Wenn false, dann darf der Buchstabe genutzt werden.
-	 * Wenn er schon vorhanden ist, wird true zurück gegeben
-	 */
-	public boolean ueberpruefeVertauschungen(Character buchstabe) {
-
-		boolean result = false;
-
-		for (int n = 0; n < orginalBuchstaben.length; n++) {
-			if (buchstabe.equals(orginalBuchstaben[n]) || buchstabe.equals(getauschteBuchstaben[n])) {
-				result = true;
-				break;
-			}
-		}
-
-		return result;
-	}
-
-	/**
-	 * Funktion codiere
-	 * <br>
-	 * Die Funktion codiere tauscht den uebergebenen Character buchstabe mit dem zu tauschenden Character aus.
-	 *
-	 * @param buchstabe : Character : Buchstabe der codiert werden soll.
-	 * @return buchstabe : Character : Codierter Buchstabe.
-	 */
-	public char codiere(Character buchstabe) {
-		for (int index = 0; index < getauschteBuchstaben.length; index++) {
-			if (buchstabe.equals(getauschteBuchstaben[index])) {
-				buchstabe = orginalBuchstaben[index];
-			} else if (buchstabe.equals(orginalBuchstaben[index])) {
-				buchstabe = getauschteBuchstaben[index];
-			}
-		}
-
-		return buchstabe;
-	}
-
-}
+    /**
+     * orginalBuchstaben: Character-Array, der jeweils den ersten zu vertauschenden Buchstaben enthält
+     */
+    private String originalBuchstaben;
+
+    /**
+     * getauschteBuchstaben: Character-Array, der jeweils den zweiten zu vertauschenden Buchstaben enthält
+     */
+    private String getauschteBuchstaben;
+
+
+    /**
+     * Konstruktor Steckbrett
+     * <br>
+     * Erzeugt zwei Charakter-Arrays (orginalBuchstaben und getauschteBuchstaben) der Länge 10.
+     */
+    public Steckbrett() {
+
+        originalBuchstaben = "";
+        getauschteBuchstaben = "";
+    }
+
+    /**
+     * Funktion setzeVertauschung
+     * <br>
+     * Der Funktion setzeVertauschung werden 2 Buchstaben (buchstabe1 und buchstabe2) übergeben.
+     * Zuerst wird überprüft ob einer der beiden Buchstaben bereits enthalten ist, was unzulässig wäre.
+     * <br>
+     * Anschließend wird:
+     * <p>
+     * buchstabe1 in das Array orginalBuchstaben auf den nächsten, freien Index geschrieben
+     * buchstabe2 in das Array getauschteBuchstaben auf den nächsten, freien Index geschrieben.
+     * </p>
+     *
+     * @param buchstabe1 : char: Gibt den ersten Buchstaben an, der getauscht werden soll.
+     * @param buchstabe2 : char: gibt den zweiten Buchstaben an, mit dem der erste getauscht werden soll.
+     * @return boolean : Wenn die Vertauschung zulässig ist, true, ansonsten false
+     */
+    public boolean setzeVertauschung(char buchstabe1, char buchstabe2) {
+
+        if (!ueberpruefeVertauschungen(buchstabe1) && !ueberpruefeVertauschungen(buchstabe2) && originalBuchstaben.length() <= 20) {
+            originalBuchstaben += buchstabe1;
+            getauschteBuchstaben += buchstabe2;
+
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Funktion setzeVertauschung mit angabe eines Ports von 1 - 10
+     * <br>
+     * Der Funktion setzeVertauschung werden 2 Buchstaben (buchstabe1 und buchstabe2) sowie der Port übergeben.
+     * Zuerst wird überprüft ob einer der beiden Buchstaben bereits enthalten ist, was unzulässig wäre.
+     * <br>
+     * Anschließend wird:
+     * <p>
+     * buchstabe1 in das Array orginalBuchstaben auf den Index (steckbrettPort) geschrieben
+     * buchstabe2 in das Array getauschteBuchstaben auf den Index (steckbrettPort) geschrieben.
+     * </p>
+     *
+     * @param buchstabe1 : char: Gibt den ersten Buchstaben an, der getauscht werden soll.
+     * @param buchstabe2 : char: gibt den zweiten Buchstaben an, mit dem der erste getauscht werden soll.
+     * @return boolean : Wenn die Vertauschung zulässig ist, true, ansonsten false
+     */
+    public boolean setzeVertauschung(int steckbrettPort, char buchstabe1, char buchstabe2) {
+
+        if (!ueberpruefeVertauschungen(buchstabe1) && !ueberpruefeVertauschungen(buchstabe2)) {
+            originalBuchstaben.replace(originalBuchstaben.charAt(steckbrettPort), buchstabe1);
+            getauschteBuchstaben.replace(getauschteBuchstaben.charAt(steckbrettPort), buchstabe2);
+
+            return true;
+        } else {
+            return false;
+        }
+
+    }
+
+    /**
+     * Funktion ueberpruefeVertauschungen
+     * <br>
+     * Die Funktion ueberpruefeVertauschungen prueft ob der übergebene Buchstabe bereits in den beiden Arrays
+     * (orginalBuchstaben) und (getauschteBuchstaben) vorhanden ist.
+     * Eine Buchstabenvertauschung ist zulaessig, wenn keine Dopplungen der zu vertauschenden Buchstaben auftritt
+     * (ein Buchstabe nicht mehrmals vertauscht wird).
+     *
+     * @return boolean :    Wenn false, dann darf der Buchstabe genutzt werden.
+     * Wenn er schon vorhanden ist, wird true zurück gegeben
+     */
+    public boolean ueberpruefeVertauschungen(Character buchstabe) {
+
+        boolean result = false;
+
+        if (originalBuchstaben.contains(String.valueOf(buchstabe)) ||
+                getauschteBuchstaben.contains(String.valueOf(buchstabe))) {
+            result = true;
+        }
+
+        return result;
+    }
+
+    /**
+     * Funktion codiere
+     * <br>
+     * Die Funktion codiere tauscht den uebergebenen Character buchstabe mit dem zu tauschenden Character aus.
+     *
+     * @param buchstabe : Character : Buchstabe der codiert werden soll.
+     * @return buchstabe : Character : Codierter Buchstabe.
+     */
+    public char codiere(Character buchstabe) {
+
+        if (originalBuchstaben.contains(String.valueOf(buchstabe))) {
+            return getauschteBuchstaben.charAt(originalBuchstaben.indexOf(buchstabe));
+        } else if(getauschteBuchstaben.contains(String.valueOf(buchstabe))) {
+            return originalBuchstaben.charAt(getauschteBuchstaben.indexOf(buchstabe));
+        } else {
+            return buchstabe;
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/src/main/java/projekt/enigma/model/Walze.java b/src/main/java/projekt/enigma/model/Walze.java
index 99d41248aa3aca3a3529674c1750a79c4ebe8a3a..62394acabc254ca541c3165e641de8d5b24fb5f6 100644
--- a/src/main/java/projekt/enigma/model/Walze.java
+++ b/src/main/java/projekt/enigma/model/Walze.java
@@ -1,9 +1,8 @@
 package projekt.enigma.model;
 
-import java.util.Arrays;
-import java.util.Collections;
-
 /**
+ * TODO: Dokumentation aktuallisieren
+ * <p>
  * Klasse Walze
  * <br>
  * Erzeugt ein Objekt des Typs Walze mit den Eigenschaften:
@@ -17,228 +16,174 @@ import java.util.Collections;
  */
 public class Walze {
 
-	/**
-	 * walzeAlpha : Character[] : Array, dass die Buchstaben des Alphabets enthaelt
-	 */
-	private Character[] alphabet;
-
-	/**
-	 * ringstellung : char : zeigt die Einstellung fuer den Umspringpunkt
-	 */
-	private char ringstellung;
-
-	/**
-	 * walzennr : int : Bestimmt, welche Walze genutzt wird
-	 */
-	private int walzennr;
-
-	/**
-	 * alphabet : Character[] : Enthaelt die Buchstaben des Alphabets. Wird im Laufe des Programmes
-	 * aber immer wieder ueberschrieben.
-	 */
-	private Character[] walzeAlpha;
-
-	/**
-	 * Ueberschriebener Konstruktor, der die Eingangsparameter der Walze mitgibt
-	 *
-	 * @param walzennr     : int : Nummer der gewaehlten Walze
-	 * @param ringstellung : int : Einstellung des Umsprungpunktes
-	 */
-	public Walze(int walzennr, int ringstellung) {
-		this.alphabet = new Character[]{'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
-				'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
-		this.walzeAlpha = new Character[]{'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
-				'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
-
-		this.setWalzennr(walzennr);
-		this.setRingstellung(ringstellung);
-	}
-
-	/**
-	 * Sortiert der Walzennummer das passende Character-Array mittels switch zu.
-	 *
-	 * @return walze : Character[] : gibt die gewaehlte Walze zurueck
-	 */
-	private Character[] walzenNummer() {
-		Character[] walze = new Character[26];
-
-		// Character-Arrays fuer die Codierung jeder Walze
-		Character[] walzeEins = {'E', 'K', 'M', 'F', 'L', 'G', 'D', 'Q', 'V', 'Z', 'N', 'T', 'O', 'W', 'Y',
-				'H', 'X', 'U', 'S', 'P', 'A', 'I', 'B', 'R', 'C', 'J'};
-		Character[] walzeZwei = {'A', 'J', 'D', 'K', 'S', 'I', 'R', 'U', 'X', 'B', 'L', 'H', 'W', 'T', 'M',
-				'C', 'Q', 'G', 'Z', 'N', 'P', 'Y', 'F', 'V', 'O', 'E'};
-		Character[] walzeDrei = {'B', 'D', 'F', 'H', 'J', 'L', 'C', 'P', 'R', 'T', 'X', 'V', 'Z', 'N', 'Y',
-				'E', 'I', 'W', 'G', 'A', 'K', 'M', 'U', 'S', 'Q', 'O'};
-		Character[] walzeVier = {'E', 'S', 'O', 'V', 'P', 'Z', 'J', 'A', 'Y', 'Q', 'U', 'I', 'R', 'H', 'X',
-				'L', 'N', 'F', 'T', 'G', 'K', 'D', 'C', 'M', 'W', 'B'};
-		Character[] walzeFuenf = {'V', 'Z', 'B', 'R', 'G', 'I', 'T', 'Y', 'U', 'P', 'S', 'D', 'N', 'H', 'L',
-				'X', 'A', 'W', 'M', 'J', 'Q', 'O', 'F', 'E', 'C', 'K'};
-
-		switch (this.walzennr) {
-			case 1:
-				walze = walzeEins;
-				break;
-			case 2:
-				walze = walzeZwei;
-				break;
-			case 3:
-				walze = walzeDrei;
-				break;
-			case 4:
-				walze = walzeVier;
-				break;
-			case 5:
-				walze = walzeFuenf;
-				break;
-		}
-
-		return walze;
-	}
-
-	/**
-	 * TODO: Dokumentieren
-	 *
-	 * @return ringstellung : char : gibt die neue Ringstellung als char zurueck
-	 */
-	public char getRingstellung() {
-		return ringstellung;
-	}
-
-	/**
-	 * Setzt die Initiale Ringstellung der Walze.
-	 * Es sind nur Zahlen von 1 - 26 zugelassen.
-	 * <p>
-	 * Die Ringstellung wird zum char umgewandelt.
-	 * Im Fehlerfall wird die Ringstellung standardmaessig auf 'Z' gesetzt.
-	 *
-	 * @param ringstellung : int : Punkt an dem die Walze umspringt
-	 */
-	//TODO ??? Setter Ringstellung
-	public void setRingstellung(int ringstellung) {
-		if ((ringstellung > 0) && (ringstellung <= 26)) {
-			this.ringstellung = this.alphabet[ringstellung - 1];
-		} else {
-			this.ringstellung = 'Z';
-		}
-	}
-
-	/**
-	 * Dreht die Walze: verschiebt das Alphabet um keine, eine oder mehrere Stellen und ueberschreibt
-	 * das Array alphabet mit der neuen Anordnung.
-	 * <p>
-	 * Ueberprueft, ob der Umspringpunkt der Walze nach der Drehung erreicht wurde.
-	 *
-	 * @param richtung : int : 1 dreht die Walze weiter und -1 dreht sie einen Schritt zurück
-	 * @return checkRing : boolean : gibt true zurueck wenn der Umspringpunkt erreicht wurde
-	 * TODO: Doku
-	 */
-	public boolean dreheWalze(int richtung) {
-		boolean checkRing = false;
-		int korrektorFaktor = 0;
-
-		if (richtung == 1) {
-			Collections.rotate(Arrays.asList(this.walzeAlpha), -1);
-		} else {
-			korrektorFaktor = 1;
-			Collections.rotate(Arrays.asList(this.walzeAlpha), 1);
-		}
-
-		// gleicht die Ringstellung mit der aktuellen Position ab
-		if (this.getPosition() + korrektorFaktor == this.ringstellung) {
-			checkRing = true;
-		}
-
-		return checkRing;
-	}
-
-	/**
-	 * Codiert den mitgegebenen Buchstaben anhand der gewaehlten Walze.
-	 *
-	 * @param buchstabe : char : Buchstabe, der verschluesselt werden soll
-	 * @return buchstabe : char : verschluesselter Buchstabe
-	 */
-	public char codiere(char buchstabe) {
-        /* durchsucht die (verschobene) Alphabetswalze nach dem aktuellen Buchstaben und
-        uebertraegt den Index auf die gewaehlte Codierwalze*/
-		buchstabe = walzenNummer()[fetchArrayIndex(buchstabe, walzeAlpha)];
-
-		return buchstabe;
-	}
-
-	/**
-	 * Decodiert den mitgegebenen Buchstaben mit Hilfe der (verschobenen) Alphabetswalze
-	 *
-	 * @param buchstabe : char : Buchstabe, der decodiert werden soll
-	 * @return buchstabe : char : decodierter Buchstabe
-	 */
-	public char codiere2(char buchstabe) {
-        /* durchsucht die gewaehlte Walze nach dem aktuellen Buchstaben und
-        uebertraegt den Index auf die (verschobene) Alphabetswalze*/
-		buchstabe = walzeAlpha[fetchArrayIndex(buchstabe, walzenNummer())];
-
-		return buchstabe;
-	}
-
-	/**
-	 * TODO: Dokumentieren
-	 * Ermittelt den Index eines Characters in einem Array ueber eine for-Schleife
-	 *
-	 * @param buchstabe : Character : Buchstabe, dessen Index benoetigt wird
-	 * @param array     : Character[] : Array, in dem der Buchstabe vorkommen soll
-	 * @return result : int : index des Buchstaben
-	 */
-	private int fetchArrayIndex(Character buchstabe, Character[] array) {
-		// wird mit ungueltigem Wert initialisiert
-		int result = -1;
-
-		for (int i = 0; i < array.length; i++) {
-			if (array[i].equals(buchstabe)) {
-				result = i;
-				break;
-			}
-		}
-
-		return result;
-	}
-
-	/**
-	 * Setzt die Walzennummer. Es stehen fuenf Walze zur Auswahl.
-	 *
-	 * @param walzennr : int : Walzennummer
-	 */
-	public void setWalzennr(int walzennr) {
-		if ((walzennr > 0) && (walzennr < 6)) {
-			this.walzennr = walzennr;
-		} else {
-			System.err.println("Keine gültige Walzennummer");
-		}
-	}
-
-	/**
-	 * TODO: Dokumentieren // das selbe wie getAnzeig?
-	 * Gibt den Character zurueck, der aktuell in der Walze eingestellt ist
-	 *
-	 * @return Character am Index 0 des (verschobenen) Alphabets zurueck
-	 */
-	public Character getPosition() {
-		return walzeAlpha[0];
-	}
-
-	/**
-	 * * TODO: Funktionsname hat sich geändert
-	 * Gibt die Grundeinstellung der Walze ein. Nur Buchstaben von A - Z sind zugelassen.
-	 * Buchstaben werden automatisch in Grossbuchstaben umgewandelt.
-	 * Ist die Grundeinstellung nicht 'A', wird die Methode dreheWalze() aufgerufen.
-	 *
-	 * @param buchstabe : Character : Einstellung der Walze
-	 */
-	public void setPosition(Character buchstabe) {
-		if (Character.isLetter(buchstabe)) {
-			buchstabe = Character.toUpperCase(buchstabe);
-			System.arraycopy(this.alphabet, 0, this.walzeAlpha, 0, this.alphabet.length);
-			if (buchstabe > 'A') {
-				dreheWalze(this.fetchArrayIndex(buchstabe, this.walzeAlpha));
-			}
-		}
-	}
-}
+    //region Variablen
+    /**
+     * Das String Array aller bekannter aktuellen Walzen
+     */
+    String[] walzen;
+
+    /**
+     * alphabet : String dass die Buchstaben des Alphabets enthaelt
+     */
+    private String alphabet;
+
+    /**
+     * ringstellung : char : zeigt die Einstellung fuer den Umspringpunkt
+     */
+    private char ringstellung;
+
+    /**
+     * walzennr : int : Bestimmt, welche Walze genutzt wird
+     */
+    private int walzenNr;
+
+    /**
+     * Die Anzahl der getätigten Walzen Drehungen
+     */
+    private int turns;
+    //endregion
+
+    //region Konstruktor
+    /**
+     * Ueberschriebener Konstruktor, der die Eingangsparameter der Walze mit gibt
+     *
+     * @param walzenNr     : int : Nummer der gewaehlten Walze
+     * @param ringstellung : int : Einstellung des Umsprungpunktes
+     */
+    public Walze(int walzenNr, int ringstellung) {
+
+        this.walzen = new String[5];
+        this.walzen[0] = "EKMFLGDQVZNTOWYHXUSPAIBRCJ";
+        this.walzen[1] = "AJDKSIRUXBLHWTMCQGZNPYFVOE";
+        this.walzen[2] = "BDFHJLCPRTXVZNYEIWGAKMUSQO";
+        this.walzen[3] = "ESOVPZJAYQUIRHXLNFTGKDCMWB";
+        this.walzen[4] = "VZBRGITYUPSDNHLXAWMJQOFECK";
+        this.alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        this.turns = 0;
+
+        this.setWalzenNr(walzenNr);
+        this.setRingstellung(ringstellung);
+    }
+    //endregion
+
+    //region Funktionen & Methoden
+    /**
+     * Dreht die Walze: Zählt die Umdrehungen (Turns) um eines hoch oder runter, je nach Drehrichtung.
+     * <p>
+     * Ueberprueft, ob der Umspringpunkt der Walze nach der Drehung erreicht wurde.
+     *
+     * @param richtung : int : 1 dreht die Walze weiter und -1 dreht sie einen Schritt zurück
+     * @return checkRing : boolean : gibt true zurueck wenn der Umspringpunkt erreicht wurde
+     * TODO: Doku
+     */
+    public boolean dreheWalze(int richtung) {
+
+        boolean checkRing = false;
+
+        if (richtung == -1 || richtung == 1) {
+            if (richtung == 1) {
+                this.turns++;
+            } else if (richtung == -1) {
+                this.turns--;
+            }
+
+            // gleicht die Ringstellung mit der aktuellen Position ab
+            if (this.getPosition() + richtung == this.ringstellung) {
+                checkRing = true;
+            }
+        }
+
+        return checkRing;
+    }
+
+    /**
+     * Codiert den mitgegebenen Buchstaben anhand der gewaehlten Walze.
+     *
+     * @param buchstabe : char : Buchstabe, der verschluesselt werden soll
+     * @return buchstabe : char : verschluesselter Buchstabe
+     */
+    public char codiere(char buchstabe) {
+        return this.fetchWalze().charAt((this.alphabet.indexOf(buchstabe) + this.turns) % 26);
+    }
+
+    /**
+     * Decodiert den mitgegebenen Buchstaben mit Hilfe der (verschobenen) Walze
+     *
+     * @param buchstabe : char : Buchstabe, der decodiert werden soll
+     * @return buchstabe : char : decodierter Buchstabe
+     */
+    public char codiere2(char buchstabe) {
+
+        int zwischensumme = this.fetchWalze().indexOf(buchstabe) - this.turns;
+        if (zwischensumme < 0) {
+            zwischensumme = this.fetchWalze().indexOf(buchstabe) - this.turns + 26;
+        }
+        return this.alphabet.charAt(zwischensumme % 26);
+    }
+
+    /**
+     * Holt den korrekten String zu der Walze
+     *
+     * @return walze : Character[] : gibt die gewaehlte Walze zurueck
+     */
+    public String fetchWalze() {
+
+        return walzen[walzenNr];
+    }
+    //endregion
+
+    //region Setter
+    /**
+     * * TODO: Funktionsname hat sich geändert
+     * Gibt die Grundeinstellung der Walze ein. Nur Buchstaben von A - Z sind zugelassen.
+     * Buchstaben werden automatisch in Grossbuchstaben umgewandelt.
+     * Ist die Grundeinstellung nicht 'A', wird die Methode dreheWalze() aufgerufen.
+     *
+     * @param buchstabe : Character : Einstellung der Walze
+     */
+    public void setPosition(Character buchstabe) {
+        this.turns = alphabet.indexOf(buchstabe);
+    }
+
+    /**
+     * Setzt die Walzennummer. Es stehen fuenf Walze zur Auswahl.
+     *
+     * @param walzenNr : int : Walzennummer
+     */
+    public void setWalzenNr(int walzenNr) {
+        if ((walzenNr > 0) && (walzenNr < 6)) {
+            this.walzenNr = walzenNr - 1;
+        } else {
+            System.err.println("Keine gültige Walzennummer");
+        }
+    }
+
+    /**
+     * Setzt die Initiale Ringstellung der Walze.
+     * Es sind nur Zahlen von 1 - 26 zugelassen.
+     * <p>
+     * Die Ringstellung wird zum char umgewandelt.
+     * Im Fehlerfall wird die Ringstellung standardmaessig auf 'Z' gesetzt.
+     *
+     * @param ringstellung : int : Punkt an dem die Walze umspringt
+     */
+    public void setRingstellung(int ringstellung) {
+        if ((ringstellung > 0) && (ringstellung <= 26)) {
+            this.ringstellung = this.alphabet.charAt(ringstellung - 1);
+        } else {
+            this.ringstellung = 'Z';
+        }
+    }
+    //endregion
+
+    //region Getter
+    /**
+     * Gibt den Character zurueck, der aktuell in der Walze eingestellt ist
+     *
+     * @return Character am Index 0 des (verschobenen) Alphabets zurueck
+     */
+    public Character getPosition() {
+        return this.alphabet.charAt(turns % 26);
+    }
+    //endregion
+}
\ No newline at end of file
diff --git a/src/test/java/projekt/enigma/model/HardwareTest.java b/src/test/java/projekt/enigma/model/HardwareTest.java
index 8c1fc82e3ffb96e35caf063154630e06a8a434b8..d0be7f035f829af0eb6defdb7356440510017587 100644
--- a/src/test/java/projekt/enigma/model/HardwareTest.java
+++ b/src/test/java/projekt/enigma/model/HardwareTest.java
@@ -17,48 +17,53 @@ public class HardwareTest {
 
 		/*
         Walze nach der Chiffrierung
-        Alphabet    {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
-        Steckbrett  {'B', 'G', 'D', 'F'}
-        Steckbrett  {'G', 'B', 'F', 'F'}
-    Walze 3    {'B', 'D', 'F', 'H', 'J', 'L', 'C', 'P', 'R', 'T', 'X', 'V', 'Z', 'N', 'Y', 'E', 'I', 'W', 'G', 'A', 'K', 'M', 'U', 'S', 'Q', 'O'};
-		Walze 2     {'A', 'J', 'D', 'K', 'S', 'I', 'R', 'U', 'X', 'B', 'L', 'H', 'W', 'T', 'M', 'C', 'Q', 'G', 'Z', 'N', 'P', 'Y', 'F', 'V', 'O', 'E'};
-		Walze 1     {'E', 'K', 'M', 'F', 'L', 'G', 'D', 'Q', 'V', 'Z', 'N', 'T', 'O', 'W', 'Y', 'H', 'X', 'U', 'S', 'P', 'A', 'I', 'B', 'R', 'C', 'J'};
-        Reflektor   {'E', 'J', 'M', 'Z', 'A', 'L', 'Y', 'X', 'V', 'B', 'W', 'F', 'C', 'R', 'Q', 'U', 'O', 'N', 'T', 'S', 'P', 'I', 'K', 'H', 'G', 'D'};
+        Alphabet    "A B C D E F G H I J K L M N O P Q R S T U V W X Y Z"
+        Steckbrett  "W S L V H Y G I X A"
+        Steckbrett  "J E F B K P M Q U C"
+
+		Walze 3     "E K M F L G D Q V Z N T O W Y H X U S P A I B R C J"
+        Walze 2     "V Z B R G I T Y U P S D N H L X A W M J Q O F E C K"
+        Walze 1   	"A J D K S I R U X B L H W T M C Q G Z N P Y F V O E"
+        Reflektor   "E J M Z A L Y X V B W F C R Q U O N T S P I K H G D"
 		*/
 
 		char result;
 		h.resetWalzen();
 		result = h.codiere('A');
-		Assert.assertEquals("Codiere: A Erwartet G, erhalten " + result, 'G', result);
+		Assert.assertEquals("Codiere: A Erwartet P, erhalten " + result, 'P', result);
 		result = h.codiere('B');
-		Assert.assertEquals("Codiere: B Erwartet H, erhalten " + result, 'H', result);
+		Assert.assertEquals("Codiere: B Erwartet R, erhalten " + result, 'R', result);
 		result = h.codiere('I');
-		Assert.assertEquals("Codiere: I Erwartet C, erhalten " + result, 'C', result);
+		Assert.assertEquals("Codiere: I Erwartet E, erhalten " + result, 'E', result);
 		result = h.codiere('F');
-		Assert.assertEquals("Codiere: F Erwartet U, erhalten " + result, 'U', result);
+		Assert.assertEquals("Codiere: F Erwartet A, erhalten " + result, 'A', result);
 
 		h.resetWalzen();
-		result = h.codiere('G');
-		Assert.assertEquals("Decodiere: G Erwartet A, erhalten " + result, 'A', result);
-		result = h.codiere('H');
-		Assert.assertEquals("Decodiere: R Erwartet H, erhalten " + result, 'B', result);
-		result = h.codiere('C');
-		Assert.assertEquals("Decodiere: C Erwartet I, erhalten " + result, 'I', result);
-		result = h.codiere('U');
-		Assert.assertEquals("Decodiere: U Erwartet F, erhalten " + result, 'F', result);
+		result = h.codiere('P');
+		Assert.assertEquals("Decodiere: P Erwartet A, erhalten " + result, 'A', result);
+		result = h.codiere('R');
+		Assert.assertEquals("Decodiere: R Erwartet B, erhalten " + result, 'B', result);
+		result = h.codiere('E');
+		Assert.assertEquals("Decodiere: E Erwartet I, erhalten " + result, 'I', result);
+		result = h.codiere('A');
+		Assert.assertEquals("Decodiere: A Erwartet F, erhalten " + result, 'F', result);
 
 		h.resetWalzen();
 		h.getSteckbrett().setzeVertauschung('B', 'G');
 		h.getSteckbrett().setzeVertauschung('D', 'F');
 		h.getSteckbrett().setzeVertauschung('I', 'L');
 		h.getSteckbrett().setzeVertauschung('M', 'Q');
-		h.getSteckbrett().setzeVertauschung('T', 'X');
+		h.getSteckbrett().setzeVertauschung('N', 'X');
+		h.getSteckbrett().setzeVertauschung('K', 'Y');
+		h.getSteckbrett().setzeVertauschung('U', 'Z');
+		h.getSteckbrett().setzeVertauschung('A', 'O');
+		h.getSteckbrett().setzeVertauschung('E', 'S');
 
 		result = h.codiere('I');
-		Assert.assertEquals("Codiere: I Erwartet F, erhalten " + result, 'F', result);
+		Assert.assertEquals("Codiere: I Erwartet F, erhalten " + result, 'D', result);
 
 		h.resetWalzen();
-		result = h.codiere('K');
-		Assert.assertEquals("Codiere: K Erwartet D, erhalten " + result, 'D', result);
+		result = h.codiere('D');
+		Assert.assertEquals("Codiere: D Erwartet I, erhalten " + result, 'I', result);
 	}
 }
\ No newline at end of file
diff --git a/src/test/java/projekt/enigma/model/WalzeTest.java b/src/test/java/projekt/enigma/model/WalzeTest.java
index a53f3832b36f9bffa8fba90d0c7919be12ddb09d..ce8cdbc4fd5a5c59769e260244e149001d410def 100644
--- a/src/test/java/projekt/enigma/model/WalzeTest.java
+++ b/src/test/java/projekt/enigma/model/WalzeTest.java
@@ -16,7 +16,7 @@ public class WalzeTest {
 
 	@Test
 	public void dreheWalze() {
-		Walze w = new Walze(1, 3);
+		Walze w = new Walze(1, 4);
 		assertFalse("false erwartet, true geliefert", w.dreheWalze(1));
 		char temp = w.getPosition();
 		Assert.assertEquals("B erwartet, " + temp + " zurück gegeben", 'B', temp);