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/README.md b/README.md
index 163ab611cc322893c21892be580514f5eeba300a..cbe467a3db48b637919ac74ff829920264d130ee 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,19 @@
 [![pipeline status](https://www.gitrepo.de/alfatrainingkurse/java/enigma/badges/master/pipeline.svg)](https://www.gitrepo.de/alfatrainingkurse/java/enigma/commits/master)
-[![coverage report](https://www.gitrepo.de/alfatrainingkurse/java/enigma/badges/master/coverage.svg)](https://www.gitrepo.de/alfatrainingkurse/java/enigma/commits/master)
 
-Link zum [Wiki](https://www.gitrepo.de/alfatrainingkurse/java/enigma/wikis/home)
\ No newline at end of file
+### Eine Enigma Simulation in Java
+
+Dieses Projekt ist unsere Abschlußprüfung zur Java Fortbildung und deshalb in der Entwicklung nicht so weit fortgeschritten.\
+Wir haben jedoch trotzdem versucht, die Enigma möglichst original getreu nach zu bauen und versucht an die Regeln,\
+aus der damaligen Zeit zu halten.
+
+Falls ihr Spaß habt daran etwas weiter zu entwickeln, sind Merge-Requests herzlich willkommen.\
+\
+Ebenfalls eingebaut haben wir einen Funkraum. Heißt das man Nachrichten, per Morsecode, an einen externen Server senden kann\
+und auch wieder abholen kann.\
+Bitte beachtet das diese Nachrichten jeder lesen kann, wenn ihr die Standard Einstellungen aus dem Codebuch und die selbe Kenngruppe nutzt.\
+Das Codebuch ist fest, in einer sqlite Datei, im Resources Ordner, hinterlegt.\
+\
+Ebenfalls wichtig ist eure Kenngruppe. Dies hat früher den Personenkreis bezeichnet, welcher diese Nachrichten lesen durfte.\
+Wenn ihr also auf mehreren Clients die selbe Kenngruppe nutzt, dann könnt ihr untereinander eure Nachrichten lesen.\
+\
+Im [Wiki](https://www.gitrepo.de/alfatrainingkurse/java/enigma/wikis/home) findet ihr auch noch einige Informationen zu dem Projekt.
diff --git a/src/main/java/projekt/enigma/GuiController.java b/src/main/java/projekt/enigma/GuiController.java
index 2e06eb606adf45ee66b00bde2d46fae7ef84a6b4..3fa825e7a815dfe33bea548ab772e9da533466b1 100644
--- a/src/main/java/projekt/enigma/GuiController.java
+++ b/src/main/java/projekt/enigma/GuiController.java
@@ -1,657 +1,451 @@
 package projekt.enigma;
 
-import projekt.enigma.model.Codierer;
 import javafx.event.ActionEvent;
 import javafx.fxml.FXML;
 import javafx.scene.control.*;
 import javafx.scene.shape.Circle;
 import org.apache.http.HttpException;
+import projekt.enigma.model.Codierer;
 
 import java.io.IOException;
 import java.util.ArrayList;
 
 public class GuiController {
 
-	private final static String[] walzenNr = {"I", "II", "III", "IV", "V"};
-	private final static String[] ringNr = {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26"};
-	private final static String[] position = {"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"};
-	private ArrayList<MenuItem> mItem;
-	private String textEingabe;
-	private String textCodiert;
-	private boolean resetDisplay;
-	private Codierer codierer;
-
-	@FXML
-	private TextField tfStecker1;
-
-	@FXML
-	private TextField tfStecker2;
-
-	@FXML
-	private TextField tfStecker3;
-
-	@FXML
-	private TextField tfStecker4;
-
-	@FXML
-	private TextField tfStecker5;
-
-	@FXML
-	private TextField tfStecker6;
-
-	@FXML
-	private TextField tfStecker7;
-
-	@FXML
-	private TextField tfStecker8;
-
-	@FXML
-	private TextField tfStecker9;
-
-	@FXML
-	private TextField tfStecker10;
-
-	@FXML
-	private Button btnM;
-
-	@FXML
-	private Button btnN;
-
-	@FXML
-	private Button btnB;
-
-	@FXML
-	private Button btnV;
-
-	@FXML
-	private Button btnC;
-
-	@FXML
-	private Button btnX;
-
-	@FXML
-	private Button btnY;
-
-	@FXML
-	private Button btnP;
-
-	@FXML
-	private Button btnL;
-
-	@FXML
-	private Button btnK;
-
-	@FXML
-	private Button btnJ;
-
-	@FXML
-	private Button btnH;
-
-	@FXML
-	private Button btnG;
-
-	@FXML
-	private Button btnF;
-
-	@FXML
-	private Button btnD;
-
-	@FXML
-	private Button btnS;
-
-	@FXML
-	private Button btnA;
-
-	@FXML
-	private Button btnO;
-
-	@FXML
-	private Button btnI;
-
-	@FXML
-	private Button btnU;
-
-	@FXML
-	private Button btnZ;
-
-	@FXML
-	private Button btnT;
-
-	@FXML
-	private Button btnR;
-
-	@FXML
-	private Button btnE;
-
-	@FXML
-	private Button btnW;
-
-	@FXML
-	private Button btnQ;
-
-	@FXML
-	private Circle circL;
-
-	@FXML
-	private Circle circM;
-
-	@FXML
-	private Circle circN;
-
-	@FXML
-	private Circle circB;
-
-	@FXML
-	private Circle circV;
-
-	@FXML
-	private Circle circC;
-
-	@FXML
-	private Circle circX;
-
-	@FXML
-	private Circle circY;
-
-	@FXML
-	private Circle circP;
-
-	@FXML
-	private Circle circK;
-
-	@FXML
-	private Circle circJ;
-
-	@FXML
-	private Circle circH;
-
-	@FXML
-	private Circle circG;
-
-	@FXML
-	private Circle circF;
-
-	@FXML
-	private Circle circD;
-
-	@FXML
-	private Circle circS;
-
-	@FXML
-	private Circle circA;
-
-	@FXML
-	private Circle circO;
-
-	@FXML
-	private Circle circI;
-
-	@FXML
-	private Circle circU;
-
-	@FXML
-	private Circle circZ;
-
-	@FXML
-	private Circle circT;
-
-	@FXML
-	private Circle circR;
-
-	@FXML
-	private Circle circE;
-
-	@FXML
-	private Circle circW;
-
-	@FXML
-	private Circle circQ;
-
-	@FXML
-	private Label lblL;
-
-	@FXML
-	private Label lblM;
-
-	@FXML
-	private Label lblN;
-
-	@FXML
-	private Label lblB;
-
-	@FXML
-	private Label lblV;
-
-	@FXML
-	private Label lblC;
-
-	@FXML
-	private Label lblX;
-
-	@FXML
-	private Label lblY;
-
-	@FXML
-	private Label lblP;
-
-	@FXML
-	private Label lblK;
-
-	@FXML
-	private Label lblJ;
-
-	@FXML
-	private Label lblH;
-
-	@FXML
-	private Label lblG;
-
-	@FXML
-	private Label lblF;
-
-	@FXML
-	private Label lblD;
-
-	@FXML
-	private Label lblS;
-
-	@FXML
-	private Label lblA;
-
-	@FXML
-	private Label lblQ;
-
-	@FXML
-	private Label lblW;
-
-	@FXML
-	private Label lblE;
-
-	@FXML
-	private Label lblR;
-
-	@FXML
-	private Label lblT;
-
-	@FXML
-	private Label lblZ;
-
-	@FXML
-	private Label lblU;
-
-	@FXML
-	private Label lblI;
-
-	@FXML
-	private Label lblO;
-
-	@FXML
-	private TextField tfCodiert;
-
-	@FXML
-	private TextField tfKlartext;
-
-	@FXML
-	private ProgressBar pbLadeNachricht;
-
-	@FXML
-	private MenuButton mBtnWalzPos1;
-
-	@FXML
-	private MenuButton mBtnWalzPos2;
-
-	@FXML
-	private MenuButton mBtnWalzPos3;
-
-	@FXML
-	private MenuButton mBtnNotchPos1;
-
-	@FXML
-	private MenuButton mBtnNotchPos2;
-
-	@FXML
-	private MenuButton mBtnNotchPos3;
-
-	@FXML
-	private MenuButton mBtnStartPos1;
-
-	@FXML
-	private MenuButton mBtnStartPos2;
-
-	@FXML
-	private MenuButton mBtnStartPos3;
-
-	@FXML
-	private Label lblLadeNachricht;
-
-	@FXML
-	void initialize() {
-
-		// Variablen setzen
-		textEingabe = "";
-		textCodiert = "";
-		resetDisplay = true;
-
-		//Einträge für Walzen
-		menu(mBtnWalzPos1, walzenNr);
-		menu(mBtnWalzPos2, walzenNr);
-		menu(mBtnWalzPos3, walzenNr);
-
-		//Einträge für die Ringe
-		menu(mBtnNotchPos1, ringNr);
-		menu(mBtnNotchPos2, ringNr);
-		menu(mBtnNotchPos3, ringNr);
-
-		//Einträge für die Startpositionen
-		menu(mBtnStartPos1, position);
-		menu(mBtnStartPos3, position);
-		menu(mBtnStartPos2, position);
-
-
-		//Setze Leucht Event bei Tastendruck
-		leuchten(btnA, circA);
-		leuchten(btnB, circB);
-		leuchten(btnC, circC);
-		leuchten(btnD, circD);
-		leuchten(btnE, circE);
-		leuchten(btnF, circF);
-		leuchten(btnG, circG);
-		leuchten(btnH, circH);
-		leuchten(btnI, circI);
-		leuchten(btnJ, circJ);
-		leuchten(btnK, circK);
-		leuchten(btnL, circL);
-		leuchten(btnM, circM);
-		leuchten(btnN, circN);
-		leuchten(btnO, circO);
-		leuchten(btnP, circP);
-		leuchten(btnQ, circQ);
-		leuchten(btnR, circR);
-		leuchten(btnS, circS);
-		leuchten(btnT, circT);
-		leuchten(btnU, circU);
-		leuchten(btnV, circV);
-		leuchten(btnW, circW);
-		leuchten(btnX, circX);
-		leuchten(btnY, circY);
-		leuchten(btnZ, circZ);
-
-		this.codierer = new Codierer();
-		this.codierer.setKenngruppe("enigma");
-
-		// Walzen auf ihre Position setzen. Der Spruchschlüssel ist hier bereits berücksichtigt.
-		mBtnStartPos1.setText(String.valueOf(this.codierer.getWalzen()[0]));
-		mBtnStartPos2.setText(String.valueOf(this.codierer.getWalzen()[1]));
-		mBtnStartPos3.setText(String.valueOf(this.codierer.getWalzen()[2]));
-	}
-
-	@FXML
-	private void loeschen() {
-		if (textEingabe.length()==0){
-			tfKlartext.setText("");
-		}else {
-			textEingabe = textEingabe.substring(0, textEingabe.length() - 1);
-			tfKlartext.setText(textEingabe);
-		}
-	}
-
-	@FXML
-	void btnempfangen() {
-		String[] empfangeneNachricht = this.codierer.empfangeNachricht();
-		if (empfangeneNachricht[0] != null) {
-			this.tfKlartext.setText(empfangeneNachricht[2]);
-			this.tfCodiert.setText(empfangeneNachricht[1]);
-			this.resetDisplay = true;
-
-			mBtnStartPos1.setText(String.valueOf(this.codierer.getWalzen()[0]));
-			mBtnStartPos2.setText(String.valueOf(this.codierer.getWalzen()[1]));
-			mBtnStartPos3.setText(String.valueOf(this.codierer.getWalzen()[2]));
-		}
-	}
-
-	@FXML
-	void btnsenden() {
-		this.tfKlartext.setText("");
-		this.tfCodiert.setText("");
-
-		try {
-			this.codierer.sendeNachricht();
-		} catch (HttpException | IOException e) {
-			e.printStackTrace();
-		}
-
-	}
-
-	/**
-	 * Methode zum setzen des menuButton Textes auf das ausgewählte MenuItem
-	 *
-	 * @param mb : MenuButton der Walze
-	 * @param mi : MenuItem
-	 */
-	private void listener(MenuButton mb, MenuItem mi) {
-		// mb.setText(mi.getText());
-
-		if(mb.getId().equals(mBtnStartPos1.getId()))setzePosition(1,mi.getText().charAt(0));
-		if(mb.getId().equals(mBtnStartPos2.getId()))setzePosition(2,mi.getText().charAt(0));
-		if(mb.getId().equals(mBtnStartPos3.getId()))setzePosition(3,mi.getText().charAt(0));
-		if(mb.getId().equals(mBtnWalzPos1.getId()))setzeWalze(1,mi.getText());
-		if(mb.getId().equals(mBtnWalzPos2.getId()))setzeWalze(2,mi.getText());
-		if(mb.getId().equals(mBtnWalzPos3.getId()))setzeWalze(3,mi.getText());
-		if(mb.getId().equals(mBtnNotchPos1.getId()))
-			setzeRing(1,Integer.parseInt(mi.getText())-1);
-		if(mb.getId().equals(mBtnNotchPos2.getId()))
-			setzeRing(2,Integer.parseInt(mi.getText())-1);
-		if(mb.getId().equals(mBtnNotchPos3.getId()))
-			setzeRing(3,Integer.parseInt(mi.getText())-1);
-	}
-
-	/**
-	 * Methode zur Erstellung der Einträge und Action Listener für die einzelnen Menüs
-	 *
-	 * @param button : Button für die die Einträge erstellt werden sollen
-	 */
-	private void menu(MenuButton button, String[] str) {
-		mItem = new ArrayList<>();
-		for (int i = 0; i < str.length; i++) {
-			//Eintrag aus str der Arraylist mi hinzufügen
-			mItem.add(new MenuItem(str[i]));
-			//MenuItem mi dem Button button hinzufügen
-			button.getItems().add(mItem.get(i));
-			int finalI = i;
-			//Listener für die einzelnen Einträge
-			ArrayList<MenuItem> finalMi = mItem;
-			mItem.get(i).setOnAction(e -> listener(button, finalMi.get(finalI)));
-		}
-	}
-
-	/**
-	 * Auswertung welcher Button gedrückt wurde
-	 *
-	 * @param e => ActionEvent des auslösenden Button
-	 */
-	@FXML
-	private void gedrueckteTaste(ActionEvent e) {
-
-		//TODO Anbindung an Klasse Hardware
-		if (e.getSource() == btnA) setText(btnA);
-		if (e.getSource() == btnB) setText(btnB);
-		if (e.getSource() == btnC) setText(btnC);
-		if (e.getSource() == btnD) setText(btnD);
-		if (e.getSource() == btnE) setText(btnE);
-		if (e.getSource() == btnF) setText(btnF);
-		if (e.getSource() == btnG) setText(btnG);
-		if (e.getSource() == btnH) setText(btnH);
-		if (e.getSource() == btnI) setText(btnI);
-		if (e.getSource() == btnJ) setText(btnJ);
-		if (e.getSource() == btnK) setText(btnK);
-		if (e.getSource() == btnL) setText(btnL);
-		if (e.getSource() == btnM) setText(btnM);
-		if (e.getSource() == btnN) setText(btnN);
-		if (e.getSource() == btnO) setText(btnO);
-		if (e.getSource() == btnP) setText(btnP);
-		if (e.getSource() == btnQ) setText(btnQ);
-		if (e.getSource() == btnR) setText(btnR);
-		if (e.getSource() == btnS) setText(btnS);
-		if (e.getSource() == btnT) setText(btnT);
-		if (e.getSource() == btnU) setText(btnU);
-		if (e.getSource() == btnV) setText(btnV);
-		if (e.getSource() == btnW) setText(btnW);
-		if (e.getSource() == btnX) setText(btnX);
-		if (e.getSource() == btnY) setText(btnY);
-		if (e.getSource() == btnZ) setText(btnZ);
-	}
-
-	/**
-	 * schreibt Buchstaben des gedrückten Knopfes in Textfeld tfrein
-	 *
-	 * @param b : gedrückter Knopf
-	 */
-	private void setText(Button b) {
-		if (textEingabe.length() < 250) {
-			if(this.resetDisplay) {
-				this.tfCodiert.setText("");
-				this.tfKlartext.setText("");
-				this.resetDisplay = false;
-				this.codierer.resetHardware();
-				textCodiert = "";
-				textEingabe = "";
-				// Spruchschlüssel generieren und codieren
-				this.codierer.generateSpruchschluessel();
-			}
-			textEingabe += b.getText();
-			textCodiert += this.codierer.codiere(b.getText().charAt(0), true);
-
-			tfKlartext.setText(textEingabe);
-			tfCodiert.setText(textCodiert);
-
-			mBtnStartPos1.setText(String.valueOf(this.codierer.getWalzen()[0]));
-			mBtnStartPos2.setText(String.valueOf(this.codierer.getWalzen()[1]));
-			mBtnStartPos3.setText(String.valueOf(this.codierer.getWalzen()[2]));
-		}
-	}
-
-	private void leuchten(Button taste, Circle leuchte) {
-
-		taste.setOnMousePressed(mouseEvent -> leuchte.setStyle("-fx-fill: #FFA500"));
-		taste.setOnMouseReleased(mouseEvent -> {
-			leuchte.setStyle("-fx-background-color: " + taste.getBackground());
-			leuchte.setStyle("-fx-border-color:  #000000");
-		});
-	}
-
-	/**
-	 * Setzt die Anzeige des entsprechende Gui-Element auf die entsprechende Walze
-	 * ->d.h. welche Walze sitzt auf welcher Position
-	 *
-	 * @param walzeRoemischNr    => gibt die Walzennummer an
-	 * @param walzenPosition => gibt die Position der Walze
-	 */
-	private void setzeWalze(int walzenPosition, String walzeRoemischNr) {
-		int walzeNr=0;
-		switch (walzeRoemischNr){
-			case "I":
-				walzeNr=0;
-				break;
-			case "II":
-				walzeNr=1;
-				break;
-			case "III":
-				walzeNr=2;
-				break;
-			case "IV":
-				walzeNr=4;
-				break;
-			case "V":
-				walzeNr=4;
-				break;
-			default:
-				break;
-		}
-
-		switch (walzenPosition) {
-			case 1:
-				mBtnWalzPos1.setText(walzenNr[walzeNr]);
-				//codierer.setWalze(walzeNr, walzenPosition)
-				break;
-			case 2:
-				mBtnWalzPos2.setText(walzenNr[walzeNr]);
-
-				break;
-			case 3:
-				mBtnWalzPos3.setText(walzenNr[walzeNr]);
-				break;
-			default:
-				break;
-		}
-	}
-
-	/**
-	 * Setzt den Notch (position)=> die Mitnahmeposition der Walze (walze) fest
-	 * Mitnahmeposition meint => die nächste Walze wird bei erreichen dieser Position (notch)
-	 * um eine Stelle versetzt
-	 *
-	 * @param ringStellung    => gibt die walze an
-	 * @param walzenPosition => gibt den notch der Walze (walze) an
-	 */
-	private void setzeRing(int walzenPosition, int ringStellung) {
-		switch (walzenPosition) {
-			case 1:
-				mBtnNotchPos1.setText(ringNr[ringStellung]);
-				break;
-			case 2:
-				mBtnNotchPos2.setText(ringNr[ringStellung]);
-				break;
-			case 3:
-				mBtnNotchPos3.setText(ringNr[ringStellung]);
-				break;
-			default:
-				break;
-		}
-	}
-
-	/**
-	 * Setzt die Startposition/ aktuelle Position der Walze
-	 *
-	 * @param walze     => gibt die walze an
-	 * @param buchstabe gibt den Startwert bzw die aktuelle Position der Walze (walze) an
-	 */
-	private void setzePosition(int walze, char buchstabe) {
-		switch (walze) {
-			case 1:
-				mBtnStartPos1.setText(String.valueOf(buchstabe));
-				break;
-			case 2:
-				mBtnStartPos2.setText(buchstabe + "");
-				break;
-			case 3:
-				mBtnStartPos3.setText(buchstabe + "");
-				break;
-			default:
-				break;
-		}
-	}
-
-	/**
-	 * Setzt den aktuellen TagesSchluessel
-	 *
-	 * @param tagesSchluessel => neuen Tagesschluessel übergeben
-	 */
-	public void setzeTagesSchluessel(String tagesSchluessel) {
-		/*
-		 * TODO Benötige TestString aus der DB Codebuch
-		 *
-		 * Den Tagesschlüssel bekommst du wie folgt:
-		 * <p>
-		 *     // Aktuelle Position der Walzen
-		 *     codierer.codebuch.getWalzenlage();
-		 *
-		 *     // Position der Ringe
-		 *     codierer.codebuch.getRingstellung();
-		 *
-		 *     //Position der Steckverbindungen
-		 *     codierer.codebuch.getSteckverbindung();
-		 * </p>
-		 */
-
-	}
+    //region Klassenvariablen
+    private final static String[] walzenNr = {"I", "II", "III", "IV", "V"};
+    private final static String[] ringNr = {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26"};
+    private final static String[] position = {"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"};
+    private ArrayList<MenuItem> mItem;
+    private String textEingabe;
+    private String textCodiert;
+    private boolean resetDisplay;
+    private Codierer codierer;
+//endregion
+
+    //region GUI-Elemente
+    @FXML
+    private TextField tfStecker1, tfStecker2, tfStecker3, tfStecker4, tfStecker5, tfStecker6, tfStecker7, tfStecker8,
+            tfStecker9, tfStecker10, tfCodiert, tfKlartext;
+
+    @FXML
+    private Button btnA, btnB, btnC, btnD, btnE, btnF, btnG, btnH, btnI, btnJ, btnK, btnL, btnM, btnN, btnO, btnP, btnQ,
+            btnR, btnS, btnT, btnU, btnV, btnW, btnX, btnY, btnZ, btnSenden, btnEmpfangen, btnDelete;
+
+    @FXML
+    private Circle circA, circB, circC, circD, circE, circF, circG, circH, circI, circJ, circK, circL, circM, circN,
+            circO, circP, circQ, circR, circS, circT, circU, circV, circW, circX, circY, circZ;
+
+    @FXML
+    private Label lblA, lblB, lblC, lblD, lblE, lblF, lblG, lblH, lblI, lblJ, lblK, lblL, lblM, lblN, lblO, lblP, lblQ,
+            lblR, lblS, lblT, lblU, lblV, lblW, lblX, lblY, lblZ, lblLadeNachricht, lblTagesschluessel,
+            lblSpruchschluessel;
+
+    @FXML
+    private ProgressBar pbLadeNachricht;
+
+    @FXML
+    private MenuButton mBtnWalzPos1, mBtnWalzPos2, mBtnWalzPos3, mBtnNotchPos1, mBtnNotchPos2, mBtnNotchPos3,
+            mBtnStartPos1, mBtnStartPos2, mBtnStartPos3;
+//endregion
+
+    //region Init
+    @FXML
+    void initialize() {
+
+        // Variablen setzen
+        textEingabe = "";
+        textCodiert = "";
+        resetDisplay = true;
+
+        //Einträge für Walzen
+        menu(mBtnWalzPos1, walzenNr);
+        menu(mBtnWalzPos2, walzenNr);
+        menu(mBtnWalzPos3, walzenNr);
+
+        //Einträge für die Ringe
+        menu(mBtnNotchPos1, ringNr);
+        menu(mBtnNotchPos2, ringNr);
+        menu(mBtnNotchPos3, ringNr);
+
+        //Einträge für die Startpositionen
+        menu(mBtnStartPos1, position);
+        menu(mBtnStartPos3, position);
+        menu(mBtnStartPos2, position);
+
+        //Setze Leucht Event bei Tastendruck
+        leuchten(btnA, circA);
+        leuchten(btnB, circB);
+        leuchten(btnC, circC);
+        leuchten(btnD, circD);
+        leuchten(btnE, circE);
+        leuchten(btnF, circF);
+        leuchten(btnG, circG);
+        leuchten(btnH, circH);
+        leuchten(btnI, circI);
+        leuchten(btnJ, circJ);
+        leuchten(btnK, circK);
+        leuchten(btnL, circL);
+        leuchten(btnM, circM);
+        leuchten(btnN, circN);
+        leuchten(btnO, circO);
+        leuchten(btnP, circP);
+        leuchten(btnQ, circQ);
+        leuchten(btnR, circR);
+        leuchten(btnS, circS);
+        leuchten(btnT, circT);
+        leuchten(btnU, circU);
+        leuchten(btnV, circV);
+        leuchten(btnW, circW);
+        leuchten(btnX, circX);
+        leuchten(btnY, circY);
+        leuchten(btnZ, circZ);
+
+        // Initialisieren des Codierers und setzen der Kenngruppe
+        this.codierer = new Codierer();
+        this.codierer.setKenngruppe("enigma");
+
+        // Beim nächsten Tastendruck erstmal das Display löschen damit falschen Nachrichten geschickt werden.
+        this.resetDisplay = true;
+
+        // Einstellungen aus dem Logbuch auslesen und setzen
+        this.setzeTagesSchluessel();
+        this.setzeSteckverbindungen();
+    }
+
+    /**
+     * init Methode zur Erstellung der Einträge und Action Listener für die einzelnen Menüs
+     *
+     * @param button : Button für die die Einträge erstellt werden sollen
+     */
+    private void menu(MenuButton button, String[] str) {
+        mItem = new ArrayList<>();
+        for (int i = 0; i < str.length; i++) {
+            //Eintrag aus str der Arraylist mi hinzufügen
+            mItem.add(new MenuItem(str[i]));
+            //MenuItem mi dem Button button hinzufügen
+            button.getItems().add(mItem.get(i));
+            int finalI = i;
+            //Listener für die einzelnen Einträge
+            ArrayList<MenuItem> finalMi = mItem;
+            mItem.get(i).setOnAction(e -> setMenuBtnText(button, finalMi.get(finalI)));
+        }
+    }
+//endregion
+
+    //region EventHandler/Listener
+
+    /**
+     * //TODO DOKU
+     */
+    private void leuchten(Button taste, Circle leuchte) {
+
+        taste.setOnMousePressed(mouseEvent -> leuchte.setStyle("-fx-fill: #FFA500"));
+        taste.setOnMouseReleased(mouseEvent -> {
+            leuchte.setStyle("-fx-background-color: " + taste.getBackground());
+            leuchte.setStyle("-fx-border-color:  #000000");
+        });
+    }
+
+    /**
+     * Auswertung welcher Button gedrückt wurde
+     *
+     * @param e => ActionEvent des auslösenden Button
+     */
+    @FXML
+    private void gedrueckteTaste(ActionEvent e) {
+
+        //TODO Anbindung an Klasse Hardware
+        if (e.getSource() == btnA) {
+            setText(btnA);
+            //leuchten();
+        }
+        if (e.getSource() == btnB) setText(btnB);
+        if (e.getSource() == btnC) setText(btnC);
+        if (e.getSource() == btnD) setText(btnD);
+        if (e.getSource() == btnE) setText(btnE);
+        if (e.getSource() == btnF) setText(btnF);
+        if (e.getSource() == btnG) setText(btnG);
+        if (e.getSource() == btnH) setText(btnH);
+        if (e.getSource() == btnI) setText(btnI);
+        if (e.getSource() == btnJ) setText(btnJ);
+        if (e.getSource() == btnK) setText(btnK);
+        if (e.getSource() == btnL) setText(btnL);
+        if (e.getSource() == btnM) setText(btnM);
+        if (e.getSource() == btnN) setText(btnN);
+        if (e.getSource() == btnO) setText(btnO);
+        if (e.getSource() == btnP) setText(btnP);
+        if (e.getSource() == btnQ) setText(btnQ);
+        if (e.getSource() == btnR) setText(btnR);
+        if (e.getSource() == btnS) setText(btnS);
+        if (e.getSource() == btnT) setText(btnT);
+        if (e.getSource() == btnU) setText(btnU);
+        if (e.getSource() == btnV) setText(btnV);
+        if (e.getSource() == btnW) setText(btnW);
+        if (e.getSource() == btnX) setText(btnX);
+        if (e.getSource() == btnY) setText(btnY);
+        if (e.getSource() == btnZ) setText(btnZ);
+        if (e.getSource() == btnSenden) sendeFunkspruch();
+        if (e.getSource() == btnEmpfangen) empfangeFunkspruch();
+        if (e.getSource() == btnDelete) loeschen();
+    }
+//endregion
+
+    //region Methoden
+
+    /**
+     * Methode zum setzen des menuButton Textes auf das ausgewählte MenuItem
+     *
+     * @param mBtn : MenuButton der Walze
+     * @param mItm : MenuItem
+     */
+    private void setMenuBtnText(MenuButton mBtn, MenuItem mItm) {
+        // mb.setText(mi.getText());
+
+        if (mBtn.getId().equals(mBtnStartPos1.getId())) setzePosition(1, mItm.getText().charAt(0));
+        if (mBtn.getId().equals(mBtnStartPos2.getId())) setzePosition(2, mItm.getText().charAt(0));
+        if (mBtn.getId().equals(mBtnStartPos3.getId())) setzePosition(3, mItm.getText().charAt(0));
+        if (mBtn.getId().equals(mBtnWalzPos1.getId())) setzeWalze(1, mItm.getText());
+        if (mBtn.getId().equals(mBtnWalzPos2.getId())) setzeWalze(2, mItm.getText());
+        if (mBtn.getId().equals(mBtnWalzPos3.getId())) setzeWalze(3, mItm.getText());
+        if (mBtn.getId().equals(mBtnNotchPos1.getId()))
+            setzeRing(1, Integer.parseInt(mItm.getText()) - 1);
+        if (mBtn.getId().equals(mBtnNotchPos2.getId()))
+            setzeRing(2, Integer.parseInt(mItm.getText()) - 1);
+        if (mBtn.getId().equals(mBtnNotchPos3.getId()))
+            setzeRing(3, Integer.parseInt(mItm.getText()) - 1);
+    }
+
+    /**
+     * Hier werden die TextFelder, welche die Steckverbindungen darstellen,
+     * mit dem Werten die die Klasse Codierer zur Verfügung stellt gefüllt.
+     */
+    private void setzeSteckverbindungen() {
+        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]);
+    }
+
+    /**
+     * Die Löschen Funktion löscht das letzte Zeichen im Klartext sowie im Codiert Feld,
+     * der Codierer wird aufgerufen um ebenfalls das letzte Zeichen zu löschen
+     */
+    private void loeschen() {
+        if (textEingabe.length() == 0) {
+            tfKlartext.setText("");
+            tfCodiert.setText("");
+        } else {
+            textEingabe = textEingabe.substring(0, textEingabe.length() - 1);
+            textCodiert = textCodiert.substring(0, textCodiert.length() - 1);
+            tfKlartext.setText(textEingabe);
+            tfCodiert.setText(textCodiert);
+            codierer.letztesZeichenLoeschen();
+            mBtnStartPos1.setText(String.valueOf(this.codierer.fetchWalzen()[0]));
+            mBtnStartPos2.setText(String.valueOf(this.codierer.fetchWalzen()[1]));
+            mBtnStartPos3.setText(String.valueOf(this.codierer.fetchWalzen()[2]));
+        }
+    }
+
+    /**
+     * //TODO DOKU
+     */
+    void empfangeFunkspruch() {
+        String[] empfangeneNachricht = this.codierer.empfangeNachricht();
+        if (empfangeneNachricht[0] != null) {
+            this.tfKlartext.setText(empfangeneNachricht[2]);
+            this.tfCodiert.setText(empfangeneNachricht[1]);
+            this.resetDisplay = true;
+
+            // Spruchschluessel in das Feld lblSpruchschluessel schreiben
+            lblSpruchschluessel.setText(this.codierer.empfangenerSpruchschluessel(empfangeneNachricht[2]));
+
+            this.setzeTagesSchluessel();
+        }
+    }
+
+    /**
+     * //TODO DOKU
+     */
+    private void sendeFunkspruch() {
+        this.tfKlartext.setText("");
+        this.tfCodiert.setText("");
+
+        try {
+            this.codierer.sendeNachricht();
+        } catch (HttpException | IOException e) {
+            e.printStackTrace();
+        }
+
+    }
+
+    /**
+     * schreibt Buchstaben des gedrückten Knopfes in Textfeld tfrein
+     *
+     * @param pressedButton : gedrückter Knopf
+     */
+    private void setText(Button pressedButton) {
+        if (textEingabe.length() < 250) {
+            if (this.resetDisplay) {
+                this.tfCodiert.setText("");
+                this.tfKlartext.setText("");
+                this.resetDisplay = false;
+                this.codierer.resetHardware();
+                textCodiert = "";
+                textEingabe = "";
+                // Spruchschlüssel generieren und codieren
+                this.codierer.generateSpruchschluessel();
+                // Spruchschluessel in das Feld lblSpruchschluessel schreiben
+                lblSpruchschluessel.setText(this.codierer.getSpruchschluessel());
+            }
+            textEingabe += pressedButton.getText();
+            textCodiert += this.codierer.codiere(pressedButton.getText().charAt(0), true);
+
+            tfKlartext.setText(textEingabe);
+            tfCodiert.setText(textCodiert);
+
+            // Position der Walzen aktuallisieren
+            mBtnStartPos1.setText(String.valueOf(this.codierer.fetchWalzen()[0]));
+            mBtnStartPos2.setText(String.valueOf(this.codierer.fetchWalzen()[1]));
+            mBtnStartPos3.setText(String.valueOf(this.codierer.fetchWalzen()[2]));
+        }
+    }
+
+    /**
+     * Setzt die Anzeige des entsprechende Gui-Element auf die entsprechende Walze
+     * ->d.h. welche Walze sitzt auf welcher Position
+     *
+     * @param walzeRoemischNr => gibt die Walzennummer an
+     * @param walzenPosition  => gibt die Position der Walze
+     */
+    private void setzeWalze(int walzenPosition, String walzeRoemischNr) {
+        int walzeNr = 0;
+        switch (walzeRoemischNr) {
+            case "I":
+                walzeNr = 0;
+                break;
+            case "II":
+                walzeNr = 1;
+                break;
+            case "III":
+                walzeNr = 2;
+                break;
+            case "IV":
+                walzeNr = 4;
+                break;
+            case "V":
+                walzeNr = 4;
+                break;
+            default:
+                break;
+        }
+
+        switch (walzenPosition) {
+            case 1:
+                mBtnWalzPos1.setText(walzenNr[walzeNr]);
+                //codierer.setWalze(walzeNr, walzenPosition)
+                break;
+            case 2:
+                mBtnWalzPos2.setText(walzenNr[walzeNr]);
+                break;
+            case 3:
+                mBtnWalzPos3.setText(walzenNr[walzeNr]);
+                break;
+            default:
+                break;
+        }
+    }
+
+    /**
+     * Setzt den Notch (position)=> die Mitnahmeposition der Walze (walze) fest
+     * Mitnahmeposition meint => die nächste Walze wird bei erreichen dieser Position (notch)
+     * um eine Stelle versetzt
+     *
+     * @param ringStellung   => gibt die walze an
+     * @param walzenPosition => gibt den notch der Walze (walze) an
+     */
+    private void setzeRing(int walzenPosition, int ringStellung) {
+        switch (walzenPosition) {
+            case 1:
+                mBtnNotchPos1.setText(ringNr[ringStellung]);
+                break;
+            case 2:
+                mBtnNotchPos2.setText(ringNr[ringStellung]);
+                break;
+            case 3:
+                mBtnNotchPos3.setText(ringNr[ringStellung]);
+                break;
+            default:
+                break;
+        }
+    }
+
+    /**
+     * Setzt die Startposition/ aktuelle Position der Walze
+     *
+     * @param walze     => gibt die walze an
+     * @param buchstabe gibt den Startwert bzw die aktuelle Position der Walze (walze) an
+     */
+    private void setzePosition(int walze, char buchstabe) {
+        switch (walze) {
+            case 1:
+                mBtnStartPos1.setText(String.valueOf(buchstabe));
+                break;
+            case 2:
+                mBtnStartPos2.setText(buchstabe + "");
+                break;
+            case 3:
+                mBtnStartPos3.setText(buchstabe + "");
+                break;
+            default:
+                break;
+        }
+    }
+
+    /**
+     * Setzt den aktuellen TagesSchluessel
+     */
+    public void setzeTagesSchluessel() {
+
+        // Umsprungpunkte anzeigen
+        mBtnNotchPos1.setText(String.valueOf(this.codierer.fetchRingstellung()[0]));
+        mBtnNotchPos2.setText(String.valueOf(this.codierer.fetchRingstellung()[1]));
+        mBtnNotchPos3.setText(String.valueOf(this.codierer.fetchRingstellung()[2]));
+        // Walzennummern anzeigen
+        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.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.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/database/DatenbankSqlite.java b/src/main/java/projekt/enigma/database/DatenbankSqlite.java
index 401af573f4c4c30bd1e8e04c18ca79f647348cb0..ac7c9024be694baff54f6573ac70dc695fc45081 100644
--- a/src/main/java/projekt/enigma/database/DatenbankSqlite.java
+++ b/src/main/java/projekt/enigma/database/DatenbankSqlite.java
@@ -22,7 +22,7 @@ public class DatenbankSqlite {
 	 */
 	private Connection connect() {
 
-		String url = "jdbc:sqlite::resource:enigma/codebuch.sqlite";
+		String url = "jdbc:sqlite::resource:projekt/enigma/codebuch.sqlite";
 		Connection conn = null;
 
 		try {
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 11ccd130aa1a551f84606f3e63822865386e25c5..aecf7f3f4d0c7e62cbf5b6df5548b9f91cf66c38 100644
--- a/src/main/java/projekt/enigma/model/Codierer.java
+++ b/src/main/java/projekt/enigma/model/Codierer.java
@@ -14,410 +14,512 @@ 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 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[3];
-		String[] codierteNachricht = new Funkraum().empfangeFunkspruch(this.kenngruppe);
-
-		if (codierteNachricht[1] != null) {
-			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();
-		}
-
-		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;
-	}
+    //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();
+    }
 
 	/**
-	 * Setzt die Kenngruppe welche die Enigma gerade benutzt.
-	 *
-	 * @param kenngruppe : String : Kenngruppe welche die Enigma gerade benutzt
+	 * Leer das Nachrichten Objekt um eine neue Nachricht aufnehmen zu können
 	 */
-	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].getAnzeige();
-		walzen[1] = this.hardware.getWalzen()[1].getAnzeige();
-		walzen[2] = this.hardware.getWalzen()[2].getAnzeige();
-
-		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 feldNr     : int : Kabel Nummer welches am Steckbrett eingesteckt wird
-	 * @param verbindung : String : Verbindung welche die vertauschten Buchstaben angibt
-	 */
-	public void setSteckbrett(int feldNr, String verbindung) {
-		this.hardware.getSteckbrett().setzeVertauschung(verbindung.charAt(0), verbindung.charAt(1));
-	}
-
-	/**
-	 * Prüft ob der Port auf den das Kabel gesteckt werden soll, noch frei ist.
-	 * <p>
-	 * TODO: Prüfen ob im aktuellen Feld bereits zwei Buchstaben stehen, wenn ja, nach erfolg dieser Funktion,
-	 * 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 true;
-	}
-
+	public void resetNachricht() {
+    	this.nachricht = "";
+    }
+    //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 (walzenPosition) und resetet anschließen das
+     * Nachrichten Objekt
+     *
+     * @param walzenPosition : int : Nummer der Walze
+     * @param buchstabe      : char : Buchstabe der zugewiesen soll
+     */
+    public void setzeWalze(int walzenPosition, char buchstabe) {
+    	this.resetNachricht();
+        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 b37ddd166c98d2274e0722e401418c81d354bc16..4fc0c5ba2b22eac34592a1ea65f32105ff53dec9 100644
--- a/src/main/java/projekt/enigma/model/Hardware.java
+++ b/src/main/java/projekt/enigma/model/Hardware.java
@@ -15,153 +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();
-
-		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.
-	 */
-	private void dreheWalzen() {
-		if (this.walzen[2].dreheWalze()) {
-			if (this.walzen[1].dreheWalze()) {
-				this.walzen[0].dreheWalze();
-			}
-		}
-	}
-
-	/**
-	 * 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 b0ad4f4cb212d07e6bc2398ac5275142bbe8d756..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,20 +11,15 @@ package projekt.enigma.model;
  */
 public class Steckbrett {
 
-    /**
-     * zaehler: Int, der als Laufvariable genutzt wird
-     */
-    private int zaehler;
-
     /**
      * orginalBuchstaben: Character-Array, der jeweils den ersten zu vertauschenden Buchstaben enthält
      */
-    private Character[] orginalBuchstaben;
+    private String originalBuchstaben;
 
     /**
      * getauschteBuchstaben: Character-Array, der jeweils den zweiten zu vertauschenden Buchstaben enthält
      */
-    private Character[] getauschteBuchstaben;
+    private String getauschteBuchstaben;
 
 
     /**
@@ -32,62 +29,85 @@ public class Steckbrett {
      */
     public Steckbrett() {
 
-        orginalBuchstaben = new Character[10];
-        getauschteBuchstaben = new Character[10];
+        originalBuchstaben = "";
+        getauschteBuchstaben = "";
     }
 
     /**
-     * TODO: Fehlerfall kommentieren, bzw. Exceptions werfen ?????
-     * TODO: Überprüfe Vertauschungen für jeden Buchstaben aufrufen
      * Funktion setzeVertauschung
      * <br>
      * Der Funktion setzeVertauschung werden 2 Buchstaben (buchstabe1 und buchstabe2) übergeben.
-     * buchstabe1 wird in das Character-Array orginalBuchstaben geschrieben.
-     * buchstabe2 wird in das Character-Array getauschteBuchstaben geschrieben.
-     * Anschließend wird die Funktion ueberpruefeVertauschungen aufgerufen.
+     * 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 ueberpruefeVertauschungen(): Ueberprueft ob die Vertauschungen zulaessig sind.
+     * @return boolean : Wenn die Vertauschung zulässig ist, true, ansonsten false
      */
     public boolean setzeVertauschung(char buchstabe1, char buchstabe2) {
-        if (zaehler < orginalBuchstaben.length) {
-            orginalBuchstaben[zaehler] = buchstabe1;
-            getauschteBuchstaben[zaehler++] = 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 {
-            System.err.println("Zu viele Vertauschungen angegeben!");
+            return false;
         }
 
-        return ueberpruefeVertauschungen();
     }
 
     /**
-     * TODO: Fehlerfall kommentieren, bzw. Exceptions werfen ?????
-     * TODO: Buchstabe zum überpüfen übergeben
      * Funktion ueberpruefeVertauschungen
      * <br>
-     * Die Funktion ueberpruefeVertauschungen prueft ob die Buchstabenvertauschung zulaessig ist.
+     * 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 : result : Flag, der die Zulassigkeit der Vertauschungen zurueckgibt.
+     * @return boolean :    Wenn false, dann darf der Buchstabe genutzt werden.
+     * Wenn er schon vorhanden ist, wird true zurück gegeben
      */
-    public boolean ueberpruefeVertauschungen() {
-        boolean result = true;
-
-        /*Es wird geprüft:
-        1. Ob im Array originalBuchstaben Dopplungen enthalten sind.
-        2. Ob im Array originalBuchstaben Buchstaben im Array getauschteBuchstaben enthalten sind.
-        3. Ob im Array getauschteBuchstaben Dopplungen enthalten sind.
-        Tritt einer der Fälle ein, erfolgt eine Konsolenausgabe und der Flag wird auf false gesetzt.
-         */
-        for (int n = 0; n < orginalBuchstaben.length; n++) {
-            if (orginalBuchstaben.equals(orginalBuchstaben[n]) ||
-                    getauschteBuchstaben.equals(orginalBuchstaben[n]) ||
-                    getauschteBuchstaben.equals(getauschteBuchstaben[n])) {
-                System.err.println("Vertauschungen enthalten unzulässige Dopplungen");
-                result = false;
-            }
+    public boolean ueberpruefeVertauschungen(Character buchstabe) {
+
+        boolean result = false;
+
+        if (originalBuchstaben.contains(String.valueOf(buchstabe)) ||
+                getauschteBuchstaben.contains(String.valueOf(buchstabe))) {
+            result = true;
         }
 
         return result;
@@ -102,15 +122,14 @@ public class Steckbrett {
      * @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;
+        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 51bf3a8b377e37edaa1e303a21409f0dea83c87f..118ad4f6245b3c8ebd42e5baaf480b18d4808392 100644
--- a/src/main/java/projekt/enigma/model/Walze.java
+++ b/src/main/java/projekt/enigma/model/Walze.java
@@ -1,6 +1,8 @@
 package projekt.enigma.model;
 
 /**
+ * TODO: Dokumentation aktuallisieren
+ * <p>
  * Klasse Walze
  * <br>
  * Erzeugt ein Objekt des Typs Walze mit den Eigenschaften:
@@ -14,255 +16,174 @@ package projekt.enigma.model;
  */
 public class Walze {
 
+    //region Variablen
     /**
-     * walzeAlpha : Character[] : Array, dass die Buchstaben des Alphabets enthaelt
+     * Das String Array aller bekannter aktuellen Walzen
      */
-    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;
+    String[] walzen;
 
     /**
-     * Ueberschriebener Konstruktor, der die Eingangsparameter der Walze mitgibt
-     *
-     * @param walzennr     : int : Nummer der gewaehlten Walze
-     * @param ringstellung : int : Einstellung des Umsprungpunktes
+     * alphabet : String dass die Buchstaben des Alphabets enthaelt
      */
-    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);
-    }
+    private String alphabet;
 
     /**
-     * Sortiert der Walzennummer das passende Character-Array mittels switch zu.
-     *
-     * @return walze : Character[] : gibt die gewaehlte Walze zurueck
+     * ringstellung : char : zeigt die Einstellung fuer den Umspringpunkt
      */
-    private Character[] walzenNummer() {
-        Character[] walze = new Character[26];
+    private char ringstellung;
 
-        // 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;
-    }
+    /**
+     * walzennr : int : Bestimmt, welche Walze genutzt wird
+     */
+    private int walzenNr;
 
     /**
-     * TODO: Dokumentieren
-     *
-     * @return ringstellung : char : gibt die neue Ringstellung als char zurueck
+     * Die Anzahl der getätigten Walzen Drehungen
      */
-    public char getRingstellung() {
-        return ringstellung;
-    }
+    private int turns;
+    //endregion
 
+    //region Konstruktor
     /**
-     * Setzt die Initiale Ringstellung der Walze.
-     * Es sind nur Zahlen von 1 - 26 zugelassen.
-	 *
-	 * Die Ringstellung wird zum char umgewandelt.
-     * Im Fehlerfall wird die Ringstellung standardmaessig auf 'Z' gesetzt.
+     * Ueberschriebener Konstruktor, der die Eingangsparameter der Walze mit gibt
      *
-     * @param ringstellung : int : Punkt an dem die Walze umspringt
+     * @param walzenNr     : int : Nummer der gewaehlten Walze
+     * @param ringstellung : int : Einstellung des Umsprungpunktes
      */
-    //TODO ??? Setter Ringstellung
-    public void setRingstellung(int ringstellung) {
-        if ((ringstellung > 0) && (ringstellung <= 26)) {
-            this.ringstellung = this.alphabet[ringstellung - 1];
-        } else {
-            this.ringstellung = 'Z';
-        }
+    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: verschiebt das Alphabet um keine, eine oder mehrere Stellen und ueberschreibt
-	 * das Array alphabet mit der neuen Anordnung.
-	 *
-	 * Ueberprueft, ob der Umspringpunkt der Walze nach der Drehung erreicht wurde.
-	 *
-	 * @param drehung : int[] : Anzahl der Drehungen
-	 * @return checkRing : boolean : gibt true zurueck wenn der Umspringpunkt erreicht wurde
+     * 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... drehung) {
-        boolean checkRing = false;
+    public boolean dreheWalze(int richtung) {
 
-        // fuehrt die Verschiebung des Alphabets um eine Stelle durch
-        verschiebung();
+        boolean checkRing = false;
 
-        // fuehrt die Verschiebung mehrfach aus, wenn mehrere Drehungen ausgefuehrt werden sollen
-        if (drehung.length > 0) {
-            for (int i = 1; i < drehung[0]; i++) {
-                verschiebung();
+        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().equals(this.ringstellung)) {
-            checkRing = true;
+            // gleicht die Ringstellung mit der aktuellen Position ab
+            if (this.getPosition() + richtung == this.ringstellung) {
+                checkRing = true;
+            }
         }
 
         return checkRing;
     }
 
-    /**
-	 * Ueberschreibt die Alphabetswalze mit dem, durch die Drehung, verschobenen Alphabet.
-     * TODO: Dokumentieren
-     */
-    private void verschiebung() {
-        Character[] neueWalze = new Character[26];
-
-        for (int index = 0; index < neueWalze.length; index++) {
-            neueWalze[(index + 1) % neueWalze.length] = this.walzeAlpha[index];
-        }
-
-        this.walzeAlpha = neueWalze;
-    }
-
-    /**
-     * TODO: Dokumentieren // dass selbe wie getPosition
-     * Gibt den Buchstaben zurueck der in der Walze aktuell eingestellt ist.
-	 *
-     * @return char an der Stelle temp des Alphabets
-     */
-    public char getAnzeige() {
-        int temp = this.fetchArrayIndex('A', this.walzeAlpha);
-        return this.alphabet[temp];
-    }
-
     /**
      * Codiert den mitgegebenen Buchstaben anhand der gewaehlten Walze.
      *
-	 * @param buchstabe : char : Buchstabe, der verschluesselt werden soll
+     * @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;
+        return this.fetchWalze().charAt((this.alphabet.indexOf(buchstabe) + this.turns) % 26);
     }
 
     /**
-     * Decodiert den mitgegebenen Buchstaben mit Hilfe der (verschobenen) Alphabetswalze
+     * Decodiert den mitgegebenen Buchstaben mit Hilfe der (verschobenen) Walze
      *
-	 * @param buchstabe : char : Buchstabe, der decodiert werden soll
+     * @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;
+        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);
     }
 
     /**
-     * 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
+     * Holt den korrekten String zu der Walze
+     *
+     * @return walze : Character[] : gibt die gewaehlte Walze zurueck
      */
-    private int fetchArrayIndex(Character buchstabe, Character[] array) {
-        // wird mit ungueltigem Wert initialisiert
-    	int result = -1;
+    private String fetchWalze() {
 
-        for (int i = 0; i < array.length; i++) {
-            if (array[i].equals(buchstabe)) {
-                result = i;
-                break;
-            }
-        }
+        return walzen[walzenNr];
+    }
+    //endregion
 
-        return result;
+    //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
+     * @param walzenNr : int : Walzennummer
      */
-    public void setWalzennr(int walzennr) {
-        if ((walzennr > 0) && (walzennr < 6)) {
-            this.walzennr = walzennr;
+    public void setWalzenNr(int walzenNr) {
+        if ((walzenNr > 0) && (walzenNr < 6)) {
+            this.walzenNr = walzenNr - 1;
         } 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
+     * 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.
      *
-     * @return Character am Index 0 des (verschobenen) Alphabets zurueck
+     * @param ringstellung : int : Punkt an dem die Walze umspringt
      */
-    public Character getPosition() {
-        return walzeAlpha[0];
+    public void setRingstellung(int ringstellung) {
+        if ((ringstellung > 0) && (ringstellung <= 26)) {
+            this.ringstellung = this.alphabet.charAt(ringstellung - 1);
+        } else {
+            this.ringstellung = 'Z';
+        }
     }
+    //endregion
 
+    //region Getter
     /**
-     * 	 * 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.
+     * Gibt den Character zurueck, der aktuell in der Walze eingestellt ist
      *
-     * @param buchstabe : Character : Einstellung der Walze
+     * @return Character am Index 0 des (verschobenen) Alphabets zurueck
      */
-    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));
-            }
-        }
+    public Character getPosition() {
+        return this.alphabet.charAt(turns % 26);
     }
-}
+    //endregion
+}
\ No newline at end of file
diff --git a/src/main/resources/projekt/enigma/gui.fxml b/src/main/resources/projekt/enigma/gui.fxml
index 4c75cd670c3ea1b526fb67c89e0adc9bfae8579d..8630069413fb732ad0ed6f81fbe7b28ce2efa52f 100644
--- a/src/main/resources/projekt/enigma/gui.fxml
+++ b/src/main/resources/projekt/enigma/gui.fxml
@@ -5,20 +5,18 @@
 <?import javafx.scene.control.Label?>
 <?import javafx.scene.control.MenuButton?>
 <?import javafx.scene.control.ProgressBar?>
-<?import javafx.scene.control.Separator?>
 <?import javafx.scene.control.TextField?>
 <?import javafx.scene.layout.AnchorPane?>
 <?import javafx.scene.layout.ColumnConstraints?>
 <?import javafx.scene.layout.FlowPane?>
 <?import javafx.scene.layout.GridPane?>
-<?import javafx.scene.layout.Pane?>
 <?import javafx.scene.layout.RowConstraints?>
 <?import javafx.scene.layout.TilePane?>
 <?import javafx.scene.layout.VBox?>
 <?import javafx.scene.shape.Circle?>
 <?import javafx.scene.text.Font?>
 
-<AnchorPane maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" prefHeight="677.0" prefWidth="967.0" xmlns="http://javafx.com/javafx/8.0.171" xmlns:fx="http://javafx.com/fxml/1" fx:controller="projekt.enigma.GuiController">
+<AnchorPane maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" prefHeight="677.0" prefWidth="967.0" xmlns="http://javafx.com/javafx/8.0.999-ea" xmlns:fx="http://javafx.com/fxml/1" fx:controller="projekt.enigma.GuiController">
    <children>
       <GridPane layoutY="313.0" prefHeight="393.0" prefWidth="968.0" AnchorPane.bottomAnchor="-7.0" AnchorPane.leftAnchor="0.0" AnchorPane.rightAnchor="0.0" AnchorPane.topAnchor="313.0">
         <columnConstraints>
@@ -41,8 +39,8 @@
           <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
           <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
             <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
-            <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
-            <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
+            <RowConstraints maxHeight="63.0" minHeight="10.0" prefHeight="63.0" vgrow="SOMETIMES" />
+            <RowConstraints maxHeight="41.0" minHeight="10.0" prefHeight="29.0" vgrow="SOMETIMES" />
             <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
           <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
         </rowConstraints>
@@ -198,14 +196,6 @@
                   <Insets left="28.0" />
                </GridPane.margin>
             </Button>
-            <Button fx:id="btnA" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="A" textFill="#fffdfd" GridPane.columnIndex="2" GridPane.rowIndex="5">
-               <font>
-                  <Font name="System Bold" size="18.0" />
-               </font>
-               <GridPane.margin>
-                  <Insets left="28.0" />
-               </GridPane.margin>
-            </Button>
             <Button fx:id="btnO" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="O" textFill="#fffdfd" GridPane.columnIndex="10" GridPane.rowIndex="4">
                <font>
                   <Font name="System Bold" size="18.0" />
@@ -251,7 +241,7 @@
                   <Font name="System Bold" size="18.0" />
                </font>
             </Button>
-            <Button minHeight="44.0" mnemonicParsing="false" onAction="#loeschen" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="&lt;" textFill="#fffdfd" GridPane.columnIndex="10" GridPane.rowIndex="5">
+            <Button fx:id="btnDelete" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="&lt;" textFill="#fffdfd" GridPane.columnIndex="10" GridPane.rowIndex="5">
                <font>
                   <Font size="18.0" />
                </font>
@@ -527,21 +517,26 @@
             </Label>
             <TilePane prefHeight="200.0" prefWidth="200.0" GridPane.columnIndex="1" GridPane.rowIndex="4" />
             <VBox prefHeight="200.0" prefWidth="152.0" GridPane.columnIndex="11" />
+            <Button fx:id="btnA" minHeight="35.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="35.0" prefWidth="42.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="A" textFill="#fffdfd" GridPane.columnIndex="2" GridPane.rowIndex="5">
+               <font>
+                  <Font name="System Bold" size="18.0" />
+               </font>
+            </Button>
          </children>
       </GridPane>
       <AnchorPane layoutX="241.0" layoutY="130.0" prefHeight="111.0" prefWidth="487.0" AnchorPane.leftAnchor="241.0" AnchorPane.rightAnchor="240.0">
          <children>
-            <VBox layoutX="72.0" layoutY="-89.0" prefHeight="200.0" prefWidth="378.0" AnchorPane.bottomAnchor="0.0" AnchorPane.leftAnchor="72.0" AnchorPane.rightAnchor="37.0" AnchorPane.topAnchor="-89.0">
+            <VBox layoutX="72.0" layoutY="-89.0" prefHeight="210.0" prefWidth="377.0" AnchorPane.bottomAnchor="-10.0" AnchorPane.leftAnchor="72.0" AnchorPane.rightAnchor="37.0" AnchorPane.topAnchor="-89.0">
                <children>
-                  <TextField fx:id="tfCodiert" editable="false" prefHeight="99.0" prefWidth="377.0" />
-                  <Separator prefWidth="200.0" />
-                  <TextField fx:id="tfKlartext" editable="false" prefHeight="100.0" prefWidth="378.0" />
+                  <TextField fx:id="tfKlartext" editable="false" prefHeight="80.0" prefWidth="377.0" />
+                  <Label prefHeight="17.0" prefWidth="385.0" />
+                  <TextField fx:id="tfCodiert" editable="false" prefHeight="79.0" prefWidth="377.0" />
+                  <Label prefHeight="17.0" prefWidth="385.0" />
+                  <Label fx:id="lblLadeNachricht" alignment="BASELINE_CENTER" contentDisplay="CENTER" prefHeight="5.0" prefWidth="377.0" text="Neue Nachricht wird vom Funkraum abgerufen!" />
+                  <ProgressBar fx:id="pbLadeNachricht" prefHeight="10.0" prefWidth="377.0" progress="0.0" />
                </children>
             </VBox>
          </children></AnchorPane>
-      <Label layoutX="40.0" layoutY="233.0" prefHeight="17.0" prefWidth="172.0" text="Spruchschlüssel" />
-      <Label layoutX="34.0" layoutY="259.0" prefHeight="17.0" prefWidth="172.0" text="Tagesschlüssel" />
-      <ProgressBar fx:id="pbLadeNachricht" layoutX="313.0" layoutY="273.0" prefHeight="18.0" prefWidth="378.0" progress="0.0" />
       <GridPane layoutX="23.0" layoutY="60.0" prefHeight="158.0" prefWidth="237.0" AnchorPane.leftAnchor="23.0" AnchorPane.topAnchor="60.0">
         <columnConstraints>
             <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0" />
@@ -607,16 +602,28 @@
       </MenuButton>
          </children>
       </GridPane>
-      <Label fx:id="lblLadeNachricht" alignment="CENTER" layoutX="313.0" layoutY="250.0" prefHeight="17.0" prefWidth="378.0" text="Neue Nachricht wird vom Funkraum abgerufen!" />
-      <FlowPane layoutX="735.0" layoutY="27.0" prefHeight="158.0" prefWidth="152.0" AnchorPane.leftAnchor="735.0" AnchorPane.rightAnchor="38.0" AnchorPane.topAnchor="27.0">
+      <FlowPane layoutX="736.0" layoutY="51.0" prefHeight="173.0" prefWidth="195.0" AnchorPane.rightAnchor="36.0" AnchorPane.topAnchor="51.0">
          <children>
-            <Button mnemonicParsing="false" onAction="#btnsenden" prefHeight="80.0" prefWidth="152.0" text="An Funker senden" />
-            <Pane>
-               <children>
-                  <Button mnemonicParsing="false" onAction="#btnempfangen" prefHeight="101.0" prefWidth="195.0" text="Funkspruch empfangen" />
-               </children>
-            </Pane>
+            <Button fx:id="btnEmpfangen" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="80.0" prefWidth="195.0" text="Funkspruch empfangen" />
+            <Label prefHeight="17.0" prefWidth="195.0" />
+            <Button fx:id="btnSenden" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="80.0" prefWidth="195.0" text="An Funker senden" />
          </children>
       </FlowPane>
+      <GridPane layoutX="23.0" layoutY="222.0" prefHeight="60.0" prefWidth="270.0" AnchorPane.leftAnchor="23.0" AnchorPane.topAnchor="222.0">
+        <columnConstraints>
+          <ColumnConstraints hgrow="SOMETIMES" maxWidth="130.0" minWidth="10.0" prefWidth="100.0" />
+          <ColumnConstraints hgrow="SOMETIMES" maxWidth="224.0" minWidth="10.0" prefWidth="170.0" />
+        </columnConstraints>
+        <rowConstraints>
+          <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
+          <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
+        </rowConstraints>
+         <children>
+            <Label alignment="CENTER_RIGHT" text="Tagesschlüssel:" />
+            <Label text="Spruchschlüssel:" GridPane.rowIndex="1" />
+            <Label fx:id="lblTagesschluessel" prefHeight="17.0" prefWidth="181.0" GridPane.columnIndex="1" />
+            <Label fx:id="lblSpruchschluessel" prefHeight="17.0" prefWidth="181.0" GridPane.columnIndex="1" GridPane.rowIndex="1" />
+         </children>
+      </GridPane>
    </children>
 </AnchorPane>
diff --git a/src/main/resources/projekt/enigma/kenngruppe.fxml b/src/main/resources/projekt/enigma/kenngruppe.fxml
index 237b3ed092c45e0f47661d7827503bee95b79ea7..2cedf3644a5b65ea0c8f53751137ac55e051acd3 100644
--- a/src/main/resources/projekt/enigma/kenngruppe.fxml
+++ b/src/main/resources/projekt/enigma/kenngruppe.fxml
@@ -4,8 +4,9 @@
 <?import javafx.scene.control.Label?>
 <?import javafx.scene.layout.AnchorPane?>
 <?import javafx.scene.layout.HBox?>
+<?import javafx.scene.shape.Circle?>
 
-<AnchorPane maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" prefHeight="411.0" prefWidth="512.0" xmlns="http://javafx.com/javafx/8.0.171" xmlns:fx="http://javafx.com/fxml/1" fx:controller="enigma.KenngruppeController">
+<AnchorPane maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" prefHeight="411.0" prefWidth="512.0" xmlns="http://javafx.com/javafx/8.0.171" xmlns:fx="http://javafx.com/fxml/1" fx:controller="projekt.enigma.KenngruppeController">
    <children>
       <Label layoutX="81.0" layoutY="29.0" text="Bitte Kenngruppe eingeben!" AnchorPane.leftAnchor="81.0" AnchorPane.rightAnchor="70.0" AnchorPane.topAnchor="29.0" />
       <HBox layoutX="107.0" layoutY="141.0" prefHeight="26.0" prefWidth="276.0" AnchorPane.leftAnchor="107.0" AnchorPane.rightAnchor="129.0" AnchorPane.topAnchor="141.0">
@@ -15,5 +16,7 @@
             <Button mnemonicParsing="false" prefHeight="25.0" prefWidth="150.0" text="Button" />
          </children>
       </HBox>
+      <Circle fill="DODGERBLUE" layoutX="226.0" layoutY="267.0" radius="100.0" stroke="BLACK" strokeType="INSIDE" AnchorPane.leftAnchor="126.0" AnchorPane.rightAnchor="186.0" AnchorPane.topAnchor="167.0" />
+      <Button fx:id="secondaryButton" layoutX="40.0" layoutY="85.0" onAction="#switchToPrimary" prefHeight="25.0" prefWidth="241.0" text="Kenngruppe bestätigen!" />
    </children>
 </AnchorPane>
diff --git a/src/test/java/projekt/enigma/model/HardwareTest.java b/src/test/java/projekt/enigma/model/HardwareTest.java
index 742e6aba1b8679f81f8729a183fc7dd377616aa9..d0be7f035f829af0eb6defdb7356440510017587 100644
--- a/src/test/java/projekt/enigma/model/HardwareTest.java
+++ b/src/test/java/projekt/enigma/model/HardwareTest.java
@@ -17,13 +17,14 @@ 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;
@@ -52,13 +53,17 @@ public class HardwareTest {
 		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: Erwartet F, erhalten " + result, 'D', result);
+		Assert.assertEquals("Codiere: I Erwartet F, erhalten " + result, 'D', result);
 
 		h.resetWalzen();
 		result = h.codiere('D');
-		Assert.assertEquals("Codiere: Erwartet I, erhalten " + result, 'I', result);
+		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 7a898dd9c28224efe22df8d49726af786ed9e3db..ce8cdbc4fd5a5c59769e260244e149001d410def 100644
--- a/src/test/java/projekt/enigma/model/WalzeTest.java
+++ b/src/test/java/projekt/enigma/model/WalzeTest.java
@@ -10,22 +10,22 @@ public class WalzeTest {
 	@Test
 	public void setRingstellung() {
 		Walze w = new Walze(1, 1);
-		char temp = w.getAnzeige();
+		char temp = w.getPosition();
 		Assert.assertEquals('A', temp);
 	}
 
 	@Test
 	public void dreheWalze() {
-		Walze w = new Walze(1, 3);
-		assertFalse("false erwartet, true geliefert", w.dreheWalze(2));
-		char temp = w.getAnzeige();
-		Assert.assertEquals("C erwartet, " + temp + " zurück gegeben", 'C', temp);
+		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);
 	}
 
 	@Test
-	public void getAnzeige() {
+	public void getPosition() {
 		Walze w = new Walze(1, 1);
-		char temp = w.getAnzeige();
+		char temp = w.getPosition();
 		Assert.assertEquals('A', temp);
 	}