diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index a9cdd0d88a066b473ec56f66313bb51bd2456464..96e0ce87853b9c65bc56756c71282a745453b22c 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -1,5 +1,8 @@
 image: maven:latest
 
+cache:
+  key: EnigmaCache
+
 stages:
   - clean
   - build
@@ -28,3 +31,6 @@ Deploy new version as Release:
   script:
     - mvn versions:set -DnewVersion=$CI_COMMIT_TAG
     - mvn assembly:assembly
+  artifacts:
+    paths:
+      - target/*.jar
\ No newline at end of file
diff --git a/LICENSE b/LICENSE
index 214f2036305afeed1fce2db5dedc4d2c3c89a847..eca5a29aee31cb8a47dfff0b974c65433079aa06 100644
--- a/LICENSE
+++ b/LICENSE
@@ -632,7 +632,7 @@ state the exclusion of warranty; and each file should have at least
 the "copyright" line and a pointer to where the full notice is found.
 
     Enigma
-    Copyright (C) 2019  AlfaTrainingKurse / Java
+    Copyright (C) 2019 Enigma@Java Developer Team
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -652,7 +652,7 @@ Also add information on how to contact you by electronic and paper mail.
   If the program does terminal interaction, make it output a short
 notice like this when it starts in an interactive mode:
 
-    Enigma  Copyright (C) 2019  AlfaTrainingKurse / Java
+    Enigma  Copyright (C) 2019  Enigma@Java Developer Team
     This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
     This is free software, and you are welcome to redistribute it
     under certain conditions; type `show c' for details.
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/pom.xml b/pom.xml
index ccec90007b7180a0e5217dd1c67323f132d5f920..680b9ad5b923a384115bb376c477879ec0abd7d2 100644
--- a/pom.xml
+++ b/pom.xml
@@ -1,15 +1,15 @@
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
     <modelVersion>4.0.0</modelVersion>
-    <groupId>Projektarbeit</groupId>
-    <artifactId>Enigma</artifactId>
+    <groupId>projekt</groupId>
+    <artifactId>enigma</artifactId>
     <version>0.0.1</version>
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <!--region[useage]-->
         <use.java.version>11</use.java.version>
         <use.javafx.version>11.0.2</use.javafx.version>
-        <use.app.main.class>Enigma.Main</use.app.main.class>
+        <use.app.main.class>${project.groupId}.${project.artifactId}.Main</use.app.main.class>
         <!--endregion[useage]-->
         <maven.compiler.source>${use.java.version}</maven.compiler.source>
         <maven.compiler.target>${use.java.version}</maven.compiler.target>
@@ -25,6 +25,12 @@
             <artifactId>javafx-fxml</artifactId>
             <version>${use.javafx.version}</version>
         </dependency>
+        <!-- https://mvnrepository.com/artifact/net.sourceforge.plantuml/plantuml -->
+        <dependency>
+            <groupId>net.sourceforge.plantuml</groupId>
+            <artifactId>plantuml</artifactId>
+            <version>8059</version>
+        </dependency>
         <!-- https://mvnrepository.com/artifact/org.xerial/sqlite-jdbc -->
         <dependency>
             <groupId>org.xerial</groupId>
diff --git a/src/main/java/Enigma/App.java b/src/main/java/Enigma/App.java
deleted file mode 100644
index 1e8c80902cf8d08f3c1da4ff39b18a55028dac21..0000000000000000000000000000000000000000
--- a/src/main/java/Enigma/App.java
+++ /dev/null
@@ -1,39 +0,0 @@
-package Enigma;
-
-import javafx.application.Application;
-import javafx.fxml.FXMLLoader;
-import javafx.scene.Parent;
-import javafx.scene.Scene;
-import javafx.stage.Stage;
-
-import java.io.IOException;
-
-/**
- * JavaFX App
- */
-public class App extends Application {
-
-    private static Scene scene;
-
-    @Override
-    public void start(Stage stage) throws IOException {
-        scene = new Scene(loadFXML("gui"));
-        stage.setScene(scene);
-        stage.show();
-
-    }
-
-    static void setRoot(String fxml) throws IOException {
-        scene.setRoot(loadFXML(fxml));
-    }
-
-    private static Parent loadFXML(String fxml) throws IOException {
-        FXMLLoader fxmlLoader = new FXMLLoader(App.class.getResource(fxml + ".fxml"));
-        return fxmlLoader.load();
-    }
-
-    public static void main(String[] args) {
-        Application.launch();
-    }
-
-}
\ No newline at end of file
diff --git a/src/main/java/Enigma/GuiController.java b/src/main/java/Enigma/GuiController.java
deleted file mode 100644
index 7e444ce2d9d8ea92ab29b90f1a76c37f048901a6..0000000000000000000000000000000000000000
--- a/src/main/java/Enigma/GuiController.java
+++ /dev/null
@@ -1,225 +0,0 @@
-package Enigma;
-
-import javafx.fxml.FXML;
-import javafx.scene.control.Label;
-import javafx.scene.control.MenuButton;
-import javafx.scene.control.MenuItem;
-
-import java.awt.event.ActionEvent;
-import java.util.ArrayList;
-import java.util.List;
-
-public class GuiController {
-
-    @FXML
-    private MenuButton w1;
-//
-//    @FXML
-//    private MenuItem w1I;
-//
-//    @FXML
-//    private MenuItem w1II;
-//
-//    @FXML
-//    private MenuItem w1III;
-//    @FXML
-//    private MenuItem w1IV;
-//
-//    @FXML
-//    private MenuItem w1V;
-
-    @FXML
-    private MenuButton w2;
-    @FXML
-    private MenuItem w2I;
-
-    @FXML
-    private MenuItem w2II;
-
-    @FXML
-    private MenuItem w2III;
-
-    @FXML
-    private MenuItem w2IV;
-
-    @FXML
-    private MenuItem w2V;
-
-    @FXML
-    private MenuButton w3;
-
-    @FXML
-    private MenuItem w3I;
-
-    @FXML
-    private MenuItem w3II;
-
-    @FXML
-    private MenuItem w3III;
-    @FXML
-    private MenuItem w3IV;
-
-    @FXML
-    private MenuItem w3V;
-
-
-    @FXML
-    void w3I(ActionEvent event) {
-    }
-
-    @FXML
-    void w3II(ActionEvent event) {
-    }
-
-    @FXML
-    void w3III(ActionEvent event) {
-    }
-    @FXML
-    void w3IV(ActionEvent event) {
-    }
-    @FXML
-    void w3V(ActionEvent event) {
-    }
-
-    @FXML
-    void btnsenden(ActionEvent event) {
-    }
-    public void btnsenden(){
-
-    }
-//    @FXML
-//    void w1I(ActionEvent event) {
-//    }
-//    @FXML
-//    void w1II(ActionEvent event) {
-//    }
-//    @FXML
-//    void w1III(ActionEvent event) {
-//    }
-//    @FXML
-//    void w1IV(ActionEvent event) {
-//    }
-//    @FXML
-//    void w1V(ActionEvent event) {
-//    }
-
-    @FXML
-    void w2I(ActionEvent event) {
-    }
-    @FXML
-    void w2II(ActionEvent event) {
-    }
-    @FXML
-    void w2III(ActionEvent event) {
-    }
-    @FXML
-    void w2IV(ActionEvent event) {
-    }
-    @FXML
-    void w2V(ActionEvent event) {
-    }
-
-//    // Action Listener für erste Walze
-//    public void w1I(){
-//        w1.setText(w1I.getText());
-//    }
-//    public void w1II(){
-//       w1.setText(w1II.getText());
-//    }
-//    public void w1III(){
-//        w1.setText(w1III.getText());
-//    }
-//   public void w1IV(){
-//        w1.setText(w1IV.getText());
-//    }
-//   public void w1V(){
-//        w1.setText(w1V.getText());
-//    }
-    // Action Listener für zweite Walze
-    public void w2I(){
-        w2.setText(w2I.getText());
-    }
-    public void w2II(){
-        w2.setText(w2II.getText());
-    }
-    public void w2III(){
-        w2.setText(w2III.getText());
-    }
-    public void w2IV(){
-        w2.setText(w2IV.getText());
-    }
-    public void w2V(){
-        w2.setText(w2V.getText());
-    }
-    // Action Listener für dritte Walze
-    public void w3I(){
-        w3.setText(w3I.getText());
-    }
-    public void w3II(){
-        w3.setText(w3II.getText());
-    }
-    public void w3III(){
-        w3.setText(w3III.getText());
-    }
-    public void w3IV(){
-        w3.setText(w3IV.getText());
-    }
-    public void w3V(){
-        w3.setText(w3V.getText());
-    }
-
-    public void listener(MenuButton mb, MenuItem mi){
-        mb.setText(mi.getText());
-    }
-//
-//    public void walzenListener(){
-//        MenuItem[] buttons = {w1I,w1II,w1II,w1IV,w1V};
-//        for (int i =0; i<6; i++) {
-//            listener(w1, buttons[i]);
-//        }
-//    }
-
-
-
-    @FXML
-    void initialize() {
-
-//        for (int i =0; i<6; i++) {
-//
-//            mi.add(new MenuItem("W"+i));
-//        }
-
-        ArrayList<MenuItem> mi;
-
-        for (int i =0; i<6; i++) {
-            String[] str={"I","II","III","IV","V"};
-            MenuItem mb2 = new MenuItem("W"+i);
-            w1.getItems().add(mb2);
-          //  listener(w1,mb2);
-        }
-       // listener(w1,);
-
-
-      //  walzenListener();
-
-        assert w1 != null : "fx:id=\"w1\" was not injected: check your FXML file 'primary.fxml'.";
-//        assert w1I != null : "fx:id=\"w1I\" was not injected: check your FXML file 'primary.fxml'.";
-//        assert w1II != null : "fx:id=\"w1II\" was not injected: check your FXML file 'primary.fxml'.";
-//        assert w1III != null : "fx:id=\"w1III\" was not injected: check your FXML file 'primary.fxml'.";
-//        assert w1IV != null : "fx:id=\"w1IV\" was not injected: check your FXML file 'primary.fxml'.";
-//        assert w1V != null : "fx:id=\"w1V\" was not injected: check your FXML file 'primary.fxml'.";
-        assert w3 != null : "fx:id=\"w3\" was not injected: check your FXML file 'primary.fxml'.";
-        assert w3I != null : "fx:id=\"w3I\" was not injected: check your FXML file 'primary.fxml'.";
-        assert w3II != null : "fx:id=\"w3II\" was not injected: check your FXML file 'primary.fxml'.";
-        assert w3III != null : "fx:id=\"w3III\" was not injected: check your FXML file 'primary.fxml'.";
-        assert w3IV != null : "fx:id=\"w3IV\" was not injected: check your FXML file 'primary.fxml'.";
-        assert w3V != null : "fx:id=\"w3V\" was not injected: check your FXML file 'primary.fxml'.";
-        assert w2 != null : "fx:id=\"w2\" was not injected: check your FXML file 'primary.fxml'.";
-        assert w2I != null : "fx:id=\"w2I\" was not injected: check your FXML file 'primary.fxml'.";
-        assert w2II != null : "fx:id=\"w2II\" was not injected: check your FXML file 'primary.fxml'.";
-        assert w2III != null : "fx:id=\"w2III\" was not injected: check your FXML file 'primary.fxml'.";
-        assert w2IV != null : "fx:id=\"w2IV\" was not injected: check your FXML file 'primary.fxml'.";
-        assert w2V != null : "fx:id=\"w2V\" was not injected: check your FXML file 'primary.fxml'.";
-    }
-
-}
diff --git a/src/main/java/Enigma/model/Codebuch.java b/src/main/java/Enigma/model/Codebuch.java
deleted file mode 100644
index 0c6d01da135415010d27909d1a07f604de085f00..0000000000000000000000000000000000000000
--- a/src/main/java/Enigma/model/Codebuch.java
+++ /dev/null
@@ -1,144 +0,0 @@
-package Enigma.model;
-
-/**
- * Das Codebuch war eines der essentiel wichtigen Sachen bei der Enigma.
- * Jeder Enigma gehörte auch ein Codebuch bei, welches notwenidg war um die Nachrichten zu ver/entschlüsseln.
- * Im Codebuch standen für jeden Tag des Monats die notwendigen Einstellungen welche vorgenommen werden
- * mussten um die Texte zu ver/entschlüsseln.
- * Hiernach wurden die Walzen eingesetzt, die Ringe für den Rücksprung der Walze gesetzt und deren Grundeinstellung
- * vorgenommen.
- * Bei der Enigma um welche es hier geht (Enigma I) gab es zusätzlich ein Steckbrett, welches ebenfalls im Codebuch
- * festgelegt war.
- *
- * Dieses Codebuch Objekt enthält die Einstellungen eines Tages, welche mittels Getter und Setter
- * verarbeitet werden können.
- *
- * Zusätzlich gibt es zu Debug Zwecken eine überschriebene toString Funktion welche das Objekt als String zurück
- * geben kann.
- */
-public class Codebuch {
-	private int tag;
-	private String[] Walzenlage;
-	private String[] Ringstellung;
-	private String[] Steckverbindung;
-
-	Codebuch() {
-		this.Walzenlage = new String[3];
-		this.Ringstellung = new String[3];
-		this.Steckverbindung = new String[10];
-	}
-
-	/**
-	 * Gibt die aktuelle Instanz des Codebuches als String zurück.
-	 * Hierbei werden der Tag die Walzenlagen, Ring/Grundstellung sowie die Steckverbindungen zurück gegeben.
-	 *
-	 * @return String : String des gesamten Objektes
-	 */
-	@Override
-	public String toString() {
-		StringBuilder sb = new StringBuilder();
-		boolean wlLoop = false;
-		boolean rsLoop = false;
-		boolean svLoop = false;
-
-		sb.append("Tag: ").append(this.getTag()).append("\n");
-
-		sb.append("Walzenlage: ");
-		for(String wl : this.getWalzenlage()) {
-			sb.append(wl).append(",");
-			wlLoop = true;
-		}
-		if(wlLoop) {
-			sb.setLength(sb.length() - 1);
-		}
-		sb.append("\n");
-
-		sb.append("Ringstellung: ");
-		for(String rs : this.getRingstellung()) {
-			sb.append(rs).append(",");
-			rsLoop = true;
-		}
-		if(rsLoop) {
-			sb.setLength(sb.length() - 1);
-		}
-		sb.append("\n");
-
-		sb.append("Steckverbindung: ");
-		for (String s : this.getSteckverbindung()) {
-			if (!s.isEmpty()) {
-				sb.append(s).append(",");
-				svLoop = true;
-			}
-		}
-		if(svLoop) {
-			sb.setLength(sb.length() - 1);
-		}
-		sb.append("\n");
-
-		return sb.toString();
-	}
-
-	/**
-	 * Gibt den Tag dieser Instanz zurück
-	 * @return int : Tag
-	 */
-	public int getTag() {
-		return tag;
-	}
-
-	/**
-	 * Gibt die Walzenlage dieser Instanz zurück
-	 * @return String[] : Walzenlage
-	 */
-	public String[] getWalzenlage() {
-		return Walzenlage;
-	}
-
-	/**
-	 * Gibt die Ringstellung dieser Instanz zurück
-	 * @return String[] : Ringstellung
-	 */
-	public String[] getRingstellung() {
-		return Ringstellung;
-	}
-
-	/**
-	 * Gibt die Steckverbindung dieser Instanz zurück
-	 * @return String[] : Steckverbindung
-	 */
-	public String[] getSteckverbindung() {
-		return Steckverbindung;
-	}
-
-	/**
-	 * Setzt den Tag dieser Instanz
-	 * @param tag : int
-	 */
-	public void setTag(int tag) {
-		this.tag = tag;
-	}
-
-	/**
-	 * Setzt die Walzenlage dieser Instanz
-	 * @param walzenlage : String[]
-	 */
-	public void setWalzenlage(String[] walzenlage) {
-		Walzenlage = walzenlage;
-	}
-
-	/**
-	 * Setzt die Ringstellung dieser Instanz
-	 * @param ringstellung : String[]
-	 */
-	public void setRingstellung(String[] ringstellung) {
-		Ringstellung = ringstellung;
-	}
-
-	/**
-	 * Setzt die Steckverbindung dieser Instanz
-	 * @param steckverbindung : String[]
-	 */
-	public void setSteckverbindung(String[] steckverbindung) {
-		Steckverbindung = steckverbindung;
-	}
-}
diff --git a/src/main/java/Enigma/model/Reflektor.java b/src/main/java/Enigma/model/Reflektor.java
deleted file mode 100644
index cc7c69dc5d6291056189ae515715aa2ddb1356a1..0000000000000000000000000000000000000000
--- a/src/main/java/Enigma/model/Reflektor.java
+++ /dev/null
@@ -1,83 +0,0 @@
-package Enigma.model;
-
-/**
- * Klasse Reflektor
- *
- * Der Reflektor nimmt einen Buchstaben der Klasse Walze entgegen und und kodiert diesen.
- * Der kodierte Buchstabe wird an die Klasse Walze wieder zurückgegeben.
- *
- * Prinzipiell verhält sich die Klasse Refelktor wie die Klasse Walze, außer das sie sich
- * nach Betätigung einer Taste nicht dreht (starr montiert) und sie gibt keine Signale
- * an andere Walzen zum drehen.
- */
-public class Reflektor {
-
-    /**
-     * Konstanten und Variablen der Klasse Reflektor
-     *
-     * WALZE_ALPHABET : konstanter Char-Array mit den Werten des Alphabeths (26 Werte)
-     * WALZE_REFLEKTOR : konstanter Char-Array mit den Werten des Reflektors (26 Werte)
-     * reflektorBuchstabeRein : Character mit dem an die Klasse übergebenen Character
-     * reflektorBuchstabeRaus : Character nach der Codierung in der Klasse Reflektor
-     * iPositionReflektor : Integer mit der Positionsnummer des Characters im Array
-     */
-    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'};
-    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'};
-    private Character reflektorBuchstabeRein;
-    private Character reflektorBuchstabeRaus;
-    private int iPositionReflektor;
-
-
-    /**
-     * Funktion Codiere
-     *
-     * Durchsucht das konstante Char-Array WALZE_ALPHABET nach der Position eines bestimmten
-     * Buchstabens und gibt den Character an der entsprechenden Position im konstanten
-     * Char-Array WALZE_REFLEKTOR zurück.
-     *
-     * @return reflektorBuchstabeRaus: Character: Der kodierte Buchstabe aus dem Reflektor
-     */
-    public char codiere (){
-        int index = 0;
-
-        /*Ermittelt die Position des Buchstaben buchstabe auf der Alphabetswalze*/
-        for(index = 0; index < WALZE_ALPHABET.length; index++) {
-            if(getReflektorBuchstabeRein().equals(WALZE_ALPHABET[index])) {
-                iPositionReflektor = index;
-                break;
-            }
-        }
-        /*Im Char-Array WALZE_REFLEKTOR wird der Character an der Position iPositionReflektor ausgegeben*/
-        reflektorBuchstabeRaus = WALZE_REFLEKTOR[iPositionReflektor];
-        return reflektorBuchstabeRaus;
-    }
-
-    /**
-     * Getter getReflektorBuchstabeRein
-     *
-     * Gibt den Wert der Variablen reflektorBuchstabeRein zurück
-     *
-     * @return reflektorBuchstabeRein: Character: gibt den Buchstaben zurück
-     */
-    public Character getReflektorBuchstabeRein() {
-        return reflektorBuchstabeRein;
-    }
-
-
-    /**
-     * Setter setReflektorBuchstabeRein
-     *
-     * Setzt den Wert der Variablen reflektorBuchstabeRein
-     *
-     * @param reflektorBuchstabeRein: Character: setzt den Wert des Buchstabens
-     */
-    public void setReflektorBuchstabeRein(Character reflektorBuchstabeRein) {
-        if (Character.isLetter(reflektorBuchstabeRein)){
-            this.reflektorBuchstabeRein = reflektorBuchstabeRein;
-        } else{
-            System.err.println("Kein Buchstabe übergeben im Reflektor");
-        }
-
-    }
-
-}
diff --git a/src/main/java/Enigma/model/Walze.java b/src/main/java/Enigma/model/Walze.java
deleted file mode 100644
index 9ad536e3a3a67ec8f1f75500d4c66799aa893614..0000000000000000000000000000000000000000
--- a/src/main/java/Enigma/model/Walze.java
+++ /dev/null
@@ -1,219 +0,0 @@
-package Enigma.model;
-
-public class Walze {
-
-    private Character buchstabe;
-    private Character ringstellung;
-    private int walzennr;
-    private int iPositionBuchstabe;
-    private int iPositionBuchstabeRe;
-    private Character[] walze;
-
-    /**
-     * Gibt die Parameter der Walze mit
-     *
-     * @param walzennr : int : Nummer der gewaehlten Walze
-     * @param buchstabe : Character : Grundeinstellung der Walze
-     * @param ringstellung : Character : Einstellung des Notch
-     */
-    public Walze(int walzennr, Character buchstabe, Character ringstellung) {
-        this.walze = new Character[25];
-        this.walzennr = walzennr;
-        this.buchstabe = buchstabe;
-        this.ringstellung = ringstellung;
-    }
-
-    /**
-     * @return buchstabe : Character : gibt den neuen Buchstaben zurueck
-     */
-    public Character getBuchstabe() {
-        return buchstabe;
-    }
-
-    /**
-     * Gibt die Grundeinstellung der Walze ein. Nur Buchstaben von A - Z sind zugelassen.
-     * Buchstaben werden automatisch in Grossbuchstaben umgewandelt.
-     * Im Fehlerfall wird die Grundeinstellung der Walze standardmaessig auf 'A' gesetzt.
-     *
-     * @param buchstabe : Character : Grundeinstellung der Walze
-     */
-    public void setBuchstabe(Character buchstabe) {
-
-        if(Character.isLetter(buchstabe)) {
-            this.buchstabe = Character.toUpperCase(buchstabe);
-        } else {
-            this.buchstabe = 'A';
-        }
-    }
-
-    /**
-     * @return ringstellung : Character : gibt die neue Ringstellung zurueck
-     */
-    public Character getRingstellung() {
-        return ringstellung;
-    }
-
-
-    /**
-     * Gibt die Initiale Ringstellung der Walze an.
-     * Es sind nur Zahlen von 1 - 26 zugelassen.
-     * Im Fehlerfall wird die Ringstellung standardmaessig auf '1' gesetzt.
-     *
-     * @param ringstellung : Character : Punkt an dem die Walze umspringt
-     */
-    public void setRingstellung(Character ringstellung) {
-
-        if(Character.isDigit(ringstellung) && ringstellung > 0 && ringstellung <= 26) {
-            this.ringstellung = ringstellung;
-        } else {
-            this.ringstellung = '1';
-        }
-    }
-
-    /**
-     * @return walzennr : int : gibt die Walzennummer zurueck
-     */
-    public int getWalzennr() {
-        return walzennr;
-    }
-
-    /**
-     * Definiert die Walze. Es stehen fuenf Walze zur Auswahl.
-     *
-     * @param walzennr : int : setzt die Walzennummer
-     */
-    public void setWalzennr(int walzennr) {
-        if(walzennr > 0 && walzennr < 6) {
-            this.walzennr = walzennr;
-        } else {
-            System.err.println("Keine gültige Walzennummer");
-        }
-    }
-
-    /**
-     * Sortiert den Walzennummern das passenden Character-Array mittels switch zu.
-     *
-     * @return walze : Character[] : gibt die gewaehlte Walze zurueck
-     */
-    private Character[] walzenNummer() {
-
-        /*Walze nach der Chiffrierung*/
-        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 (getWalzennr()) {
-            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;
-    }
-
-    /**
-     * Ermittelt die Position des Buchstaben auf der Alphabetswalze, um die Position mit
-     * der Chiffrierung auf der gewaehlten Walze abgleichen zu koennen.
-     *
-     * @return iPositionBuchstabe : int : Position des Buchstaben im Array
-     */
-    public int positionBuchstabe() {
-
-        /*Alphabetswalze*/
-        Character[] walzeAlpha = {'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'};
-
-        /*Ermittelt die Position des Buchstaben buchstabe auf der Alphabetswalze*/
-        for(int index = 0; index < walzeAlpha.length; index++) {
-            if(getBuchstabe().equals(walzeAlpha[index])) {
-                iPositionBuchstabe = index;
-                break;
-            }
-        }
-
-        return iPositionBuchstabe;
-    }
-
-
-    /**
-     * Chiffriert den Buchstaben an der Position aus der Methode positionBuchstabe()
-     * anhand der gewaehlten Walze.
-     *
-     * @param iPositionBuchstabe : int : Position des zu chiffrierenden Buchstabens
-     * @param walze : Character[] : ausgewaehlte Walze
-     * @return chiffrierterBuchstabe : Character : chiffrierter Buchstabe
-     */
-    public Character codiereBuchstabe(int iPositionBuchstabe, Character[] walze) {
-        Character codierterBuchstabe = walze[iPositionBuchstabe];
-        return codierterBuchstabe;
-    }
-
-
-    /**
-     * Nimmt die Startposition, die aus der Walzeneinstellung geholt wird und
-     * erhoeht sie um eins.
-     * Die Variable wird ueberschrieben und zaehlt von nun an die Position mit.
-     * Ab Position 25 wird wieder bei 0 angefangen.
-     *
-     * @param iPositionBuchstabe : int : alte Position der Walze
-     * @return iPositionBuchstabe : int : neue Position der Walze
-     */
-    public int vorstellenDerWalze(int iPositionBuchstabe) {
-
-        if(iPositionBuchstabe == 25) {
-            iPositionBuchstabe = 0;
-        } else {
-            iPositionBuchstabe += 1;
-        }
-
-        return iPositionBuchstabe;
-    }
-
-    /**
-     * Ermittelt die Position des Buchstaben auf der gewaehlten Walze, um die Position mit
-     * der Chiffrierung auf der AlphaWalze abgleichen zu koennen.
-     *
-     * @param walzennr : int : gibt die gewaehlte Walze zurueck
-     * @return iPositionBuchstabeRe : int : Position des Buchstaben im Array
-     */
-    public int positionBuchstabeReverse(int walzennr) {
-
-        /*Ermittelt die Position des Buchstaben buchstabe auf der Alphabetswalze*/
-        for(int index = 0; index < walze.length; index++) {
-            if(getBuchstabe().equals(walze[index])) {
-                iPositionBuchstabeRe = index;
-                break;
-            }
-        }
-        return iPositionBuchstabeRe;
-    }
-
-    /**
-     * Chiffriert den Buchstaben an der Position aus der Methode positionBuchstabeReverse()
-     * anhand der AlphaWalze.
-     *
-     * @param iPositionBuchstabeRe : int : Position des zu chiffrierenden Buchstabens
-     * @return codierterBuchstabeRe : Character : chiffrierter Buchstabe
-     */
-    public Character codierterBuchstabeReverse(int iPositionBuchstabeRe) {
-        /*Alphawalze*/
-        Character[] walzeAlpha = {'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'};
-
-        Character codierterBuchstabeRe = walzeAlpha[iPositionBuchstabeRe];
-        return codierterBuchstabeRe;
-    }
-
-}
diff --git a/src/main/java/projekt/enigma/App.java b/src/main/java/projekt/enigma/App.java
new file mode 100644
index 0000000000000000000000000000000000000000..72a9b8a5bb3b6636a3e15044ac516f19eae64eb5
--- /dev/null
+++ b/src/main/java/projekt/enigma/App.java
@@ -0,0 +1,67 @@
+package projekt.enigma;
+
+import projekt.enigma.model.Codierer;
+import javafx.application.Application;
+import javafx.fxml.FXMLLoader;
+import javafx.scene.Parent;
+import javafx.scene.Scene;
+import javafx.stage.Stage;
+import java.io.IOException;
+
+/**
+ * JavaFX App
+ */
+public class App extends Application {
+
+	/**
+	 * TODO Dokumentieren
+	 */
+	private static Scene scene;
+	private Codierer c;
+
+	/**
+	 * TODO Dokumentieren
+	 *
+	 * @param fxml
+	 * @throws IOException
+	 */
+	static void setRoot(String fxml) throws IOException {
+		scene.setRoot(loadFXML(fxml));
+	}
+
+	/**
+	 * TODO Dokumentieren
+	 *
+	 * @param fxml
+	 * @return
+	 * @throws IOException
+	 */
+	private static Parent loadFXML(String fxml) throws IOException {
+		FXMLLoader fxmlLoader = new FXMLLoader(App.class.getResource(fxml + ".fxml"));
+		return fxmlLoader.load();
+	}
+
+	/**
+	 * TODO Dokumentieren
+	 *
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		Application.launch();
+	}
+
+	/**
+	 * TODO Dokumentieren
+	 *
+	 * @param stage
+	 * @throws IOException
+	 */
+	@Override
+	public void start(Stage stage) throws IOException {
+		scene = new Scene(loadFXML("gui"));
+		stage.setScene(scene);
+		stage.setResizable(true);
+		stage.show();
+	}
+
+}
diff --git a/src/main/java/projekt/enigma/GuiController.java b/src/main/java/projekt/enigma/GuiController.java
new file mode 100644
index 0000000000000000000000000000000000000000..d88fdd57956dae55db68d58c67429ce1bd56fd9a
--- /dev/null
+++ b/src/main/java/projekt/enigma/GuiController.java
@@ -0,0 +1,451 @@
+package projekt.enigma;
+
+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 {
+
+    //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.getSteckverbindungen()[0][0] + "" + codierer.getSteckverbindungen()[0][1]);
+        tfStecker2.setText(codierer.getSteckverbindungen()[1][0] + "" + codierer.getSteckverbindungen()[1][1]);
+        tfStecker3.setText(codierer.getSteckverbindungen()[2][0] + "" + codierer.getSteckverbindungen()[2][1]);
+        tfStecker4.setText(codierer.getSteckverbindungen()[3][0] + "" + codierer.getSteckverbindungen()[3][1]);
+        tfStecker5.setText(codierer.getSteckverbindungen()[4][0] + "" + codierer.getSteckverbindungen()[4][1]);
+        tfStecker6.setText(codierer.getSteckverbindungen()[5][0] + "" + codierer.getSteckverbindungen()[5][1]);
+        tfStecker7.setText(codierer.getSteckverbindungen()[6][0] + "" + codierer.getSteckverbindungen()[6][1]);
+        tfStecker8.setText(codierer.getSteckverbindungen()[7][0] + "" + codierer.getSteckverbindungen()[7][1]);
+        tfStecker9.setText(codierer.getSteckverbindungen()[8][0] + "" + codierer.getSteckverbindungen()[8][1]);
+        tfStecker10.setText(codierer.getSteckverbindungen()[9][0] + "" + codierer.getSteckverbindungen()[9][1]);
+    }
+
+    /**
+     * 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.getWalzen()[0]));
+            mBtnStartPos2.setText(String.valueOf(this.codierer.getWalzen()[1]));
+            mBtnStartPos3.setText(String.valueOf(this.codierer.getWalzen()[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.getWalzen()[0]));
+            mBtnStartPos2.setText(String.valueOf(this.codierer.getWalzen()[1]));
+            mBtnStartPos3.setText(String.valueOf(this.codierer.getWalzen()[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.getchWalzenNr()[0]));
+        mBtnWalzPos2.setText(String.valueOf(this.codierer.getchWalzenNr()[1]));
+        mBtnWalzPos3.setText(String.valueOf(this.codierer.getchWalzenNr()[2]));
+        // Position der Walzen anzeigen
+        mBtnStartPos1.setText(String.valueOf(this.codierer.getWalzen()[0]));
+        mBtnStartPos2.setText(String.valueOf(this.codierer.getWalzen()[1]));
+        mBtnStartPos3.setText(String.valueOf(this.codierer.getWalzen()[2]));
+        // Steckbrett Felder setzen
+        tfStecker1.setText(this.codierer.getSteckverbindungen()[0][0] + "" +
+                this.codierer.getSteckverbindungen()[0][1]);
+        tfStecker2.setText(this.codierer.getSteckverbindungen()[1][0] + "" +
+                this.codierer.getSteckverbindungen()[1][1]);
+        tfStecker3.setText(this.codierer.getSteckverbindungen()[2][0] + "" +
+                this.codierer.getSteckverbindungen()[2][1]);
+        tfStecker4.setText(this.codierer.getSteckverbindungen()[3][0] + "" +
+                this.codierer.getSteckverbindungen()[3][1]);
+        tfStecker5.setText(this.codierer.getSteckverbindungen()[4][0] + "" +
+                this.codierer.getSteckverbindungen()[4][1]);
+        tfStecker6.setText(this.codierer.getSteckverbindungen()[5][0] + "" +
+                this.codierer.getSteckverbindungen()[5][1]);
+        tfStecker7.setText(this.codierer.getSteckverbindungen()[6][0] + "" +
+                this.codierer.getSteckverbindungen()[6][1]);
+        tfStecker8.setText(this.codierer.getSteckverbindungen()[7][0] + "" +
+                this.codierer.getSteckverbindungen()[7][1]);
+        tfStecker9.setText(this.codierer.getSteckverbindungen()[8][0] + "" +
+                this.codierer.getSteckverbindungen()[8][1]);
+        tfStecker10.setText(this.codierer.getSteckverbindungen()[9][0] + "" +
+                this.codierer.getSteckverbindungen()[9][1]);
+    }
+    //endregion
+}
diff --git a/src/main/java/Enigma/SecondaryController.java b/src/main/java/projekt/enigma/KenngruppeController.java
similarity index 59%
rename from src/main/java/Enigma/SecondaryController.java
rename to src/main/java/projekt/enigma/KenngruppeController.java
index 360bb06245d64f0367068d81be1f0ab2587ff7f6..3371b0f647ea6f27a72082ae0f18a44b79faf489 100644
--- a/src/main/java/Enigma/SecondaryController.java
+++ b/src/main/java/projekt/enigma/KenngruppeController.java
@@ -1,12 +1,12 @@
-package Enigma;
+package projekt.enigma;
 
 import java.io.IOException;
 import javafx.fxml.FXML;
 
-public class SecondaryController {
+public class KenngruppeController {
 
     @FXML
     private void switchToPrimary() throws IOException {
-        App.setRoot("primary");
+        App.setRoot("gui");
     }
 }
\ No newline at end of file
diff --git a/src/main/java/Enigma/Main.java b/src/main/java/projekt/enigma/Main.java
similarity index 56%
rename from src/main/java/Enigma/Main.java
rename to src/main/java/projekt/enigma/Main.java
index 2bfc594ce53b57275c180938447de3ea3a866f17..f016016d5dd3ebc14cae30918487a14eec35ac8e 100644
--- a/src/main/java/Enigma/Main.java
+++ b/src/main/java/projekt/enigma/Main.java
@@ -1,8 +1,5 @@
-package Enigma;
+package projekt.enigma;
 
-import Enigma.model.Codebuch;
-import Enigma.model.DatenbankSqlite;
-import Enigma.model.Morsecode;
 
 import java.sql.SQLException;
 
diff --git a/src/main/java/Enigma/model/DatenbankSqlite.java b/src/main/java/projekt/enigma/database/DatenbankSqlite.java
similarity index 60%
rename from src/main/java/Enigma/model/DatenbankSqlite.java
rename to src/main/java/projekt/enigma/database/DatenbankSqlite.java
index 891c011a036f01b038400dbb808d65c11a0b8f43..ac7c9024be694baff54f6573ac70dc695fc45081 100644
--- a/src/main/java/Enigma/model/DatenbankSqlite.java
+++ b/src/main/java/projekt/enigma/database/DatenbankSqlite.java
@@ -1,8 +1,6 @@
-package Enigma.model;
+package projekt.enigma.database;
 
-import javax.swing.text.html.HTML;
 import java.sql.*;
-import java.util.Random;
 
 /**
  * Dies ist die SQLite Datenbank Klasse
@@ -24,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 {
@@ -42,36 +40,48 @@ public class DatenbankSqlite {
 	 * Anschließend wir eine Verbindung zur SQLite Datenbank aufgebaut und das Codebuch angefragt.
 	 * Dieses wird in ein Object vom Type Codebuch gepackt und zurück gegeben.
 	 *
+	 * Hole den heutigen Eintrag aus der SQLite Datenbank und erstelle daraus ein Codebuch Objekt
+	 *
 	 * @param tag : int : Tag für welchen ein Codebuch benötigt wird.
-	 * @return Codebuch : Codebuch Object mit dem Codebuch des angefragten Tages
+	 * @return String : Die Einstellungen des angefragten Tages
+	 * <p>
+	 *     String[0] : Tag
+	 *     String[1] : Walzenlage
+	 *     String[2] : Ringstellung
+	 *     String[3] : Steckverbindung
+	 * </p>
 	 */
-	public Codebuch getCodebuch(int tag) throws SQLException {
-		Codebuch cb = new Codebuch();
-
-		Connection conn = this.connect();
-		PreparedStatement pstm = conn.prepareStatement("SELECT * FROM table_codebuch WHERE Tag=? LIMIT 1");
-		pstm.setInt(1, tag);
-		ResultSet rs = pstm.executeQuery();
-
-		while (rs.next()) {
-			cb.setTag(rs.getInt("Tag"));
-			cb.setWalzenlage(rs.getString("Walzenlage").split(","));
-			cb.setRingstellung(rs.getString("Ringstellung").split(","));
-			cb.setSteckverbindung(rs.getString("Steckverbindung").split(","));
+	public String[] getCodebuch(int tag) {
+
+		String[] codebuch = new String[4];
+
+		try {
+			Connection conn = this.connect();
+			PreparedStatement pstm = conn.prepareStatement("SELECT * FROM table_codebuch WHERE Tag=? LIMIT 1");
+			pstm.setInt(1, tag);
+			ResultSet rs = pstm.executeQuery();
+
+			while (rs.next()) {
+				codebuch[0] = rs.getString("Tag");
+				codebuch[1] = rs.getString("Walzenlage");
+				codebuch[2] = rs.getString("Ringstellung");
+				codebuch[3] = rs.getString("Steckverbindung");
+			}
+		} catch (SQLException ignored) {
 		}
 
-		return cb;
+		return codebuch;
 	}
 
 	//region Random New Codebuch generieren
-	/*
-	*//**
+	/**
 	 * Setzt zufällige Codebuch Einträge in die SQLite Datenbank
 	 * Tag => int
 	 * Walzenlage => String w1,w2,w3
 	 * Ringstellung => String r1,r2,r3
 	 * Steckverbindungen => s0,s1,s2,s3,s4,s5,s6,s7,s8,s9
-	 *//*
+	 */
+	/*
 	public void autoGenCodebuch() throws SQLException {
 
 		Connection conn = connect();
@@ -88,11 +98,12 @@ public class DatenbankSqlite {
 		conn.commit();
 	}
 
-	*//**
+	/**
 	 * Generiert einen String aus 3 Zufalls-Zahlen(zwischen 1 und 5)
 	 * die Zahlen sind durch Komma getrennt
 	 * @return String => walzenlage mit drei Kommaseparierten Zufallszahlen zwischen 1 und 5
-	 *//*
+	 */
+	/*
 	private static String walzenlage(){
 		String walzenlage;
 		Random random = new Random();
@@ -105,13 +116,14 @@ public class DatenbankSqlite {
 		}
 		walzenlage= w[0]+","+w[1]+","+w[2];
 		return walzenlage;
-	}
+	}*/
 
-	*//**
+	/**
 	 * Generiert einen String aus 3 Zufalls-Zahlen(zwischen 1 und 26)
 	 * die Zahlen sind durch Komma getrennt
 	 * @return String => ringstellung mit drei Kommaseparierten Zufallszahlen zwischen 1 und 26
-	 *//*
+	 */
+	/*
 	private static String ringstellung(){
 		String ringstellung;
 		Random random = new Random();
@@ -121,30 +133,35 @@ public class DatenbankSqlite {
 		}
 		ringstellung= w[0]+","+w[1]+","+w[2];
 		return ringstellung;
-	}
+	}*/
 
-	*//**
+	/**
 	 * Generiert einen String aus 10 * 2 unterschiedlichen Großbuchstaben
-	 * @return  String => 10 Buchstabenkombinationen mit Komma getrennt
+	 * @return String => 10 Buchstabenkombinationen mit Komma getrennt
 	 *//*
-	private static String steckverbindung(){
-		Random rnd = new Random();
-		String steckverbindung="";
-		char[] c = new char[2];
-		for (int i = 0; i < 10; i++) {
-			for (int j = 0; j < 2; j++) {
-				c[j]= (char) (rnd.nextInt(26) + 'A');
-				if (j==1) {
-					while (c[0] == c[j]) {
-						c[j] = (char) (rnd.nextInt(26) + 'A');
-					}
-				}
-			}
-			System.out.println(c[0]+" / "+c[1]);
-			steckverbindung+= ((""+c[0]) + (""+c[1]) +",");
-		}
-		steckverbindung= (String) steckverbindung.subSequence(0,steckverbindung.lastIndexOf(","));
-		return steckverbindung;
-	}*/
+	    private static String steckverbindung(){
+        Random rnd = new Random();
+        String steckverbindung="";
+
+
+        char[] c = new char[20];
+        for (int i = 0; i < 20; i++) {
+            c[i] = (char) (rnd.nextInt(26) + 'A');
+            for (int j = i; j >= 0; j--) {
+                if (i>j) {
+                    while (c[i]==c[j]) {
+                        c[i] = (char) (rnd.nextInt(26) + 'A');
+                        j= i-1;
+                    }
+                }
+            }
+        }
+        steckverbindung = ((""+c[0]) + (""+c[1]) +"," +(""+c[2]) +(""+c[3]) + ","+(""+c[4]) +(""+c[5]) + ","+(""+c[6]) +(""+c[7]) + ","
+                +(""+c[8]) +(""+c[9]) + ","+(""+c[10]) +(""+c[11]) + ","+(""+c[12]) +(""+c[13]) + ","+(""+c[14]) +(""+c[15]) + ","+(""+c[16]) +(""+c[17]) + ","
+                +(""+c[18]) +(""+c[19]));
+       // System.out.println(steckverbindung);
+       // steckverbindung= (String) steckverbindung.subSequence(0,steckverbindung.lastIndexOf(","));
+        return steckverbindung;
+    }*/
 	//endregion
 }
diff --git a/src/main/java/projekt/enigma/model/Codebuch.java b/src/main/java/projekt/enigma/model/Codebuch.java
new file mode 100644
index 0000000000000000000000000000000000000000..9ded525e6d41617d76f148556b5c8f278bb88a63
--- /dev/null
+++ b/src/main/java/projekt/enigma/model/Codebuch.java
@@ -0,0 +1,229 @@
+package projekt.enigma.model;
+
+import projekt.enigma.database.DatenbankSqlite;
+
+import java.time.LocalDate;
+import java.time.ZoneId;
+
+/**
+ * Das Codebuch war eines der essentiel wichtigen Sachen bei der Enigma.
+ * Jeder Enigma gehörte auch ein Codebuch bei, welches notwendig war um die Nachrichten zu ver/entschlüsseln.
+ * Im Codebuch standen für jeden Tag des Monats die notwendigen Einstellungen welche vorgenommen werden
+ * mussten um die Texte zu ver/entschlüsseln.
+ * Hiernach wurden die Walzen eingesetzt, die Ringe für den Rücksprung der Walze gesetzt und deren Grundeinstellung
+ * vorgenommen.
+ * Bei der Enigma um welche es hier geht (Enigma I) gab es zusätzlich ein Steckbrett, welches ebenfalls im Codebuch
+ * festgelegt war.
+ * <p>
+ * Dieses Codebuch Objekt enthält die Einstellungen eines Tages, welche mittels Getter und Setter
+ * verarbeitet werden können.
+ * <p>
+ * Zusätzlich gibt es zu Debug Zwecken eine überschriebene toString Funktion welche das Objekt als String zurück
+ * geben kann.
+ */
+public class Codebuch {
+
+	/**
+	 * TODO: Dokumentieren tag
+	 * tag : int : gibt den Tag an
+	 */
+	private int tag;
+
+	/**
+	 * walzenlage : int[] : legt die Positionen der Walzen fest
+	 */
+	private int[] walzenlage;
+
+	/**
+	 * ringstellung : int[] : TODO ringstellung: char || int ?
+	 */
+	private int[] ringstellung;
+
+	/**
+	 * steckverbindung : char[][] : stellt die Steckverbindungen im Steckbrett dar
+	 */
+	private char[][] steckverbindung;
+
+	/**
+	 * Im Konstruktor werden die Standardwerte gesetzt
+	 * <p>
+	 * walzenlage : int[3] :            Hier wird die Position der drei Walzen festgelegt.
+	 * ringstellung : char[3] :         Jede Walze hat einen Ring. Der Index steht für die Walze und der Value für
+	 * die Position des Ringes.
+	 * steckverbindung : char[10][] :   Zehn Kabel können in das Steckbrett gesteckt werden. In diesem Array werden
+	 * 									die Kabel mit ihren jeweiligen Buchsen hinterlegt.
+	 */
+	public Codebuch() {
+		this.walzenlage = new int[3];
+		this.ringstellung = new int[3];
+		this.steckverbindung = new char[10][];
+
+		for (int i = 0; i < 10; i++) {
+			this.steckverbindung[i] = new char[2];
+			this.steckverbindung[i][0] = 'A';
+			this.steckverbindung[i][1] = 'A';
+		}
+	}
+
+	/**
+	 * TODO: Dokumentieren
+	 * Holt den Tagesschluessel aus dem Codebuch ab. Ist kein Tag angegeben, wird der aktuelle Tag genutzt.
+	 * Aus dem Tagesschluessel werden die Werte fuer die Walzenlage, Ringstellung und Steckverbindung
+	 * gesetzt.
+	 *
+	 * @param tag : int[] : gibt einen Tag oder mehrere Tage mit
+	 */
+	public void fetchTagesschluessel(int... tag) {
+		String[] walzenlage, ringstellung, db;
+
+		if (tag.length > 0) {
+			db = new DatenbankSqlite().getCodebuch(tag[0]);
+		} else {
+			db = new DatenbankSqlite().getCodebuch(LocalDate.now(ZoneId.of("Europe/Berlin")).getDayOfMonth());
+		}
+
+		this.setTag(Integer.parseInt(db[0]));
+
+		walzenlage = db[1].split(",");
+		for (int i = 0; i < 3; i++) {
+			this.setWalzenlage(i, Integer.parseInt(walzenlage[i]));
+		}
+
+		ringstellung = db[2].split(",");
+		for (int i = 0; i < 3; i++) {
+			this.setRingstellung(i, Integer.parseInt(ringstellung[i]));
+		}
+
+		this.setSteckverbindung(db[3].split(","));
+
+	}
+
+	/**
+	 * Gibt die aktuelle Instanz des Codebuches als String zurück.
+	 * Hierbei werden der Tag die Walzenlagen, Ring-/Grundstellung sowie die Steckverbindungen zurück gegeben.
+	 *
+	 * @return String : String des gesamten Objektes
+	 */
+	@Override
+	public String toString() {
+		StringBuilder sb = new StringBuilder();
+
+		// Tag des aktuellen Codebuch Eintrags
+		sb.append("Tag: ").append(this.getTag()).append("\n");
+
+		// In welchem Slot steckt die Walze?
+		sb.append("Walzenlage: ");
+		for (int wl : this.getWalzenlage()) {
+			sb.append(wl).append(",");
+		}
+		if (this.getWalzenlage().length > 0) {
+			sb.setLength(sb.length() - 1);
+		}
+		sb.append("\n");
+
+		// Die Ringstellung an den Walzen
+		sb.append("Ringstellung: ");
+		for (int rs : this.getRingstellung()) {
+			sb.append(rs).append(",");
+		}
+		if (this.getRingstellung().length > 0) {
+			sb.setLength(sb.length() - 1);
+		}
+		sb.append("\n");
+
+		// Das Steckbrett und wie die Kabel angeschlossen sind
+		sb.append("Steckverbindung: ");
+		for (char[] verbindung : this.getSteckverbindung()) {
+			sb.append(verbindung[0]).append(":").append(verbindung[1]).append(",");
+		}
+		if (this.getSteckverbindung().length > 0) {
+			sb.setLength(sb.length() - 1);
+		}
+		sb.append("\n");
+
+		return sb.toString();
+	}
+
+	/**
+	 * Gibt den Tag dieser Instanz zurück
+	 *
+	 * @return int : Tag
+	 */
+	public int getTag() {
+		return tag;
+	}
+
+	/**
+	 * Setzt den Tag dieser Instanz
+	 *
+	 * @param tag : int : Tag
+	 */
+	void setTag(int tag) { this.tag = tag; }
+
+	/**
+	 * Gibt die Walzenlage dieser Instanz zurück
+	 *
+	 * @return String[] : Walzenlage TODO: String[] || int[]?
+	 */
+	public int[] getWalzenlage() {
+		return walzenlage;
+	}
+
+	/**
+	 * Gibt die Ringstellung dieser Instanz zurück
+	 *
+	 * @return String[] : Ringstellung TODO: String[] || int[]?
+	 */
+	public int[] getRingstellung() {
+		return ringstellung;
+	}
+
+	/**
+	 * Gibt die Steckverbindung dieser Instanz zurück
+	 *
+	 * @return String[] : Steckverbindung
+	 */
+	// TODO
+	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;
+	}
+}
diff --git a/src/main/java/projekt/enigma/model/Codierer.java b/src/main/java/projekt/enigma/model/Codierer.java
new file mode 100644
index 0000000000000000000000000000000000000000..724cb462b9b6034bd2544aed4bd3446ebb7b1d0d
--- /dev/null
+++ b/src/main/java/projekt/enigma/model/Codierer.java
@@ -0,0 +1,476 @@
+package projekt.enigma.model;
+
+import org.apache.http.HttpException;
+
+import java.io.IOException;
+import java.util.Calendar;
+import java.util.Random;
+
+/**
+ * Die Codierer Klasse beschreibt den Benutzer welcher die Enigma benutzt.
+ * Alle Vorgänge wie z.B. das zusammenbauen der Hardware, auslesen des Codebuches und das anschließende codieren,
+ * finden hier statt. Dieser ist quasi die Schnittstelle zwischen der GUI (Hauptmann welcher ihm sagt was er zu
+ * verschlüsseln hat), der Enigma und dem Funker im Funkraum, welcher die Nachricht im Anschluß versendet.
+ */
+public class Codierer {
+
+	/**
+	 * Der Klartext Spruchschlüssel zur codierung der Nachricht
+	 */
+	private String spruchschluessel;
+	/**
+	 * Der Spruchschlüssel, mit den Tageswerten aus dem Codebuch, codiert
+	 */
+	private String spruchschluesselCodiert;
+	/**
+	 * Die Kenngruppe für die versendeten Nachrichten gedacht sind. Diese ist relevant für den Webservice (Funkraum)
+	 */
+	private String kenngruppe;
+	/**
+	 * Die Nachricht, welche der Benutzer eingibt, wird als String nachricht gespeichert
+	 * und im laufe der Benutzung ergänzt
+	 */
+	private String nachricht;
+	/**
+	 * Das Hardware Objekt. Hier werden alle Hardware relevanten Baugruppen gespeichert und verarbeitet.
+	 */
+	private Hardware hardware;
+	/**
+	 * Im Codebuch sind die Tageswerte zu finden. Über dieses Objekt kann darauf zugegriffen werden.
+	 */
+	private Codebuch codebuch;
+	/**
+	 * Der aktuelle Tagesschluessel. Dieser wird aus dem Codebuch ausgelesen und hier hinterlegt.
+	 */
+	private String tagesSchluessel;
+
+	/**
+	 * Der Konstruktor des Codierers
+	 * Hier werden die globalen Variablen auf ihre Standart Werte gesetzt sowie die Objekte Initialisiert.
+	 */
+	public Codierer() {
+
+		this.nachricht = "";
+		this.spruchschluessel = "";
+		this.spruchschluesselCodiert = "";
+		this.kenngruppe = "";
+		this.codebuch = new Codebuch();
+		this.codebuch.fetchTagesschluessel();
+	}
+
+	/**
+	 * Hier lesen wir den heutigen Eintrag aus dem Codebuch aus und erstellen ein Codebuch Objekt
+	 * Nach dem Codebuch werden dann die Ringe auf die Walzen gesteckt und die Walzen anschließend
+	 * in die Hardware gebaut.
+	 * <br>
+	 * Ein Reflektor wird definiert, jedoch keine Werte zugewisen, da wir nur einen besitzen und
+	 * deshalb alle Einstellungen hierfür Statisch im Reflektor definiert haben.
+	 * <br>
+	 * Das Steck wird ebenfalls definiert und die notwendigen Kabel eingesteckt laut dem heutigen
+	 * Codebuch Eintrag.
+	 */
+	private void initialisiereHardware() {
+
+		// Das Steckbrett initialisieren
+		Steckbrett sb = new Steckbrett();
+		char[][] verbinder = this.codebuch.getSteckverbindung();
+
+		// Für jedes Kabel eine Verbindung auf dem Steckbrett setzen
+		for (char[] kabel : verbinder) {
+			sb.setzeVertauschung(kabel[0], kabel[1]);
+		}
+
+		// Die Hardware aus dem Koffer holen (initialisieren)
+		this.hardware = new Hardware();
+
+		// Den Ring an der Walze anbringen und die Walze dann in die Hardware einsetzen
+		this.hardware.setWalzen(0, this.codebuch.getWalzenlage()[0], this.codebuch.getRingstellung()[0]);
+		this.hardware.setWalzen(1, this.codebuch.getWalzenlage()[1], this.codebuch.getRingstellung()[1]);
+		this.hardware.setWalzen(2, this.codebuch.getWalzenlage()[2], this.codebuch.getRingstellung()[2]);
+
+		// Der Hardware das gesetzte Steckbrett zuweisen
+		this.hardware.setSteckbrett(sb);
+
+		// Ein Reflektor Objekt erstellen und der Hardware bekannt geben
+		this.hardware.setReflektor(new Reflektor());
+
+	}
+
+	/**
+	 * Hier wird ein neuer Spruchschlüssel generiert.
+	 * <p>
+	 * Mit diesem werden die Walzen auf eine neue Startposition gestellt und dem Kopf, mit dem
+	 * Tagesschlüssel codiert, hinzugefügt.
+	 * <br>
+	 * Hierfür wird mittels der Funktion "randomBuchstabe" ein zufälliger Buchstabe generiert,
+	 * und geschaut ob dieser bereits in der globalen Variable (this.spruchschluessel) vorhanden ist.
+	 * Wenn nicht, wird der Buchstabe dem Spruchschlüssel hinzugefügt.
+	 * <br>
+	 * Dies wir nun so lange gemacht bis der Spruchschlüssel eine länge von drei Zeichen hat.
+	 */
+	public void generateSpruchschluessel() {
+
+		String klartext = "";
+
+		while (klartext.length() < 3) {
+			String temp = this.randomBuchstabe();
+			if (!klartext.contains(temp)) {
+				klartext += temp;
+			}
+		}
+
+		this.spruchschluessel = klartext;
+		this.spruchschluesselCodiert = this.codiere(klartext + klartext, false);
+
+		// Walzen auf den Spruchschlüssel stellen
+		this.hardware.setzePosition(0, this.spruchschluessel.charAt(0));
+		this.hardware.setzePosition(1, this.spruchschluessel.charAt(1));
+		this.hardware.setzePosition(2, this.spruchschluessel.charAt(2));
+
+		// Die Kenngruppe codieren und in der Nachricht speichern
+		this.codiere(this.kenngruppe, true);
+	}
+
+	/**
+	 * Der Spruchschlüssel wird, zur internen Verwendung, auch im Klartext gespeichert.
+	 * Wir brauchen diesen dann zum codieren der eigentlichen Nachricht.
+	 *
+	 * @return String : Der klartext Spruchschlüssel
+	 */
+	public String getSpruchschluessel() {
+		return this.spruchschluessel;
+	}
+
+	/**
+	 * Erstellen des Nachrichten Kopfes.
+	 * Hierfür wird die aktuelle Uhrzeit ausgelesen, die Länge der Nachricht sowie der, mit den
+	 * Tagescodes codierte, Spruchschlüssel.
+	 */
+	private String generateKopf() {
+		Calendar cal = Calendar.getInstance();
+
+		// Uhrzeit an den Kopf hängen
+		return String.format("%02d%02d", cal.get(Calendar.HOUR), cal.get(Calendar.MINUTE)) + " " +
+
+				// Zeichen Anzahl der Nachricht
+				this.nachricht.length() + " " +
+
+				// Spruchschlüssel anhängen
+				this.spruchschluesselCodiert.substring(0, 3) + " " + this.spruchschluesselCodiert.substring(3, 6) + " ";
+	}
+
+	/**
+	 * Einen zufälligen Buchstaben aus dem Alphabet generieren.
+	 * In der Funktion gibt es den String Alphabet, in welchem alle zulässigen Zeichen eingetragen sind.
+	 * Aus diesem String wird nun zufällig ein Zeichen ausgewählt und zurück gegeben.
+	 *
+	 * @return String : ein zufällig generierter Buchstabe
+	 */
+	private String randomBuchstabe() {
+		return String.valueOf((char) ('A' + new Random().nextInt(26)));
+	}
+
+	/**
+	 * Befehl die Nachricht an den Funker zu übergeben
+	 *
+	 * @throws IOException   : Die Antwort konnte nicht gelesen werden
+	 * @throws HttpException : Die Nachricht konnte nicht abgesendet werden
+	 */
+	public void sendeNachricht() throws IOException, HttpException {
+		String kopf = this.generateKopf();
+		new Funkraum().sendeFunkspruch(new Morsecode().convertBuchstabeToMorsecode(kopf + this.nachricht), this.kenngruppe);
+		this.nachricht = "";
+	}
+
+	/**
+	 * Gibt die letzte empfangene Nachricht zurück
+	 * <br>
+	 * String[0] Tag wann die Nachricht gesendet wurde
+	 * String[1] = Die verschlüsselte Nachricht
+	 * String[2] = Nachricht im Klartext
+	 */
+	public String[] empfangeNachricht() {
+
+		this.nachricht = "";
+		Morsecode mc = new Morsecode();
+		String[] nachricht = new String[4];
+		String[] codierteNachricht = new Funkraum().empfangeFunkspruch(this.kenngruppe);
+
+		if (codierteNachricht.length > 1 && codierteNachricht[1].split(" ").length > 3) {
+			nachricht[0] = codierteNachricht[0];
+			nachricht[1] = mc.convertMorsecodeToBuchstabe(codierteNachricht[1]);
+			nachricht[2] = this.decodiere(nachricht[1], Integer.parseInt(nachricht[0]));
+			StringBuilder sb = new StringBuilder();
+
+			sb.append(nachricht[1], 0, 16);
+			for (int i = 17; i <= nachricht[1].length(); ) {
+				if ((i + 5) < nachricht[1].length()) {
+					sb.append(nachricht[1], i, i + 5).append(" ");
+					i += 5;
+				} else {
+					sb.append(nachricht[1].substring(i));
+					break;
+				}
+			}
+			nachricht[1] = sb.toString();
+		} else {
+			nachricht[0] = "";
+			nachricht[1] = "";
+			nachricht[2] = "Es liegen keine neuen Nachrichten im Funkraum für Sie vor.";
+		}
+
+		return nachricht;
+	}
+
+	/**
+	 * Liest die Kenngruppe aus welche die Maschine gerade besitzt. Früher war dies eine eindeutige Nummer
+	 * die einer Einheit zugewiesen war. Wir hinterlegen hier einen Benutzernamen.
+	 *
+	 * @return String : Kenngruppe
+	 */
+	public String getKenngruppe() {
+		return kenngruppe;
+	}
+
+	/**
+	 * Setzt die Kenngruppe welche die Enigma gerade benutzt.
+	 *
+	 * @param kenngruppe : String : Kenngruppe welche die Enigma gerade benutzt
+	 */
+	public void setKenngruppe(String kenngruppe) {
+
+		this.kenngruppe = kenngruppe;
+		this.initialisiereHardware();
+
+	}
+
+	/**
+	 * Gibt die bisher erstellte Nachricht zurück
+	 *
+	 * @return String : Erstellte Nachricht
+	 */
+	public String getNachricht() {
+		return nachricht;
+	}
+
+	/**
+	 * Gibt die aktuellen Buchstaben auf den Walzen zurück
+	 *
+	 * @return char[] : Walzen Array mit der aktuellen Position
+	 */
+	public char[] getWalzen() {
+		char[] walzen = new char[3];
+		walzen[0] = this.hardware.getWalzen()[0].getPosition();
+		walzen[1] = this.hardware.getWalzen()[1].getPosition();
+		walzen[2] = this.hardware.getWalzen()[2].getPosition();
+
+		return walzen;
+	}
+
+	/**
+	 * Hier wird ein einzelner Buchstabe verschlüsselt.
+	 * Man muss hier ebenfalls mitgeben ob der codierte String in Codierer.nachricht gespeichert werden soll oder nicht.
+	 * In der Regel ist dies der Fall.
+	 *
+	 * @param buchstabe : char : Der zu codierende Buchstabe
+	 * @param save      : boolean : Nachricht speichern oder nicht
+	 * @return char     : Der codierte Buchstabe
+	 */
+	public char codiere(char buchstabe, boolean save) {
+		char codiert = this.hardware.codiere(buchstabe);
+		if (save) {
+			this.nachricht += codiert;
+		}
+
+		return codiert;
+	}
+
+	/**
+	 * Codiert den Übergebenen String.
+	 * Man muss hier ebenfalls mitgeben ob der codierte String in Codierer.nachricht gespeichert werden soll oder nicht.
+	 * In der Regel ist dies der Fall.
+	 *
+	 * @param klartext : String : Der zu codierende Text
+	 * @param save     : boolean : Nachricht speichern oder nicht
+	 * @return String : Der codierte Text zusätzlich als Rückgabe
+	 */
+	public String codiere(String klartext, boolean save) {
+
+		StringBuilder sb = new StringBuilder();
+
+		for (char buchstabe : klartext.toCharArray()) {
+			sb.append(this.codiere(buchstabe, save));
+		}
+
+		return sb.toString();
+	}
+
+	/**
+	 * Diese Funktion erwartet als (codierteNachricht) eine korrekte Enigma Nachricht.
+	 * Ihr muss auch der Tag der codierung mitgegeben werden. Dieser weiß dein Funker im Funkraum.
+	 * In der Regel ist dies der Tag des Nachrichten empfangs.
+	 *
+	 * @param codierteNachricht : String : Enigma codierte Nachricht
+	 * @param tag               : int : Tag der Nachricht
+	 * @return String : decodierte Nachricht
+	 */
+	private String decodiere(String codierteNachricht, int tag) {
+
+		// Hardware reseten und Tageseinstellungen aus dem Codebuch laden
+		this.initialisiereHardware();
+		this.codebuch.fetchTagesschluessel(tag);
+
+		String[] nachricht = codierteNachricht.split(" ");
+		StringBuilder sb = new StringBuilder();
+
+		// Uhrzeit
+		sb.append(nachricht[0]).append(" ");
+
+		// Zeichen Anzahl der Nachricht
+		sb.append(nachricht[1]).append(" ");
+
+		// Spruchschlüssel
+		String spruchschluessel = this.decodiereString(nachricht[2]);
+		sb.append(spruchschluessel).append(" ");
+		sb.append(this.decodiereString(nachricht[3])).append(" ");
+
+		// Walzen neu einstellen mit dem Spruchschlüssel
+		this.hardware.setzePosition(0, spruchschluessel.charAt(0));
+		this.hardware.setzePosition(1, spruchschluessel.charAt(1));
+		this.hardware.setzePosition(2, spruchschluessel.charAt(2));
+
+		// Nachricht decodieren
+		sb.append(this.decodiereString(nachricht[4]));
+
+		return sb.toString();
+	}
+
+	/**
+	 * Zerlegt den übergebenen String in einen char Array und decodiert jedes Zeichen.
+	 * Der String wird dann decodiert zurück gegeben.
+	 *
+	 * @param nachricht : String : Der zu decodierende Text
+	 * @return String : Der decodierte Text
+	 */
+	private String decodiereString(String nachricht) {
+
+		StringBuilder sb = new StringBuilder();
+
+		for (char buchstabe : nachricht.toCharArray()) {
+			if (buchstabe > 0) {
+				sb.append(this.hardware.codiere(buchstabe));
+			}
+		}
+
+		return sb.toString();
+	}
+
+	/**
+	 * Setzt die Enigma auf die Einstellungen des aktuellen Tages, aus dem Codebuch zurück.
+	 */
+	public void resetHardware() {
+		this.initialisiereHardware();
+	}
+
+	/**
+	 * Setzt den anzuzeigenden Buchstaben (buchstabe) auf der Walze (wlazenPosition)
+	 * TODO: Wenn die Walzen, Notches, Kabel, etc. verändert werden, muss die bisherige Nachricht (this.nachricht) gelöscht werden.
+	 *
+	 * @param walzenPosition : int : Nummer der Walze
+	 * @param buchstabe      : char : Buchstabe der zugewiesen soll
+	 */
+	public void setWalze(int walzenPosition, char buchstabe) {
+		this.hardware.setzePosition(walzenPosition, buchstabe);
+	}
+
+	/**
+	 * Setzt den Ring auf der Walze auf einen neuen Umstprungwert.
+	 *
+	 * @param walzenPosition : int : Walze auf die der Ring gesteckt wird
+	 * @param umsprungPunkt  : int : Buchstabe auf dem der Notch sitzt
+	 */
+	public void setRing(int walzenPosition, int umsprungPunkt) {
+		this.hardware.setzeRing(walzenPosition, umsprungPunkt);
+	}
+
+	/**
+	 * Setzt die Walze (walzeNr) in die Position (walzenPosition) der Enigma ein.
+	 * Mit (ringstellung) gibt man die Position des Umsprungpunktes an.
+	 *
+	 * @param walzenPosition : int : Position der Walze in der Enigma (1-2-3)
+	 * @param walzeNr        : int : Nummer der Walze die eingesetzt wird
+	 * @param ringstellung   : int : Stellung des Ringes
+	 */
+	public void setWalzeNr(int walzenPosition, int walzeNr, int ringstellung) {
+		this.hardware.setzeWalzenNr(walzenPosition, walzeNr, ringstellung);
+	}
+
+	/**
+	 * Setzt das Kabel in beide Ports ein und fügt es dem Steckbrett Array hinzu.
+	 *
+	 * @param port       : int : Kabel Nummer welches am Steckbrett eingesteckt wird
+	 * @param verbindung : String : Verbindung welche die vertauschten Buchstaben angibt
+	 * @return boolean : Wenn true, darf das Kabel gesteckt werden, wenn nicht, steckt da bereits schon eines
+	 */
+	public boolean setSteckbrett(int port, String verbindung) {
+		return this.hardware.getSteckbrett().setzeVertauschung(port, verbindung.charAt(0), verbindung.charAt(1));
+	}
+
+	/**
+	 * Prüft ob der Port auf den das Kabel gesteckt werden soll, noch frei ist.
+	 * <p>
+	 * setSteckbrett ausführen mit beiden Buchstaben als String
+	 *
+	 * @param buchstabe : char : Der zuletzt eingegebene Buchstabe
+	 * @return boolean : Wenn der Buchstabe nicht vorhanden ist, wird true zurückgegeben, ansonsten false
+	 */
+	public boolean pruefeSteckbrettPort(char buchstabe) {
+		return this.hardware.getSteckbrett().ueberpruefeVertauschungen(buchstabe);
+	}
+
+	/**
+	 * Ließt aus der empfangenen Nachricht den Spruchschlüssel aus und gibt ihn zurück.
+	 *
+	 * @param empfangeneNachricht : String : Die empfangene Nachricht als String
+	 * @return String : Der Spruchschlüssel mit welcher die Nachricht codiert wurde.
+	 */
+	public String empfangenerSpruchschluessel(String empfangeneNachricht) {
+		String[] nachricht = empfangeneNachricht.split(" ");
+
+		return nachricht[2];
+	}
+
+	/**
+	 * Gibt die Ringstellungen aus dem Codebuch zurück
+	 *
+	 * @return int[] : Array mit den Ringstellungen der drei eingesetzten Walzen
+	 */
+	public int[] fetchRingstellung() {
+		return this.codebuch.getRingstellung();
+	}
+
+	/**
+	 * Gibt die Walzennummer aus dem Codebuch zurück
+	 *
+	 * @return int[] : Array mit den Nummern der drei eingesetzten Walzen
+	 */
+	public int[] getchWalzenNr() {
+		return this.codebuch.getWalzenlage();
+	}
+
+	/**
+	 * Gibt die Steckverbindungen aus dem Codebuch zurück
+	 *
+	 * @return char[][] : Array mit den gesteckten Verbindungen im Steckbrett
+	 */
+	public char[][] getSteckverbindungen() {
+		return this.codebuch.getSteckverbindung();
+	}
+
+	/**
+	 * Löscht das letzte Zeichen aus der Nachricht und dreht die Walzen eine Position zurück.
+	 */
+	public void letztesZeichenLoeschen() {
+		this.hardware.dreheWalzen(-1);
+	}
+}
diff --git a/src/main/java/Enigma/model/Funkraum.java b/src/main/java/projekt/enigma/model/Funkraum.java
similarity index 62%
rename from src/main/java/Enigma/model/Funkraum.java
rename to src/main/java/projekt/enigma/model/Funkraum.java
index de283e750d219646a8fbca82f81626a4b94dff0d..96a3a35b3fa9391afad8d5193ff4923bb368c391 100644
--- a/src/main/java/Enigma/model/Funkraum.java
+++ b/src/main/java/projekt/enigma/model/Funkraum.java
@@ -1,4 +1,4 @@
-package Enigma.model;
+package projekt.enigma.model;
 
 import org.apache.http.HttpEntity;
 import org.apache.http.HttpException;
@@ -10,6 +10,7 @@ import org.apache.http.client.methods.HttpPost;
 import org.apache.http.impl.client.HttpClients;
 import org.apache.http.message.BasicNameValuePair;
 import org.json.JSONObject;
+
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
@@ -25,39 +26,46 @@ import java.util.List;
  * (Benutzername) übergeben und falls eine Nachricht gesendet werden soll, zusätzlich ein m mit der Nachricht.
  * Beides wird als String gesendet.
  */
-public class Funkraum {
+class Funkraum {
 	/**
 	 * Zum Empfangen liefert der Server, anstatt der Kenngruppe (k) den Empfangstag der Nachricht mit damit man
-	 *  die Grundeinstellungen aus dem Codebuch, für diesen Tag, raussuchen kann.
-	 *  {'m': 'Hello world', 't': '26'}
+	 * die Grundeinstellungen aus dem Codebuch, für diesen Tag, raussuchen kann.
+	 * {'m': 'Hello world', 't': '26'}
 	 *
 	 * @param kenngruppe : String : Kenngruppe dieser Engiam
 	 * @return String[] : String Array wobei Index 0 dem Empfangstag entspricht und index 1 der empfangenen Nachricht
-	 * @throws IOException : Exception :  wenn keine Verbindung zum Funker aufgebaut werden konnte.
 	 */
-	public String[] empfangeFunkspruch(String kenngruppe) throws IOException {
+	String[] empfangeFunkspruch(String kenngruppe) {
+
 		String[] funkspruch = new String[2];
 
 		HttpClient httpclient = HttpClients.createDefault();
 		HttpPost httppost = new HttpPost("https://enigma.itstall.de/");
 
-		// Anfrage Parameter und Encoding setzen
-		List<NameValuePair> params = new ArrayList<>(2);
-		params.add(new BasicNameValuePair("k", kenngruppe));
-		httppost.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));
+		try {
+			// Anfrage Parameter und Encoding setzen
+			List<NameValuePair> params = new ArrayList<>(2);
+			params.add(new BasicNameValuePair("k", kenngruppe));
+			httppost.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));
 
-		// POST Request ausführen und Rückgabe verarbeiten
-		HttpResponse response = httpclient.execute(httppost);
-		HttpEntity entity = response.getEntity();
+			// POST Request ausführen und Rückgabe verarbeiten
+			HttpResponse response = httpclient.execute(httppost);
+			HttpEntity entity = response.getEntity();
 
-		if (entity != null) {
-			BufferedReader reader = new BufferedReader(new InputStreamReader(entity.getContent()));
-			JSONObject result = new JSONObject(reader.readLine());
+			if (entity != null) {
+				BufferedReader reader = new BufferedReader(new InputStreamReader(entity.getContent()));
+				JSONObject result = new JSONObject(reader.readLine());
 
-			if(!result.getString("m").isEmpty()) {
-				funkspruch[0] = result.getString("t");
-				funkspruch[1] = result.getString("m");
+				if (!result.getString("m").isEmpty()) {
+					funkspruch[0] = result.getString("t");
+					funkspruch[1] = result.getString("m");
+				}
 			}
+		} catch (UnsupportedEncodingException e) {
+			System.out.println("Encoding wird nicht unterstützt.");
+		} catch (IOException e) {
+			System.out.println("HTTP Post war nicht erfolgreich.\nBitte wenden Sie sich an ihren Vorgesetzten.");
+			e.printStackTrace();
 		}
 
 		return funkspruch;
@@ -67,19 +75,20 @@ public class Funkraum {
 	 * Dem Service senden wir unsere Nachricht als POST Parameter (m) und unsere Kenngruppe (k).
 	 * Dieser nimmt die Daten entgegeb und hierlerlegt sie auf seinem Stapel (Datenbank) von dem die Nachrichten
 	 * irgendwann, auf Anfrage, wieder abgerufen werden können.
-	 *
-	 *  Darauf antworter der Server dann mit einem JSON Object in dem das Ergebnis der Anfrage zu sehen ist.
-	 *  {'result': 200}
-	 *
-	 *  Die 200 heißt hier das alles erfolgreich durchgeführt werden konnte. Steht hier etwas anderes, ist ein Fehler
-	 *  aufgetreten und die Anfrage war nicht erfolgreich.
-	 *  In letzterem Fall sollte eine Meldung an den Benutzer ausgegeben werden und ggF später erneut versucht.
+	 * <p>
+	 * Darauf antworter der Server dann mit einem JSON Object in dem das Ergebnis der Anfrage zu sehen ist.
+	 * {'result': 200}
+	 * <p>
+	 * Die 200 heißt hier das alles erfolgreich durchgeführt werden konnte. Steht hier etwas anderes, ist ein Fehler
+	 * aufgetreten und die Anfrage war nicht erfolgreich.
+	 * In letzterem Fall sollte eine Meldung an den Benutzer ausgegeben werden und ggF später erneut versucht.
 	 *
 	 * @param funkspruch : String : Der zu sendede Funkspruch
 	 * @param kenngruppe : String : Die Kenngruppe dieser Engima
 	 * @throws IOException : Exception : Funkspruch konnte nicht gesendet werden
 	 */
-	public void sendeFunkspruch(String funkspruch, String kenngruppe) throws HttpException, IOException {
+	void sendeFunkspruch(String funkspruch, String kenngruppe) throws HttpException, IOException {
+
 		HttpClient httpclient = HttpClients.createDefault();
 		HttpPost httppost = new HttpPost("https://enigma.itstall.de/");
 
@@ -96,7 +105,7 @@ public class Funkraum {
 		if (entity != null) {
 			BufferedReader reader = new BufferedReader(new InputStreamReader(entity.getContent()));
 			JSONObject result = new JSONObject(reader.readLine());
-			if(result.getInt("result") != 200) {
+			if (result.getInt("result") != 200) {
 				throw new HttpException("Der andere Funker mag deine Nachricht nicht. Rüge ihn wenn du ihn wieder siehst...");
 			}
 		}
diff --git a/src/main/java/projekt/enigma/model/Hardware.java b/src/main/java/projekt/enigma/model/Hardware.java
new file mode 100644
index 0000000000000000000000000000000000000000..58ac07827ed796bc9bfa9605f9b8c1bfe31dff84
--- /dev/null
+++ b/src/main/java/projekt/enigma/model/Hardware.java
@@ -0,0 +1,175 @@
+package projekt.enigma.model;
+
+/**
+ * In dieser Klasse wird die Hardware zusammen gefasst.
+ * Alle Komponenter der Enigma laufen hier zusammen.
+ *
+ * <p>
+ * walzen : Walze[] :           Ist ein Array der drei eingebauten Walzen Objekte
+ * steckbrett : Steckbrett :    Das Steckbrett mit den Verbindungen aus dem Codebuch
+ * reflektor : Reflektor :      Dies ist das Objekt der Reflektors
+ * nachricht : String :         Die verschlüsselte Nachricht wird in diesem String zusammen gesetzt und gespeichert
+ * kenngruppe : String :        Früher definierte die Kennzeichnung die Einheit welche diese Enigma benutzte.
+ * Wir missbrauchen die Kenngruppe für einen Benutzernamen
+ * </p>
+ */
+public class Hardware {
+
+	/**
+	 * TODO: Dokumentieren
+	 */
+	private Walze[] walzen;
+	private Steckbrett steckbrett;
+	private Reflektor reflektor;
+
+	/**
+	 * Im Konstruktor legen wir die Anzahl der Walzen fest welche die Hardware aufnehmen kann.
+	 * Die Enigma I welche hier nachgebildet werden soll, konnte drei Walzen aufnehmen.
+	 */
+	public Hardware() {
+		this.walzen = new Walze[3];
+	}
+
+	/**
+	 * Setzt eine Walze ein
+	 *
+	 * @param walze    : int : Setzt die Walze mit der angegebenen Nummer ein
+	 * @param walzenNr : int : Die Nummer der einzusetzenden Walze
+	 */
+	public void setzeWalzenNr(int walze, int walzenNr, int ringstellung) {
+		this.walzen[walze] = new Walze(walzenNr, ringstellung);
+	}
+
+	/**
+	 * Setzt den Notch der Walze
+	 *
+	 * @param walze    : int : Position der Walze
+	 * @param position : int : Umspringpunkt auf der Walze
+	 */
+	public void setzeRing(int walze, int position) {
+		this.walzen[walze].setRingstellung(position);
+	}
+
+	/**
+	 * Setzt den Startwert (position) der Walze (walze)
+	 *
+	 * @param walze     : int : Nummer der Walze
+	 * @param buchstabe : char : Buchstabe der zugewiesen soll
+	 */
+	public void setzePosition(int walze, char buchstabe) {
+		this.walzen[walze].setPosition(buchstabe);
+	}
+
+	/**
+	 * Verschlüsselt den übergebenen Buchstaben und fügt ihn der Nachricht hinzu
+	 *
+	 * @param buchstabe char : Der zu ver/entschlüsselnde Buchstabe
+	 * @return char : Der ver/entschlüsselte Buchstabe
+	 */
+	public char codiere(char buchstabe) {
+		this.dreheWalzen(1);
+
+		buchstabe = this.steckbrett.codiere(Character.toUpperCase(buchstabe));
+		buchstabe = this.walzen[2].codiere(buchstabe);
+		buchstabe = this.walzen[1].codiere(buchstabe);
+		buchstabe = this.walzen[0].codiere(buchstabe);
+		buchstabe = this.reflektor.codiere(buchstabe);
+		buchstabe = this.walzen[0].codiere2(buchstabe);
+		buchstabe = this.walzen[1].codiere2(buchstabe);
+		buchstabe = this.walzen[2].codiere2(buchstabe);
+		buchstabe = this.steckbrett.codiere(buchstabe);
+
+		return buchstabe;
+	}
+
+	/**
+	 * Nach jeder codierung eines Buchstabens müssen die Walzen gedreht werden.
+	 * Hier überprüfen wir welche der Walzen gedreht werden müssen und stoßen die Vorgang an.
+	 */
+	public void dreheWalzen(int richtung) {
+		if (richtung > 0) {
+			for (int i = 0; i < richtung; i++) {
+				if (this.walzen[2].dreheWalze(1) && this.walzen[1].dreheWalze(1)) {
+					this.walzen[0].dreheWalze(1);
+				}
+			}
+		} else {
+			for (int i = 0; i > richtung; richtung++) {
+				if (this.walzen[2].dreheWalze(-1) && this.walzen[1].dreheWalze(-1)) {
+					this.walzen[0].dreheWalze(-1);
+				}
+			}
+		}
+	}
+
+	/**
+	 * Gibt die verbauten Walzen Objekte zurück
+	 *
+	 * @return Walze[] : Array mit den Walzen Objekten
+	 */
+	public Walze[] getWalzen() {
+		return this.walzen;
+	}
+
+	/**
+	 * Setzt eine Walze ein und speichert das Objekt im Walzen Array
+	 *
+	 * @param position     : int : Position der Walze
+	 * @param walze        : int : Die Nummer der Walze
+	 * @param ringstellung : int : Umsprung Punkt der Walze
+	 */
+	public void setWalzen(int position, int walze, int ringstellung) {
+		this.walzen[position] = new Walze(walze, ringstellung);
+	}
+
+	/**
+	 * Gibt das Objekt des Steckbretts zurück
+	 *
+	 * @return Steckbrett : Das eingesetzte Steckbrett mit seinen Kabeln wenn eingesteckt
+	 */
+	public Steckbrett getSteckbrett() {
+		return steckbrett;
+	}
+
+	/**
+	 * Setzt das übergebene Steckbrett Objekt in die Hardware ein
+	 *
+	 * @param steckbrett : Steckbrett : Objekt des Steckbretts mit allen verbundenen Kabeln
+	 */
+	public void setSteckbrett(Steckbrett steckbrett) {
+		this.steckbrett = steckbrett;
+	}
+
+	/**
+	 * Liest den Reflektor aus und gibt ihn zurück
+	 *
+	 * @return Reflektor : Objekt des Reflektors
+	 */
+	public Reflektor getReflektor() {
+		return reflektor;
+	}
+
+	/**
+	 * Setzt den Reflektor ein.
+	 * In der Enigma I welche hier nachgebaut wird, gab es nur einen Reflektor.
+	 * Spätere Versionen haten zwei oder mehr, deshalb haben wir hier auch schon ein Objekt dafür erstellt,
+	 * welches ausgetauscht werden kann.
+	 *
+	 * @param reflektor : Reflektor : Das Obejtk des Reflektors
+	 */
+	public void setReflektor(Reflektor reflektor) {
+		this.reflektor = reflektor;
+	}
+
+	/**
+	 * Diese Funktion setzt die Walzen auf ihren Anfangswert zurück.
+	 * Hierfür ist der Buchstabe "A" festgelegt.
+	 * Dies wird benötigt um zB einen neuen Spruchschlüssel einzustellen oder eine neue Nachricht zu verfassen.
+	 */
+	public void resetWalzen() {
+		this.getWalzen()[0].setPosition('A');
+		this.getWalzen()[1].setPosition('A');
+		this.getWalzen()[2].setPosition('A');
+	}
+
+}
diff --git a/src/main/java/Enigma/model/Morsecode.java b/src/main/java/projekt/enigma/model/Morsecode.java
similarity index 91%
rename from src/main/java/Enigma/model/Morsecode.java
rename to src/main/java/projekt/enigma/model/Morsecode.java
index f8c759cf70fd7d17b2024ce91077b5835c46c618..7d99652547325b95631bb82dc8216ff4bdf5bc25 100644
--- a/src/main/java/Enigma/model/Morsecode.java
+++ b/src/main/java/projekt/enigma/model/Morsecode.java
@@ -1,4 +1,4 @@
-package Enigma.model;
+package projekt.enigma.model;
 
 import java.util.*;
 import java.util.Map.Entry;
@@ -42,6 +42,17 @@ public class Morsecode {
 		this.codeMap.put("X", "-..-");
 		this.codeMap.put("Y", "-.--");
 		this.codeMap.put("Z", "--..");
+		this.codeMap.put(" ", "-...-");
+		this.codeMap.put("1", ".----");
+		this.codeMap.put("2", ".----");
+		this.codeMap.put("3", "...--");
+		this.codeMap.put("4", "....-");
+		this.codeMap.put("5", ".....");
+		this.codeMap.put("6", "-....");
+		this.codeMap.put("7", "--...");
+		this.codeMap.put("8", "---..");
+		this.codeMap.put("9", "----.");
+		this.codeMap.put("0", "-----");
 	}
 
 	/**
@@ -93,7 +104,6 @@ public class Morsecode {
 	 */
 	private String getBuchstabe(String morsecode) {
 		// Initialisieren des Rückgabe Strings
-		// TODO: Darf bei der Initialisierung gleich einen Wert setzten lauf JAVA Konventionen?
 		String result = null;
 
 		// Loopt duch die Codemap und erstellt daraus ein Set
@@ -124,14 +134,13 @@ public class Morsecode {
 
 		String[] morsecodes = input.split(" ");
 
-
 		// Durch alle char im übergebenen String loopen
 		for(String morsecode : morsecodes) {
 
 			// Wenn der char in der codeMap enthalten ist, an den Rückgabe String anheften, ansonsten nichts ignorieren.
 			buchstabe = this.getBuchstabe(morsecode);
 			if(buchstabe != null) {
-				sb.append(buchstabe).append(' ');
+				sb.append(buchstabe);
 			}
 		}
 
diff --git a/src/main/java/projekt/enigma/model/Reflektor.java b/src/main/java/projekt/enigma/model/Reflektor.java
new file mode 100644
index 0000000000000000000000000000000000000000..9e5e6b1424852c8ee063179f8a8d216aac9c969a
--- /dev/null
+++ b/src/main/java/projekt/enigma/model/Reflektor.java
@@ -0,0 +1,48 @@
+package projekt.enigma.model;
+
+/**
+ * Klasse Reflektor
+ * <br>
+ * Der Reflektor nimmt einen Buchstaben der Klasse Walze entgegen und und kodiert diesen.
+ * Der kodierte Buchstabe wird an die Klasse Walze wieder zurückgegeben.
+ * <br>
+ * Prinzipiell verhält sich die Klasse Reflektor wie die Klasse Walze, außer das sie sich
+ * nach Betätigung einer Taste nicht dreht (quasi starr montiert ist) und sie gibt keine Signale
+ * an andere Walzen zum drehen.
+ */
+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>
+     * Durchsucht das konstante Char-Array WALZE_ALPHABET nach der Position eines bestimmten
+     * Buchstabens und gibt den Character an der entsprechenden Position im konstanten
+     * Char-Array WALZE_REFLEKTOR zurück.
+     *
+     * @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;
+            }
+        }
+
+        return WALZE_REFLEKTOR[iPositionReflektor];
+    }
+}
diff --git a/src/main/java/projekt/enigma/model/Steckbrett.java b/src/main/java/projekt/enigma/model/Steckbrett.java
new file mode 100644
index 0000000000000000000000000000000000000000..ec18c7ae9aed17c12a2bd361eda796f0c6cb5497
--- /dev/null
+++ b/src/main/java/projekt/enigma/model/Steckbrett.java
@@ -0,0 +1,142 @@
+package projekt.enigma.model;
+
+/**
+ * Klasse Steckbrett
+ * <br>
+ * Das Steckbrett diente dazu Buchstaben paarweise zu vertauschen noch bevor diese durch die Walzen codiert werden.
+ * Die Klasse Steckbrett nimmt bis zu 10 paarweise zu vertauschende Buchstabenpaare entgegen, prueft diese auf
+ * Zulaessigkeit und tauscht diese dann paarweise aus.
+ */
+public class Steckbrett {
+
+	/**
+	 * zaehler: Int, der als Laufvariable für die gesteckten Kabel genutzt wird
+	 */
+	private int zaehler;
+
+	/**
+	 * orginalBuchstaben: Character-Array, der jeweils den ersten zu vertauschenden Buchstaben enthält
+	 */
+	private Character[] orginalBuchstaben;
+
+	/**
+	 * getauschteBuchstaben: Character-Array, der jeweils den zweiten zu vertauschenden Buchstaben enthält
+	 */
+	private Character[] getauschteBuchstaben;
+
+
+	/**
+	 * Konstruktor Steckbrett
+	 * <br>
+	 * Erzeugt zwei Charakter-Arrays (orginalBuchstaben und getauschteBuchstaben) der Länge 10.
+	 */
+	public Steckbrett() {
+
+		orginalBuchstaben = new Character[10];
+		getauschteBuchstaben = new Character[10];
+	}
+
+	/**
+	 * Funktion setzeVertauschung
+	 * <br>
+	 * Der Funktion setzeVertauschung werden 2 Buchstaben (buchstabe1 und buchstabe2) übergeben.
+	 * Zuerst wird überprüft ob einer der beiden Buchstaben bereits enthalten ist, was unzulässig wäre.
+	 * <br>
+	 * Anschließend wird:
+	 * <p>
+	 * buchstabe1 in das Array orginalBuchstaben auf den nächsten, freien Index geschrieben
+	 * buchstabe2 in das Array getauschteBuchstaben auf den nächsten, freien Index geschrieben.
+	 * </p>
+	 *
+	 * @param buchstabe1 : char: Gibt den ersten Buchstaben an, der getauscht werden soll.
+	 * @param buchstabe2 : char: gibt den zweiten Buchstaben an, mit dem der erste getauscht werden soll.
+	 * @return boolean : Wenn die Vertauschung zulässig ist, true, ansonsten false
+	 */
+	public boolean setzeVertauschung(char buchstabe1, char buchstabe2) {
+
+		if (!ueberpruefeVertauschungen(buchstabe1) && !ueberpruefeVertauschungen(buchstabe2) && (zaehler < orginalBuchstaben.length)) {
+			orginalBuchstaben[zaehler] = buchstabe1;
+			getauschteBuchstaben[zaehler++] = buchstabe2;
+
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	/**
+	 * Funktion setzeVertauschung mit angabe eines Ports von 1 - 10
+	 * <br>
+	 * Der Funktion setzeVertauschung werden 2 Buchstaben (buchstabe1 und buchstabe2) sowie der Port übergeben.
+	 * Zuerst wird überprüft ob einer der beiden Buchstaben bereits enthalten ist, was unzulässig wäre.
+	 * <br>
+	 * Anschließend wird:
+	 * <p>
+	 * buchstabe1 in das Array orginalBuchstaben auf den Index (steckbrettPort) geschrieben
+	 * buchstabe2 in das Array getauschteBuchstaben auf den Index (steckbrettPort) geschrieben.
+	 * </p>
+	 *
+	 * @param buchstabe1 : char: Gibt den ersten Buchstaben an, der getauscht werden soll.
+	 * @param buchstabe2 : char: gibt den zweiten Buchstaben an, mit dem der erste getauscht werden soll.
+	 * @return boolean : Wenn die Vertauschung zulässig ist, true, ansonsten false
+	 */
+	public boolean setzeVertauschung(int steckbrettPort, char buchstabe1, char buchstabe2) {
+
+		if (!ueberpruefeVertauschungen(buchstabe1) && !ueberpruefeVertauschungen(buchstabe2)) {
+			orginalBuchstaben[steckbrettPort - 1] = buchstabe1;
+			getauschteBuchstaben[steckbrettPort - 1] = buchstabe2;
+
+			return true;
+		} else {
+
+			return false;
+		}
+
+	}
+
+	/**
+	 * Funktion ueberpruefeVertauschungen
+	 * <br>
+	 * Die Funktion ueberpruefeVertauschungen prueft ob der übergebene Buchstabe bereits in den beiden Arrays
+	 * (orginalBuchstaben) und (getauschteBuchstaben) vorhanden ist.
+	 * Eine Buchstabenvertauschung ist zulaessig, wenn keine Dopplungen der zu vertauschenden Buchstaben auftritt
+	 * (ein Buchstabe nicht mehrmals vertauscht wird).
+	 *
+	 * @return boolean :    Wenn false, dann darf der Buchstabe genutzt werden.
+	 * Wenn er schon vorhanden ist, wird true zurück gegeben
+	 */
+	public boolean ueberpruefeVertauschungen(Character buchstabe) {
+
+		boolean result = false;
+
+		for (int n = 0; n < orginalBuchstaben.length; n++) {
+			if (buchstabe.equals(orginalBuchstaben[n]) || buchstabe.equals(getauschteBuchstaben[n])) {
+				result = true;
+				break;
+			}
+		}
+
+		return result;
+	}
+
+	/**
+	 * Funktion codiere
+	 * <br>
+	 * Die Funktion codiere tauscht den uebergebenen Character buchstabe mit dem zu tauschenden Character aus.
+	 *
+	 * @param buchstabe : Character : Buchstabe der codiert werden soll.
+	 * @return buchstabe : Character : Codierter Buchstabe.
+	 */
+	public char codiere(Character buchstabe) {
+		for (int index = 0; index < getauschteBuchstaben.length; index++) {
+			if (buchstabe.equals(getauschteBuchstaben[index])) {
+				buchstabe = orginalBuchstaben[index];
+			} else if (buchstabe.equals(orginalBuchstaben[index])) {
+				buchstabe = getauschteBuchstaben[index];
+			}
+		}
+
+		return buchstabe;
+	}
+
+}
diff --git a/src/main/java/projekt/enigma/model/Walze.java b/src/main/java/projekt/enigma/model/Walze.java
new file mode 100644
index 0000000000000000000000000000000000000000..99d41248aa3aca3a3529674c1750a79c4ebe8a3a
--- /dev/null
+++ b/src/main/java/projekt/enigma/model/Walze.java
@@ -0,0 +1,244 @@
+package projekt.enigma.model;
+
+import java.util.Arrays;
+import java.util.Collections;
+
+/**
+ * Klasse Walze
+ * <br>
+ * Erzeugt ein Objekt des Typs Walze mit den Eigenschaften:
+ * <br>
+ * 1. Walzennummer (Die Walze enthält die 26 Buchstaben des Alphabeths und codiert diese.
+ * 5 verschiedene Walzen stehen zur Auswahl, die jeweils verschieden die Buchstaben des Alphabeths
+ * paarweise vertauschen)
+ * <br>
+ * 2. Ringstellung (Umspringpunkt der Walze wird festgelegt. Der Umspringpunkt bestimmt
+ * den Drehzeitpunkt der linken Nachbarwalze)
+ */
+public class Walze {
+
+	/**
+	 * walzeAlpha : Character[] : Array, dass die Buchstaben des Alphabets enthaelt
+	 */
+	private Character[] alphabet;
+
+	/**
+	 * ringstellung : char : zeigt die Einstellung fuer den Umspringpunkt
+	 */
+	private char ringstellung;
+
+	/**
+	 * walzennr : int : Bestimmt, welche Walze genutzt wird
+	 */
+	private int walzennr;
+
+	/**
+	 * alphabet : Character[] : Enthaelt die Buchstaben des Alphabets. Wird im Laufe des Programmes
+	 * aber immer wieder ueberschrieben.
+	 */
+	private Character[] walzeAlpha;
+
+	/**
+	 * Ueberschriebener Konstruktor, der die Eingangsparameter der Walze mitgibt
+	 *
+	 * @param walzennr     : int : Nummer der gewaehlten Walze
+	 * @param ringstellung : int : Einstellung des Umsprungpunktes
+	 */
+	public Walze(int walzennr, int ringstellung) {
+		this.alphabet = new Character[]{'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+				'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
+		this.walzeAlpha = new Character[]{'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+				'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
+
+		this.setWalzennr(walzennr);
+		this.setRingstellung(ringstellung);
+	}
+
+	/**
+	 * Sortiert der Walzennummer das passende Character-Array mittels switch zu.
+	 *
+	 * @return walze : Character[] : gibt die gewaehlte Walze zurueck
+	 */
+	private Character[] walzenNummer() {
+		Character[] walze = new Character[26];
+
+		// Character-Arrays fuer die Codierung jeder Walze
+		Character[] walzeEins = {'E', 'K', 'M', 'F', 'L', 'G', 'D', 'Q', 'V', 'Z', 'N', 'T', 'O', 'W', 'Y',
+				'H', 'X', 'U', 'S', 'P', 'A', 'I', 'B', 'R', 'C', 'J'};
+		Character[] walzeZwei = {'A', 'J', 'D', 'K', 'S', 'I', 'R', 'U', 'X', 'B', 'L', 'H', 'W', 'T', 'M',
+				'C', 'Q', 'G', 'Z', 'N', 'P', 'Y', 'F', 'V', 'O', 'E'};
+		Character[] walzeDrei = {'B', 'D', 'F', 'H', 'J', 'L', 'C', 'P', 'R', 'T', 'X', 'V', 'Z', 'N', 'Y',
+				'E', 'I', 'W', 'G', 'A', 'K', 'M', 'U', 'S', 'Q', 'O'};
+		Character[] walzeVier = {'E', 'S', 'O', 'V', 'P', 'Z', 'J', 'A', 'Y', 'Q', 'U', 'I', 'R', 'H', 'X',
+				'L', 'N', 'F', 'T', 'G', 'K', 'D', 'C', 'M', 'W', 'B'};
+		Character[] walzeFuenf = {'V', 'Z', 'B', 'R', 'G', 'I', 'T', 'Y', 'U', 'P', 'S', 'D', 'N', 'H', 'L',
+				'X', 'A', 'W', 'M', 'J', 'Q', 'O', 'F', 'E', 'C', 'K'};
+
+		switch (this.walzennr) {
+			case 1:
+				walze = walzeEins;
+				break;
+			case 2:
+				walze = walzeZwei;
+				break;
+			case 3:
+				walze = walzeDrei;
+				break;
+			case 4:
+				walze = walzeVier;
+				break;
+			case 5:
+				walze = walzeFuenf;
+				break;
+		}
+
+		return walze;
+	}
+
+	/**
+	 * TODO: Dokumentieren
+	 *
+	 * @return ringstellung : char : gibt die neue Ringstellung als char zurueck
+	 */
+	public char getRingstellung() {
+		return ringstellung;
+	}
+
+	/**
+	 * Setzt die Initiale Ringstellung der Walze.
+	 * Es sind nur Zahlen von 1 - 26 zugelassen.
+	 * <p>
+	 * Die Ringstellung wird zum char umgewandelt.
+	 * Im Fehlerfall wird die Ringstellung standardmaessig auf 'Z' gesetzt.
+	 *
+	 * @param ringstellung : int : Punkt an dem die Walze umspringt
+	 */
+	//TODO ??? Setter Ringstellung
+	public void setRingstellung(int ringstellung) {
+		if ((ringstellung > 0) && (ringstellung <= 26)) {
+			this.ringstellung = this.alphabet[ringstellung - 1];
+		} else {
+			this.ringstellung = 'Z';
+		}
+	}
+
+	/**
+	 * Dreht die Walze: verschiebt das Alphabet um keine, eine oder mehrere Stellen und ueberschreibt
+	 * das Array alphabet mit der neuen Anordnung.
+	 * <p>
+	 * Ueberprueft, ob der Umspringpunkt der Walze nach der Drehung erreicht wurde.
+	 *
+	 * @param richtung : int : 1 dreht die Walze weiter und -1 dreht sie einen Schritt zurück
+	 * @return checkRing : boolean : gibt true zurueck wenn der Umspringpunkt erreicht wurde
+	 * TODO: Doku
+	 */
+	public boolean dreheWalze(int richtung) {
+		boolean checkRing = false;
+		int korrektorFaktor = 0;
+
+		if (richtung == 1) {
+			Collections.rotate(Arrays.asList(this.walzeAlpha), -1);
+		} else {
+			korrektorFaktor = 1;
+			Collections.rotate(Arrays.asList(this.walzeAlpha), 1);
+		}
+
+		// gleicht die Ringstellung mit der aktuellen Position ab
+		if (this.getPosition() + korrektorFaktor == this.ringstellung) {
+			checkRing = true;
+		}
+
+		return checkRing;
+	}
+
+	/**
+	 * Codiert den mitgegebenen Buchstaben anhand der gewaehlten Walze.
+	 *
+	 * @param buchstabe : char : Buchstabe, der verschluesselt werden soll
+	 * @return buchstabe : char : verschluesselter Buchstabe
+	 */
+	public char codiere(char buchstabe) {
+        /* durchsucht die (verschobene) Alphabetswalze nach dem aktuellen Buchstaben und
+        uebertraegt den Index auf die gewaehlte Codierwalze*/
+		buchstabe = walzenNummer()[fetchArrayIndex(buchstabe, walzeAlpha)];
+
+		return buchstabe;
+	}
+
+	/**
+	 * Decodiert den mitgegebenen Buchstaben mit Hilfe der (verschobenen) Alphabetswalze
+	 *
+	 * @param buchstabe : char : Buchstabe, der decodiert werden soll
+	 * @return buchstabe : char : decodierter Buchstabe
+	 */
+	public char codiere2(char buchstabe) {
+        /* durchsucht die gewaehlte Walze nach dem aktuellen Buchstaben und
+        uebertraegt den Index auf die (verschobene) Alphabetswalze*/
+		buchstabe = walzeAlpha[fetchArrayIndex(buchstabe, walzenNummer())];
+
+		return buchstabe;
+	}
+
+	/**
+	 * TODO: Dokumentieren
+	 * Ermittelt den Index eines Characters in einem Array ueber eine for-Schleife
+	 *
+	 * @param buchstabe : Character : Buchstabe, dessen Index benoetigt wird
+	 * @param array     : Character[] : Array, in dem der Buchstabe vorkommen soll
+	 * @return result : int : index des Buchstaben
+	 */
+	private int fetchArrayIndex(Character buchstabe, Character[] array) {
+		// wird mit ungueltigem Wert initialisiert
+		int result = -1;
+
+		for (int i = 0; i < array.length; i++) {
+			if (array[i].equals(buchstabe)) {
+				result = i;
+				break;
+			}
+		}
+
+		return result;
+	}
+
+	/**
+	 * Setzt die Walzennummer. Es stehen fuenf Walze zur Auswahl.
+	 *
+	 * @param walzennr : int : Walzennummer
+	 */
+	public void setWalzennr(int walzennr) {
+		if ((walzennr > 0) && (walzennr < 6)) {
+			this.walzennr = walzennr;
+		} else {
+			System.err.println("Keine gültige Walzennummer");
+		}
+	}
+
+	/**
+	 * TODO: Dokumentieren // das selbe wie getAnzeig?
+	 * Gibt den Character zurueck, der aktuell in der Walze eingestellt ist
+	 *
+	 * @return Character am Index 0 des (verschobenen) Alphabets zurueck
+	 */
+	public Character getPosition() {
+		return walzeAlpha[0];
+	}
+
+	/**
+	 * * TODO: Funktionsname hat sich geändert
+	 * Gibt die Grundeinstellung der Walze ein. Nur Buchstaben von A - Z sind zugelassen.
+	 * Buchstaben werden automatisch in Grossbuchstaben umgewandelt.
+	 * Ist die Grundeinstellung nicht 'A', wird die Methode dreheWalze() aufgerufen.
+	 *
+	 * @param buchstabe : Character : Einstellung der Walze
+	 */
+	public void setPosition(Character buchstabe) {
+		if (Character.isLetter(buchstabe)) {
+			buchstabe = Character.toUpperCase(buchstabe);
+			System.arraycopy(this.alphabet, 0, this.walzeAlpha, 0, this.alphabet.length);
+			if (buchstabe > 'A') {
+				dreheWalze(this.fetchArrayIndex(buchstabe, this.walzeAlpha));
+			}
+		}
+	}
+}
diff --git a/src/main/resources/Enigma/gui.fxml b/src/main/resources/Enigma/gui.fxml
deleted file mode 100644
index ae2b648dd67c8856ee83f5a43d166affc882a42a..0000000000000000000000000000000000000000
--- a/src/main/resources/Enigma/gui.fxml
+++ /dev/null
@@ -1,200 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-
-<?import javafx.scene.control.Button?>
-<?import javafx.scene.control.ButtonBar?>
-<?import javafx.scene.control.Label?>
-<?import javafx.scene.control.MenuButton?>
-<?import javafx.scene.control.MenuItem?>
-<?import javafx.scene.control.TextField?>
-<?import javafx.scene.layout.AnchorPane?>
-
-<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="Enigma.GuiController">
-   <children>
-      <TextField layoutX="43.0" layoutY="625.0" prefHeight="25.0" prefWidth="48.0" />
-      <TextField layoutX="112.0" layoutY="625.0" prefHeight="25.0" prefWidth="48.0" />
-      <TextField layoutX="187.0" layoutY="625.0" prefHeight="25.0" prefWidth="48.0" />
-      <TextField layoutX="272.0" layoutY="625.0" prefHeight="25.0" prefWidth="48.0" />
-      <TextField layoutX="346.0" layoutY="625.0" prefHeight="25.0" prefWidth="48.0" />
-      <TextField layoutX="413.0" layoutY="625.0" prefHeight="25.0" prefWidth="48.0" />
-      <TextField layoutX="476.0" layoutY="625.0" prefHeight="25.0" prefWidth="48.0" />
-      <TextField layoutX="544.0" layoutY="625.0" prefHeight="25.0" prefWidth="48.0" />
-      <TextField layoutX="617.0" layoutY="625.0" prefHeight="25.0" prefWidth="48.0" />
-      <TextField layoutX="693.0" layoutY="625.0" prefHeight="25.0" prefWidth="48.0" />
-      <ButtonBar layoutX="31.0" layoutY="570.0" prefHeight="36.0" prefWidth="860.0">
-        <buttons>
-            <Button mnemonicParsing="false" text="L" />
-            <Button mnemonicParsing="false" text="P" />
-            <Button mnemonicParsing="false" text="Y" />
-          <Button mnemonicParsing="false" text="X" />
-            <Button mnemonicParsing="false" text="C" />
-            <Button mnemonicParsing="false" text="V" />
-            <Button mnemonicParsing="false" text="B" />
-            <Button mnemonicParsing="false" text="N" />
-            <Button mnemonicParsing="false" text="M" />
-        </buttons>
-      </ButtonBar>
-      <ButtonBar layoutX="15.0" layoutY="534.0" prefHeight="36.0" prefWidth="860.0">
-         <buttons>
-            <Button mnemonicParsing="false" text="A" />
-            <Button mnemonicParsing="false" text="S" />
-            <Button mnemonicParsing="false" text="D" />
-            <Button mnemonicParsing="false" text="F" />
-            <Button mnemonicParsing="false" text="G" />
-            <Button mnemonicParsing="false" text="H" />
-            <Button mnemonicParsing="false" text="J" />
-            <Button mnemonicParsing="false" text="K" />
-         </buttons>
-      </ButtonBar>
-      <ButtonBar layoutX="22.0" layoutY="491.0" prefHeight="25.0" prefWidth="583.0">
-         <buttons>
-            <Button minWidth="13.0" mnemonicParsing="false" prefHeight="25.0" text="Q" />
-            <Button mnemonicParsing="false" text="W" />
-            <Button mnemonicParsing="false" text="E" />
-            <Button mnemonicParsing="false" text="R" />
-            <Button mnemonicParsing="false" text="T" />
-            <Button mnemonicParsing="false" text="Z" />
-            <Button mnemonicParsing="false" text="U" />
-            <Button mnemonicParsing="false" text="I" />
-            <Button mnemonicParsing="false" text="O" />
-            <Button mnemonicParsing="false" text="Löschen" />
-         </buttons>
-      </ButtonBar>
-      <ButtonBar layoutX="39.0" layoutY="418.0" prefHeight="36.0" prefWidth="860.0">
-         <buttons>
-            <Button mnemonicParsing="false" text="L" />
-            <Button mnemonicParsing="false" text="P" />
-            <Button mnemonicParsing="false" text="Y" />
-            <Button mnemonicParsing="false" text="X" />
-            <Button mnemonicParsing="false" text="C" />
-            <Button mnemonicParsing="false" text="V" />
-            <Button mnemonicParsing="false" text="B" />
-            <Button mnemonicParsing="false" text="N" />
-            <Button mnemonicParsing="false" text="M" />
-         </buttons>
-      </ButtonBar>
-      <ButtonBar layoutX="23.0" layoutY="382.0" prefHeight="36.0" prefWidth="860.0">
-         <buttons>
-            <Button mnemonicParsing="false" text="A" />
-            <Button mnemonicParsing="false" text="S" />
-            <Button mnemonicParsing="false" text="D" />
-            <Button mnemonicParsing="false" text="F" />
-            <Button mnemonicParsing="false" text="G" />
-            <Button mnemonicParsing="false" text="H" />
-            <Button mnemonicParsing="false" text="J" />
-            <Button mnemonicParsing="false" text="K" />
-         </buttons>
-      </ButtonBar>
-      <ButtonBar layoutX="30.0" layoutY="339.0" prefHeight="25.0" prefWidth="583.0">
-         <buttons>
-            <Button minWidth="13.0" mnemonicParsing="false" prefHeight="25.0" text="Q" />
-            <Button mnemonicParsing="false" text="W" />
-            <Button mnemonicParsing="false" text="E" />
-            <Button mnemonicParsing="false" text="R" />
-            <Button mnemonicParsing="false" text="T" />
-            <Button mnemonicParsing="false" text="Z" />
-            <Button mnemonicParsing="false" text="U" />
-            <Button mnemonicParsing="false" text="I" />
-            <Button mnemonicParsing="false" text="O" />
-         </buttons>
-      </ButtonBar>
-      <MenuButton fx:id="w1" layoutX="91.0" layoutY="76.0" mnemonicParsing="false" text="I">
-<!--        <items>-->
-<!--          <MenuItem fx:id="w1I" mnemonicParsing="false" onAction="#w1I" text="I" />-->
-<!--          <MenuItem fx:id="w1II" mnemonicParsing="false" onAction="#w1II" text="II" />-->
-<!--           <MenuItem fx:id="w1III" mnemonicParsing="false" onAction="#w1III" text="III" />-->
-<!--            <MenuItem fx:id="w1IV" mnemonicParsing="false" onAction="#w1IV" text="IV" />-->
-<!--            <MenuItem fx:id="w1V" mnemonicParsing="false" onAction="#w1V" text="V" />-->
-<!--        </items>-->
-      </MenuButton>
-      <MenuButton fx:id="w3" layoutX="171.0" layoutY="76.0" mnemonicParsing="false" text="I">
-         <items>
-            <MenuItem fx:id="w3I" mnemonicParsing="false" onAction="#w3I" text="I" />
-            <MenuItem fx:id="w3II" mnemonicParsing="false" onAction="#w3II" text="II" />
-            <MenuItem fx:id="w3III" mnemonicParsing="false" onAction="#w3III" text="III" />
-            <MenuItem fx:id="w3IV" mnemonicParsing="false" onAction="#w3IV" text="IV" />
-            <MenuItem fx:id="w3V" mnemonicParsing="false" onAction="#w3V" text="V" />
-         </items>
-      </MenuButton>
-      <MenuButton fx:id="w2" layoutX="133.0" layoutY="76.0" mnemonicParsing="false" text="I">
-         <items>
-            <MenuItem fx:id="w2I" mnemonicParsing="false" onAction="#w2I" text="I" />
-            <MenuItem fx:id="w2II" mnemonicParsing="false" onAction="#w2II" text="II" />
-            <MenuItem fx:id="w2III" mnemonicParsing="false" onAction="#w2III" text="III" />
-            <MenuItem fx:id="w2IV" mnemonicParsing="false" onAction="#w2IV" text="IV" />
-            <MenuItem fx:id="w2V" mnemonicParsing="false" onAction="#w2V" text="V" />
-         </items>
-      </MenuButton>
-<!--      <MenuButton layoutX="93.0" layoutY="114.0" mnemonicParsing="false">-->
-<!--         <items>-->
-<!--            <MenuItem mnemonicParsing="false" onAction="#z1" text="1" />-->
-<!--            <MenuItem mnemonicParsing="false" onAction="#z2" text="2" />-->
-<!--            <MenuItem mnemonicParsing="false" onAction="#z3" text="3" />-->
-<!--            <MenuItem mnemonicParsing="false" onAction="#z4" text="4" />-->
-<!--            <MenuItem mnemonicParsing="false" onAction="#z5" text="5" />-->
-<!--            <MenuItem mnemonicParsing="false" onAction="#z6" text="6" />-->
-<!--            <MenuItem mnemonicParsing="false" onAction="#z7" text="7" />-->
-<!--            <MenuItem mnemonicParsing="false" onAction="#z8" text="8" />-->
-<!--            <MenuItem mnemonicParsing="false" onAction="#z9" text="9" />-->
-<!--            <MenuItem mnemonicParsing="false" onAction="#z10" text="10" />-->
-<!--            <MenuItem mnemonicParsing="false" onAction="#z11" text="11" />-->
-<!--            <MenuItem mnemonicParsing="false" onAction="#z12" text="12" />-->
-<!--            <MenuItem mnemonicParsing="false" onAction="#z13" text="13" />-->
-<!--            <MenuItem mnemonicParsing="false" onAction="#z14" text="14" />-->
-<!--            <MenuItem mnemonicParsing="false" onAction="#z15" text="15" />-->
-<!--            <MenuItem mnemonicParsing="false" onAction="#z16" text="16" />-->
-<!--            <MenuItem mnemonicParsing="false" onAction="#z17" text="17" />-->
-<!--            <MenuItem mnemonicParsing="false" onAction="#z18" text="18" />-->
-<!--            <MenuItem mnemonicParsing="false" onAction="#z19" text="19" />-->
-<!--            <MenuItem mnemonicParsing="false" onAction="#z20" text="20" />-->
-<!--            <MenuItem mnemonicParsing="false" onAction="#z21" text="21" />-->
-<!--            <MenuItem mnemonicParsing="false" onAction="#z22" text="22" />-->
-<!--            <MenuItem mnemonicParsing="false" onAction="#z23" text="23" />-->
-<!--            <MenuItem mnemonicParsing="false" onAction="#z24" text="24" />-->
-<!--            <MenuItem mnemonicParsing="false" onAction="#z25" text="25" />-->
-<!--            <MenuItem mnemonicParsing="false" onAction="#z26" text="26" />-->
-<!--         </items>-->
-<!--      </MenuButton>-->
-      <MenuButton layoutX="173.0" layoutY="114.0" mnemonicParsing="false">
-         <items>
-            <MenuItem mnemonicParsing="false" text="Action 1" />
-            <MenuItem mnemonicParsing="false" text="Action 2" />
-         </items>
-      </MenuButton>
-      <MenuButton layoutX="135.0" layoutY="114.0" mnemonicParsing="false">
-         <items>
-            <MenuItem mnemonicParsing="false" text="Action 1" />
-            <MenuItem mnemonicParsing="false" text="Action 2" />
-         </items>
-      </MenuButton>
-      <MenuButton layoutX="95.0" layoutY="157.0" mnemonicParsing="false">
-         <items>
-            <MenuItem mnemonicParsing="false" text="Action 1" />
-            <MenuItem mnemonicParsing="false" text="Action 2" />
-         </items>
-      </MenuButton>
-      <MenuButton layoutX="175.0" layoutY="157.0" mnemonicParsing="false">
-         <items>
-            <MenuItem mnemonicParsing="false" text="Action 1" />
-            <MenuItem mnemonicParsing="false" text="Action 2" />
-         </items>
-      </MenuButton>
-      <MenuButton layoutX="137.0" layoutY="157.0" mnemonicParsing="false">
-         <items>
-            <MenuItem mnemonicParsing="false" text="Action 1" />
-            <MenuItem mnemonicParsing="false" text="Action 2" />
-         </items>
-      </MenuButton>
-      <TextField layoutX="246.0" layoutY="76.0" prefHeight="77.0" prefWidth="410.0" />
-      <TextField layoutX="248.0" layoutY="182.0" prefHeight="77.0" prefWidth="410.0" />
-      <Button layoutX="717.0" layoutY="221.0" mnemonicParsing="false" onAction="#btnsenden" prefHeight="69.0" prefWidth="164.0" text="An Funker senden" />
-      <Button layoutX="717.0" layoutY="135.0" mnemonicParsing="false" prefHeight="69.0" prefWidth="164.0" text="Funkspruch empfangen" />
-      <TextField layoutX="725.0" layoutY="76.0" />
-      <Label layoutX="727.0" layoutY="51.0" prefHeight="17.0" prefWidth="149.0" text="Kenngruppe" />
-      <MenuButton layoutX="93.0" layoutY="114.0" mnemonicParsing="false">
-         <items>
-            <MenuItem mnemonicParsing="false" text="Action 1" />
-            <MenuItem mnemonicParsing="false" text="Action 2" />
-         </items>
-      </MenuButton>
-   </children>
-</AnchorPane>
diff --git a/src/main/resources/Enigma/secondary.fxml b/src/main/resources/Enigma/secondary.fxml
deleted file mode 100644
index 6f0d942833692b3137fbe7119541faecce085034..0000000000000000000000000000000000000000
--- a/src/main/resources/Enigma/secondary.fxml
+++ /dev/null
@@ -1,16 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-
-<?import javafx.scene.layout.VBox?>
-<?import javafx.scene.control.Label?>
-<?import javafx.scene.control.Button?>
-<?import javafx.geometry.Insets?>
-
-<VBox alignment="CENTER" spacing="20.0" xmlns="http://javafx.com/javafx/8.0.171" xmlns:fx="http://javafx.com/fxml/1" fx:controller="Enigma.SecondaryController">
-    <children>
-        <Label text="Secondary View" />
-        <Button fx:id="secondaryButton" text="Switch to Primary View" onAction="#switchToPrimary" />
-    </children>
-    <padding>
-        <Insets bottom="20.0" left="20.0" right="20.0" top="20.0" />
-    </padding>
-</VBox>
diff --git a/src/main/resources/Enigma/codebuch.sqlite b/src/main/resources/projekt/enigma/codebuch.sqlite
similarity index 92%
rename from src/main/resources/Enigma/codebuch.sqlite
rename to src/main/resources/projekt/enigma/codebuch.sqlite
index 78be5227db85283c0c20e3719303cb77e48e8cbf..018731d4221da62ff7e8702ce5f52833bccbea05 100644
Binary files a/src/main/resources/Enigma/codebuch.sqlite and b/src/main/resources/projekt/enigma/codebuch.sqlite differ
diff --git a/src/main/resources/projekt/enigma/gui.fxml b/src/main/resources/projekt/enigma/gui.fxml
new file mode 100644
index 0000000000000000000000000000000000000000..8630069413fb732ad0ed6f81fbe7b28ce2efa52f
--- /dev/null
+++ b/src/main/resources/projekt/enigma/gui.fxml
@@ -0,0 +1,629 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import javafx.geometry.Insets?>
+<?import javafx.scene.control.Button?>
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.control.MenuButton?>
+<?import javafx.scene.control.ProgressBar?>
+<?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.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.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>
+            <ColumnConstraints hgrow="ALWAYS" minWidth="10.0" prefWidth="100.0" />
+            <ColumnConstraints hgrow="ALWAYS" minWidth="10.0" prefWidth="100.0" />
+            <ColumnConstraints hgrow="ALWAYS" minWidth="10.0" prefWidth="100.0" />
+            <ColumnConstraints hgrow="ALWAYS" minWidth="10.0" prefWidth="100.0" />
+            <ColumnConstraints hgrow="ALWAYS" minWidth="10.0" prefWidth="100.0" />
+            <ColumnConstraints hgrow="ALWAYS" minWidth="10.0" prefWidth="100.0" />
+            <ColumnConstraints hgrow="ALWAYS" minWidth="10.0" prefWidth="100.0" />
+            <ColumnConstraints hgrow="ALWAYS" minWidth="10.0" prefWidth="100.0" />
+            <ColumnConstraints hgrow="ALWAYS" minWidth="10.0" prefWidth="100.0" />
+            <ColumnConstraints hgrow="ALWAYS" minWidth="10.0" prefWidth="100.0" />
+            <ColumnConstraints hgrow="ALWAYS" minWidth="10.0" prefWidth="100.0" />
+          <ColumnConstraints hgrow="ALWAYS" minWidth="10.0" prefWidth="100.0" />
+            <ColumnConstraints hgrow="ALWAYS" minWidth="10.0" prefWidth="100.0" />
+        </columnConstraints>
+        <rowConstraints>
+            <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>
+         <children>
+            <TextField fx:id="tfStecker1" prefHeight="25.0" prefWidth="48.0" GridPane.columnIndex="1" GridPane.rowIndex="7">
+               <GridPane.margin>
+                  <Insets left="10.0" right="10.0" />
+               </GridPane.margin>
+            </TextField>
+            <TextField fx:id="tfStecker2" prefHeight="25.0" prefWidth="48.0" GridPane.columnIndex="2" GridPane.rowIndex="7">
+               <GridPane.margin>
+                  <Insets left="10.0" right="10.0" />
+               </GridPane.margin>
+            </TextField>
+            <TextField fx:id="tfStecker3" prefHeight="25.0" prefWidth="48.0" GridPane.columnIndex="3" GridPane.rowIndex="7">
+               <GridPane.margin>
+                  <Insets left="10.0" right="10.0" />
+               </GridPane.margin>
+            </TextField>
+            <TextField fx:id="tfStecker4" prefHeight="25.0" prefWidth="48.0" GridPane.columnIndex="4" GridPane.rowIndex="7">
+               <GridPane.margin>
+                  <Insets left="10.0" right="10.0" />
+               </GridPane.margin>
+            </TextField>
+            <TextField fx:id="tfStecker5" prefHeight="25.0" prefWidth="48.0" GridPane.columnIndex="5" GridPane.rowIndex="7">
+               <GridPane.margin>
+                  <Insets left="10.0" right="10.0" />
+               </GridPane.margin>
+            </TextField>
+            <TextField fx:id="tfStecker6" prefHeight="25.0" prefWidth="48.0" GridPane.columnIndex="6" GridPane.rowIndex="7">
+               <GridPane.margin>
+                  <Insets left="10.0" right="10.0" />
+               </GridPane.margin>
+            </TextField>
+            <TextField fx:id="tfStecker7" prefHeight="25.0" prefWidth="48.0" GridPane.columnIndex="7" GridPane.rowIndex="7">
+               <GridPane.margin>
+                  <Insets left="10.0" right="10.0" />
+               </GridPane.margin>
+            </TextField>
+            <TextField fx:id="tfStecker8" prefHeight="25.0" prefWidth="48.0" GridPane.columnIndex="8" GridPane.rowIndex="7">
+               <GridPane.margin>
+                  <Insets left="10.0" right="10.0" />
+               </GridPane.margin>
+            </TextField>
+            <TextField fx:id="tfStecker9" prefHeight="25.0" prefWidth="48.0" GridPane.columnIndex="9" GridPane.rowIndex="7">
+               <GridPane.margin>
+                  <Insets left="10.0" right="10.0" />
+               </GridPane.margin>
+            </TextField>
+            <TextField fx:id="tfStecker10" prefHeight="25.0" prefWidth="48.0" GridPane.columnIndex="10" GridPane.rowIndex="7">
+               <GridPane.margin>
+                  <Insets left="10.0" right="10.0" />
+               </GridPane.margin>
+            </TextField>
+            <Button fx:id="btnM" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="M" textFill="#fffdfd" GridPane.columnIndex="9" GridPane.rowIndex="6">
+               <font>
+                  <Font name="System Bold" size="18.0" />
+               </font>
+            </Button>
+            <Button fx:id="btnN" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="N" textFill="#fffdfd" GridPane.columnIndex="8" GridPane.rowIndex="6">
+               <font>
+                  <Font name="System Bold" size="18.0" />
+               </font>
+            </Button>
+            <Button fx:id="btnB" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="B" textFill="#fffdfd" GridPane.columnIndex="7" GridPane.rowIndex="6">
+               <font>
+                  <Font name="System Bold" size="18.0" />
+               </font>
+            </Button>
+            <Button fx:id="btnV" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="V" textFill="#fffdfd" GridPane.columnIndex="6" GridPane.rowIndex="6">
+               <font>
+                  <Font name="System Bold" size="18.0" />
+               </font>
+            </Button>
+            <Button fx:id="btnC" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="C" textFill="#fffdfd" GridPane.columnIndex="5" GridPane.rowIndex="6">
+               <font>
+                  <Font name="System Bold" size="18.0" />
+               </font>
+            </Button>
+            <Button fx:id="btnX" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="X" textFill="#fffdfd" GridPane.columnIndex="4" GridPane.rowIndex="6">
+               <font>
+                  <Font name="System Bold" size="18.0" />
+               </font>
+            </Button>
+            <Button fx:id="btnY" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="Y" textFill="#fffdfd" GridPane.columnIndex="3" GridPane.rowIndex="6">
+               <font>
+                  <Font name="System Bold" size="18.0" />
+               </font>
+            </Button>
+            <Button fx:id="btnP" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="P" textFill="#fffdfd" GridPane.columnIndex="2" GridPane.rowIndex="6">
+               <font>
+                  <Font name="System Bold" size="18.0" />
+               </font>
+            </Button>
+            <Button fx:id="btnL" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="L" textFill="#fffdfd" GridPane.columnIndex="10" GridPane.rowIndex="6">
+               <font>
+                  <Font name="System Bold" size="18.0" />
+               </font>
+            </Button>
+            <Button fx:id="btnK" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="K" textFill="#fffdfd" GridPane.columnIndex="9" GridPane.rowIndex="5">
+               <font>
+                  <Font name="System Bold" size="18.0" />
+               </font>
+               <GridPane.margin>
+                  <Insets left="28.0" />
+               </GridPane.margin>
+            </Button>
+            <Button fx:id="btnJ" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="J" textFill="#fffdfd" GridPane.columnIndex="8" GridPane.rowIndex="5">
+               <font>
+                  <Font name="System Bold" size="18.0" />
+               </font>
+               <GridPane.margin>
+                  <Insets left="28.0" />
+               </GridPane.margin>
+            </Button>
+            <Button fx:id="btnH" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="H" textFill="#fffdfd" GridPane.columnIndex="7" GridPane.rowIndex="5">
+               <font>
+                  <Font name="System Bold" size="18.0" />
+               </font>
+               <GridPane.margin>
+                  <Insets left="28.0" />
+               </GridPane.margin>
+            </Button>
+            <Button fx:id="btnG" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="G" textFill="#fffdfd" GridPane.columnIndex="6" GridPane.rowIndex="5">
+               <font>
+                  <Font name="System Bold" size="18.0" />
+               </font>
+               <GridPane.margin>
+                  <Insets left="28.0" />
+               </GridPane.margin>
+            </Button>
+            <Button fx:id="btnF" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="F" textFill="#fffdfd" GridPane.columnIndex="5" GridPane.rowIndex="5">
+               <font>
+                  <Font name="System Bold" size="18.0" />
+               </font>
+               <GridPane.margin>
+                  <Insets left="28.0" />
+               </GridPane.margin>
+            </Button>
+            <Button fx:id="btnD" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="D" textFill="#fffdfd" GridPane.columnIndex="4" GridPane.rowIndex="5">
+               <font>
+                  <Font name="System Bold" size="18.0" />
+               </font>
+               <GridPane.margin>
+                  <Insets left="28.0" />
+               </GridPane.margin>
+            </Button>
+            <Button fx:id="btnS" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="S" textFill="#fffdfd" GridPane.columnIndex="3" 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" />
+               </font>
+            </Button>
+            <Button fx:id="btnI" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="I" textFill="#fffdfd" GridPane.columnIndex="9" GridPane.rowIndex="4">
+               <font>
+                  <Font name="System Bold" size="18.0" />
+               </font>
+            </Button>
+            <Button fx:id="btnU" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="U" textFill="#fffdfd" GridPane.columnIndex="8" GridPane.rowIndex="4">
+               <font>
+                  <Font name="System Bold" size="18.0" />
+               </font>
+            </Button>
+            <Button fx:id="btnZ" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="Z" textFill="#fffdfd" GridPane.columnIndex="7" GridPane.rowIndex="4">
+               <font>
+                  <Font name="System Bold" size="18.0" />
+               </font>
+            </Button>
+            <Button fx:id="btnT" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="T" textFill="#fffdfd" GridPane.columnIndex="6" GridPane.rowIndex="4">
+               <font>
+                  <Font name="System Bold" size="18.0" />
+               </font>
+            </Button>
+            <Button fx:id="btnR" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="R" textFill="#fffdfd" GridPane.columnIndex="5" GridPane.rowIndex="4">
+               <font>
+                  <Font name="System Bold" size="18.0" />
+               </font>
+            </Button>
+            <Button fx:id="btnE" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="E" textFill="#fffdfd" GridPane.columnIndex="4" GridPane.rowIndex="4">
+               <font>
+                  <Font name="System Bold" size="18.0" />
+               </font>
+            </Button>
+            <Button fx:id="btnW" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="W" textFill="#fffdfd" GridPane.columnIndex="3" GridPane.rowIndex="4">
+               <font>
+                  <Font name="System Bold" size="18.0" />
+               </font>
+            </Button>
+            <Button fx:id="btnQ" minHeight="44.0" mnemonicParsing="false" onAction="#gedrueckteTaste" prefHeight="48.0" prefWidth="51.0" style="-fx-background-radius: 100; -fx-background-color: #0d0d0d;" text="Q" textFill="#fffdfd" GridPane.columnIndex="2" GridPane.rowIndex="4">
+               <font>
+                  <Font name="System Bold" size="18.0" />
+               </font>
+            </Button>
+            <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>
+               <GridPane.margin>
+                  <Insets left="28.0" />
+               </GridPane.margin>
+            </Button>
+            <Circle fx:id="circL" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="10" GridPane.rowIndex="2" />
+            <Circle fx:id="circM" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="9" GridPane.rowIndex="2" />
+            <Circle fx:id="circN" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="8" GridPane.rowIndex="2" />
+            <Circle fx:id="circB" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="7" GridPane.rowIndex="2" />
+            <Circle fx:id="circV" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="6" GridPane.rowIndex="2" />
+            <Circle fx:id="circC" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="5" GridPane.rowIndex="2" />
+            <Circle fx:id="circX" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="4" GridPane.rowIndex="2" />
+            <Circle fx:id="circY" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="3" GridPane.rowIndex="2" />
+            <Circle fx:id="circP" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="2" GridPane.rowIndex="2" />
+            <Circle fx:id="circK" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="9" GridPane.rowIndex="1">
+               <GridPane.margin>
+                  <Insets left="35.0" />
+               </GridPane.margin>
+            </Circle>
+            <Circle fx:id="circJ" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="8" GridPane.rowIndex="1">
+               <GridPane.margin>
+                  <Insets left="35.0" />
+               </GridPane.margin>
+            </Circle>
+            <Circle fx:id="circH" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="7" GridPane.rowIndex="1">
+               <GridPane.margin>
+                  <Insets bottom="4.0" left="42.0" />
+               </GridPane.margin>
+            </Circle>
+            <Circle fx:id="circG" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="6" GridPane.rowIndex="1">
+               <GridPane.margin>
+                  <Insets left="35.0" />
+               </GridPane.margin>
+            </Circle>
+            <Circle fx:id="circF" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="5" GridPane.rowIndex="1">
+               <GridPane.margin>
+                  <Insets left="35.0" />
+               </GridPane.margin>
+            </Circle>
+            <Circle fx:id="circD" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="4" GridPane.rowIndex="1">
+               <GridPane.margin>
+                  <Insets left="35.0" />
+               </GridPane.margin>
+            </Circle>
+            <Circle fx:id="circS" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="3" GridPane.rowIndex="1">
+               <GridPane.margin>
+                  <Insets left="35.0" />
+               </GridPane.margin>
+            </Circle>
+            <Circle fx:id="circA" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="2" GridPane.rowIndex="1">
+               <GridPane.margin>
+                  <Insets left="35.0" />
+               </GridPane.margin>
+            </Circle>
+            <Circle fx:id="circO" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="10" />
+            <Circle fx:id="circI" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="9" />
+            <Circle fx:id="circU" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="8" />
+            <Circle fx:id="circZ" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="7" />
+            <Circle fx:id="circT" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="6" />
+            <Circle fx:id="circR" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="5" />
+            <Circle fx:id="circE" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="4" />
+            <Circle fx:id="circW" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="3" />
+            <Circle fx:id="circQ" fill="#f0f3f5" radius="22.0" stroke="BLACK" strokeType="INSIDE" GridPane.columnIndex="2" />
+            <Label fx:id="lblL" alignment="CENTER" minHeight="0.0" prefHeight="30.0" prefWidth="30.0" text="L" GridPane.columnIndex="10" GridPane.rowIndex="2">
+               <font>
+                  <Font size="23.0" />
+               </font>
+               <GridPane.margin>
+                  <Insets bottom="2.0" left="7.0" />
+               </GridPane.margin>
+            </Label>
+            <Label fx:id="lblM" alignment="CENTER" minHeight="0.0" prefHeight="30.0" prefWidth="30.0" text="M" GridPane.columnIndex="9" GridPane.rowIndex="2">
+               <font>
+                  <Font size="23.0" />
+               </font>
+               <GridPane.margin>
+                  <Insets bottom="2.0" left="7.0" />
+               </GridPane.margin>
+            </Label>
+            <Label fx:id="lblN" alignment="CENTER" minHeight="0.0" prefHeight="30.0" prefWidth="30.0" text="N" GridPane.columnIndex="8" GridPane.rowIndex="2">
+               <font>
+                  <Font size="23.0" />
+               </font>
+               <GridPane.margin>
+                  <Insets bottom="2.0" left="7.0" />
+               </GridPane.margin>
+            </Label>
+            <Label fx:id="lblB" alignment="CENTER" minHeight="0.0" prefHeight="30.0" prefWidth="30.0" text="B" GridPane.columnIndex="7" GridPane.rowIndex="2">
+               <font>
+                  <Font size="23.0" />
+               </font>
+               <GridPane.margin>
+                  <Insets bottom="2.0" left="7.0" />
+               </GridPane.margin>
+            </Label>
+            <Label fx:id="lblV" alignment="CENTER" minHeight="0.0" prefHeight="30.0" prefWidth="30.0" text="V" GridPane.columnIndex="6" GridPane.rowIndex="2">
+               <font>
+                  <Font size="23.0" />
+               </font>
+               <GridPane.margin>
+                  <Insets bottom="2.0" left="7.0" />
+               </GridPane.margin>
+            </Label>
+            <Label fx:id="lblC" alignment="CENTER" minHeight="0.0" prefHeight="30.0" prefWidth="30.0" text="C" GridPane.columnIndex="5" GridPane.rowIndex="2">
+               <font>
+                  <Font size="23.0" />
+               </font>
+               <GridPane.margin>
+                  <Insets bottom="2.0" left="7.0" />
+               </GridPane.margin>
+            </Label>
+            <Label fx:id="lblX" alignment="CENTER" minHeight="0.0" prefHeight="30.0" prefWidth="30.0" text="X" GridPane.columnIndex="4" GridPane.rowIndex="2">
+               <font>
+                  <Font size="23.0" />
+               </font>
+               <GridPane.margin>
+                  <Insets bottom="2.0" left="7.0" />
+               </GridPane.margin>
+            </Label>
+            <Label fx:id="lblY" alignment="CENTER" minHeight="0.0" prefHeight="30.0" prefWidth="30.0" text="Y" GridPane.columnIndex="3" GridPane.rowIndex="2">
+               <font>
+                  <Font size="23.0" />
+               </font>
+               <GridPane.margin>
+                  <Insets bottom="2.0" left="7.0" />
+               </GridPane.margin>
+            </Label>
+            <Label fx:id="lblP" alignment="CENTER" minHeight="0.0" prefHeight="30.0" prefWidth="30.0" text="P" GridPane.columnIndex="2" GridPane.rowIndex="2">
+               <font>
+                  <Font size="23.0" />
+               </font>
+               <GridPane.margin>
+                  <Insets bottom="2.0" left="7.0" />
+               </GridPane.margin>
+            </Label>
+            <Label fx:id="lblK" alignment="CENTER" minHeight="0.0" prefHeight="30.0" prefWidth="30.0" text="K" GridPane.columnIndex="9" GridPane.rowIndex="1">
+               <font>
+                  <Font size="23.0" />
+               </font>
+               <GridPane.margin>
+                  <Insets bottom="4.0" left="42.0" />
+               </GridPane.margin>
+            </Label>
+            <Label fx:id="lblJ" alignment="CENTER" minHeight="0.0" prefHeight="30.0" prefWidth="30.0" text="J" GridPane.columnIndex="8" GridPane.rowIndex="1">
+               <font>
+                  <Font size="23.0" />
+               </font>
+               <GridPane.margin>
+                  <Insets bottom="4.0" left="42.0" />
+               </GridPane.margin>
+            </Label>
+            <Label fx:id="lblH" alignment="CENTER" minHeight="0.0" prefHeight="27.0" prefWidth="25.0" text="H" GridPane.columnIndex="7" GridPane.rowIndex="1">
+               <font>
+                  <Font size="23.0" />
+               </font>
+               <GridPane.margin>
+                  <Insets bottom="6.0" left="50.0" />
+               </GridPane.margin>
+            </Label>
+            <Label fx:id="lblG" alignment="CENTER" minHeight="0.0" prefHeight="30.0" prefWidth="30.0" text="G" GridPane.columnIndex="6" GridPane.rowIndex="1">
+               <font>
+                  <Font size="23.0" />
+               </font>
+               <GridPane.margin>
+                  <Insets bottom="4.0" left="42.0" />
+               </GridPane.margin>
+            </Label>
+            <Label fx:id="lblF" alignment="CENTER" minHeight="0.0" prefHeight="30.0" prefWidth="30.0" text="F" GridPane.columnIndex="5" GridPane.rowIndex="1">
+               <font>
+                  <Font size="23.0" />
+               </font>
+               <GridPane.margin>
+                  <Insets bottom="4.0" left="42.0" />
+               </GridPane.margin>
+            </Label>
+            <Label fx:id="lblD" alignment="CENTER" minHeight="0.0" prefHeight="30.0" prefWidth="30.0" text="D" GridPane.columnIndex="4" GridPane.rowIndex="1">
+               <font>
+                  <Font size="23.0" />
+               </font>
+               <GridPane.margin>
+                  <Insets bottom="4.0" left="42.0" />
+               </GridPane.margin>
+            </Label>
+            <Label fx:id="lblS" alignment="CENTER" minHeight="0.0" prefHeight="30.0" prefWidth="30.0" text="S" GridPane.columnIndex="3" GridPane.rowIndex="1">
+               <font>
+                  <Font size="23.0" />
+               </font>
+               <GridPane.margin>
+                  <Insets bottom="4.0" left="42.0" />
+               </GridPane.margin>
+            </Label>
+            <Label fx:id="lblA" alignment="CENTER" minHeight="0.0" prefHeight="30.0" prefWidth="30.0" text="A" GridPane.columnIndex="2" GridPane.rowIndex="1">
+               <font>
+                  <Font size="23.0" />
+               </font>
+               <GridPane.margin>
+                  <Insets bottom="4.0" left="42.0" />
+               </GridPane.margin>
+            </Label>
+            <Label fx:id="lblQ" alignment="CENTER" prefHeight="30.0" prefWidth="30.0" text="Q" GridPane.columnIndex="2">
+               <font>
+                  <Font size="23.0" />
+               </font>
+               <GridPane.margin>
+                  <Insets bottom="2.0" left="7.0" />
+               </GridPane.margin>
+            </Label>
+            <Label fx:id="lblW" alignment="CENTER" prefHeight="36.0" prefWidth="30.0" text="W" GridPane.columnIndex="3">
+               <font>
+                  <Font size="23.0" />
+               </font>
+               <GridPane.margin>
+                  <Insets bottom="1.0" left="7.0" />
+               </GridPane.margin>
+            </Label>
+            <Label fx:id="lblE" alignment="CENTER" prefHeight="30.0" prefWidth="30.0" text="E" textAlignment="CENTER" GridPane.columnIndex="4">
+               <font>
+                  <Font size="23.0" />
+               </font>
+               <GridPane.margin>
+                  <Insets bottom="2.0" left="7.0" />
+               </GridPane.margin>
+            </Label>
+            <Label fx:id="lblR" alignment="CENTER" prefHeight="30.0" prefWidth="30.0" text="R" textAlignment="CENTER" GridPane.columnIndex="5">
+               <font>
+                  <Font size="23.0" />
+               </font>
+               <GridPane.margin>
+                  <Insets bottom="2.0" left="7.0" />
+               </GridPane.margin>
+            </Label>
+            <Label fx:id="lblT" alignment="CENTER" prefHeight="30.0" prefWidth="30.0" text="T" textAlignment="CENTER" GridPane.columnIndex="6">
+               <font>
+                  <Font size="23.0" />
+               </font>
+               <GridPane.margin>
+                  <Insets bottom="2.0" left="7.0" />
+               </GridPane.margin>
+            </Label>
+            <Label fx:id="lblZ" alignment="CENTER" prefHeight="30.0" prefWidth="30.0" text="Z" textAlignment="CENTER" GridPane.columnIndex="7">
+               <font>
+                  <Font size="23.0" />
+               </font>
+               <GridPane.margin>
+                  <Insets bottom="2.0" left="7.0" />
+               </GridPane.margin>
+            </Label>
+            <Label fx:id="lblU" alignment="CENTER" prefHeight="30.0" prefWidth="30.0" text="U" textAlignment="CENTER" GridPane.columnIndex="8">
+               <font>
+                  <Font size="23.0" />
+               </font>
+               <GridPane.margin>
+                  <Insets bottom="2.0" left="7.0" />
+               </GridPane.margin>
+            </Label>
+            <Label fx:id="lblI" alignment="CENTER" prefHeight="30.0" prefWidth="30.0" text="I" textAlignment="CENTER" GridPane.columnIndex="9">
+               <font>
+                  <Font size="23.0" />
+               </font>
+               <GridPane.margin>
+                  <Insets bottom="2.0" left="7.0" />
+               </GridPane.margin>
+            </Label>
+            <Label fx:id="lblO" alignment="CENTER" prefHeight="30.0" prefWidth="30.0" text="O" textAlignment="CENTER" GridPane.columnIndex="10">
+               <font>
+                  <Font size="23.0" />
+               </font>
+               <GridPane.margin>
+                  <Insets bottom="2.0" left="7.0" />
+               </GridPane.margin>
+            </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="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="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>
+      <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" />
+            <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0" />
+          <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0" />
+          <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0" />
+        </columnConstraints>
+        <rowConstraints>
+            <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>
+         <children>
+            <Label text="Walze" />
+            <Label text="Ringe" GridPane.rowIndex="1" />
+            <Label text="Position" GridPane.rowIndex="2" />
+            <MenuButton fx:id="mBtnWalzPos1" alignment="CENTER_RIGHT" contentDisplay="CENTER" mnemonicParsing="false" prefHeight="25.0" prefWidth="48.0" text="I" GridPane.columnIndex="1">
+      </MenuButton>
+            <MenuButton fx:id="mBtnWalzPos2" alignment="CENTER_RIGHT" mnemonicParsing="false" prefHeight="25.0" prefWidth="48.0" text="I" textAlignment="CENTER" GridPane.columnIndex="2">
+      </MenuButton>
+            <MenuButton fx:id="mBtnWalzPos3" mnemonicParsing="false" popupSide="TOP" prefHeight="25.0" prefWidth="48.0" text="I" textAlignment="CENTER" GridPane.columnIndex="3">
+      </MenuButton>
+            <MenuButton fx:id="mBtnNotchPos1" alignment="CENTER_RIGHT" mnemonicParsing="false" prefHeight="25.0" prefWidth="48.0" text="1" textAlignment="CENTER" GridPane.columnIndex="1" GridPane.rowIndex="1" />
+            <MenuButton fx:id="mBtnNotchPos2" alignment="CENTER_RIGHT" mnemonicParsing="false" prefHeight="25.0" prefWidth="48.0" text="1" textAlignment="CENTER" GridPane.columnIndex="2" GridPane.rowIndex="1">
+      </MenuButton>
+      <!--      <MenuButton layoutX="93.0" layoutY="114.0" mnemonicParsing="false">-->
+      <!--         <items>-->
+      <!--            <MenuItem mnemonicParsing="false" onAction="#z1" text="1" />-->
+      <!--            <MenuItem mnemonicParsing="false" onAction="#z2" text="2" />-->
+      <!--            <MenuItem mnemonicParsing="false" onAction="#z3" text="3" />-->
+      <!--            <MenuItem mnemonicParsing="false" onAction="#z4" text="4" />-->
+      <!--            <MenuItem mnemonicParsing="false" onAction="#z5" text="5" />-->
+      <!--            <MenuItem mnemonicParsing="false" onAction="#z6" text="6" />-->
+      <!--            <MenuItem mnemonicParsing="false" onAction="#z7" text="7" />-->
+      <!--            <MenuItem mnemonicParsing="false" onAction="#z8" text="8" />-->
+      <!--            <MenuItem mnemonicParsing="false" onAction="#z9" text="9" />-->
+      <!--            <MenuItem mnemonicParsing="false" onAction="#z10" text="10" />-->
+      <!--            <MenuItem mnemonicParsing="false" onAction="#z11" text="11" />-->
+      <!--            <MenuItem mnemonicParsing="false" onAction="#z12" text="12" />-->
+      <!--            <MenuItem mnemonicParsing="false" onAction="#z13" text="13" />-->
+      <!--            <MenuItem mnemonicParsing="false" onAction="#z14" text="14" />-->
+      <!--            <MenuItem mnemonicParsing="false" onAction="#z15" text="15" />-->
+      <!--            <MenuItem mnemonicParsing="false" onAction="#z16" text="16" />-->
+      <!--            <MenuItem mnemonicParsing="false" onAction="#z17" text="17" />-->
+      <!--            <MenuItem mnemonicParsing="false" onAction="#z18" text="18" />-->
+      <!--            <MenuItem mnemonicParsing="false" onAction="#z19" text="19" />-->
+      <!--            <MenuItem mnemonicParsing="false" onAction="#z20" text="20" />-->
+      <!--            <MenuItem mnemonicParsing="false" onAction="#z21" text="21" />-->
+      <!--            <MenuItem mnemonicParsing="false" onAction="#z22" text="22" />-->
+      <!--            <MenuItem mnemonicParsing="false" onAction="#z23" text="23" />-->
+      <!--            <MenuItem mnemonicParsing="false" onAction="#z24" text="24" />-->
+      <!--            <MenuItem mnemonicParsing="false" onAction="#z25" text="25" />-->
+      <!--            <MenuItem mnemonicParsing="false" onAction="#z26" text="26" />-->
+      <!--         </items>-->
+      <!--      </MenuButton>-->
+            <MenuButton fx:id="mBtnNotchPos3" alignment="CENTER_RIGHT" mnemonicParsing="false" prefHeight="25.0" prefWidth="48.0" text="1" textAlignment="CENTER" GridPane.columnIndex="3" GridPane.rowIndex="1">
+      </MenuButton>
+            <MenuButton fx:id="mBtnStartPos1" alignment="CENTER_RIGHT" mnemonicParsing="false" prefHeight="25.0" prefWidth="48.0" text="A" textAlignment="CENTER" GridPane.columnIndex="1" GridPane.rowIndex="2">
+      </MenuButton>
+            <MenuButton fx:id="mBtnStartPos2" alignment="CENTER_RIGHT" mnemonicParsing="false" prefHeight="25.0" prefWidth="48.0" text="A" textAlignment="CENTER" GridPane.columnIndex="2" GridPane.rowIndex="2">
+      </MenuButton>
+            <MenuButton fx:id="mBtnStartPos3" alignment="CENTER_RIGHT" mnemonicParsing="false" prefHeight="25.0" prefWidth="48.0" text="A" textAlignment="CENTER" GridPane.columnIndex="3" GridPane.rowIndex="2">
+      </MenuButton>
+         </children>
+      </GridPane>
+      <FlowPane layoutX="736.0" layoutY="51.0" prefHeight="173.0" prefWidth="195.0" AnchorPane.rightAnchor="36.0" AnchorPane.topAnchor="51.0">
+         <children>
+            <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
new file mode 100644
index 0000000000000000000000000000000000000000..2cedf3644a5b65ea0c8f53751137ac55e051acd3
--- /dev/null
+++ b/src/main/resources/projekt/enigma/kenngruppe.fxml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import javafx.scene.control.Button?>
+<?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="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">
+         <children>
+            <Button fx:id="secondaryButton" onAction="#switchToPrimary" prefHeight="25.0" prefWidth="142.0" text="Kenngruppe bestätigen!" />
+            <Label prefHeight="17.0" prefWidth="159.0" text="Label" />
+            <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/Enigma/model/CodebuchTest.java b/src/test/java/Enigma/model/CodebuchTest.java
deleted file mode 100644
index 91e265342537fdf07e92ca735f9e377b48b4e424..0000000000000000000000000000000000000000
--- a/src/test/java/Enigma/model/CodebuchTest.java
+++ /dev/null
@@ -1,33 +0,0 @@
-package Enigma.model;
-
-import org.junit.Assert;
-import org.junit.Test;
-import java.sql.SQLException;
-
-public class CodebuchTest {
-
-	@Test
-	public void testToString() {
-		String expected = "Tag: 1\n" +
-				"Walzenlage: 1,3,2\n" +
-				"Ringstellung: 16,11,13\n" +
-				"Steckverbindung: CO,DI,FR,HU,JW,LS,TX\n";
-
-		try {
-			// Codebuch abrufen
-			Codebuch cb = new DatenbankSqlite().getCodebuch(1);
-			// Ausgabe auf der Konsole
-			String result = new DatenbankSqlite().getCodebuch(1).toString();
-			Assert.assertEquals(expected, result);
-		} catch (SQLException e) {
-			e.printStackTrace();
-		}
-	}
-
-	@Test
-	public void getTag() {
-		Codebuch cb = new Codebuch();
-		cb.setTag(1);
-		Assert.assertEquals(1, cb.getTag());
-	}
-}
\ No newline at end of file
diff --git a/src/test/java/Enigma/model/SteckbrettTest.java b/src/test/java/Enigma/model/SteckbrettTest.java
deleted file mode 100644
index df6051df00bcd397568a5e9e88ba5295eba803a0..0000000000000000000000000000000000000000
--- a/src/test/java/Enigma/model/SteckbrettTest.java
+++ /dev/null
@@ -1,36 +0,0 @@
-package Enigma.model;
-
-import org.junit.Assert;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-public class SteckbrettTest {
-
-	@Test
-	public void setzeVertauschung() {
-		/*Steckbrett sb = new Steckbrett();
-		sb.setzeVertauschung('A', 'G');
-		sb.setzeVertauschung('C', 'H');
-		Assert.assertEquals('H', sb.codiere('C'));
-		Assert.assertEquals('G', sb.codiere('A'));*/
-	}
-
-	@Test
-	public void codiere() {
-		/*Steckbrett sb = new Steckbrett();
-		sb.setzeVertauschung('A', 'G');
-		sb.setzeVertauschung('C', 'H');
-		Assert.assertEquals('H', sb.codiere('C'));
-		Assert.assertEquals('G', sb.codiere('A'));*/
-	}
-
-	@Test
-	public void codiere2() {
-		/*Steckbrett sb = new Steckbrett();
-		sb.setzeVertauschung('A', 'G');
-		sb.setzeVertauschung('C', 'H');
-		Assert.assertEquals('C', sb.codiere2('H'));
-		Assert.assertEquals('A', sb.codiere2('G'));*/
-	}
-}
\ No newline at end of file
diff --git a/src/test/java/Enigma/model/WalzeTest.java b/src/test/java/Enigma/model/WalzeTest.java
deleted file mode 100644
index 1c58136c318dbbdce13c250cbadba805805aa0ad..0000000000000000000000000000000000000000
--- a/src/test/java/Enigma/model/WalzeTest.java
+++ /dev/null
@@ -1,45 +0,0 @@
-package Enigma.model;
-
-import org.junit.Assert;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-public class WalzeTest {
-
-	@Test
-	public void setzeNotch() {
-		/*Walze w = new Walze(1);
-		w.setzeNotch('G');
-		Assert.assertEquals('G', w.wlazenPosition());*/
-	}
-
-	@Test
-	public void dreheWalze() {
-		/*Walze w = new Walze(1);
-		w.setzeNotch('G');
-		w.dreheWalze();
-		Assert.assertEquals('H', w.wlazenPosition());*/
-	}
-
-	@Test
-	public void walzenPoition() {
-		/*Walze w = new Walze(1);
-		w.setzeNotch('G');
-		Assert.assertEquals('G', w.wlazenPosition());*/
-	}
-
-	@Test
-	public void codiere() {
-		/*Walze w = new Walze(1);
-		w.setzeNotch('A');
-		Assert.assertEquals('E', w.codiere('A'));*/
-	}
-
-	@Test
-	public void codiere2() {
-		/*Walze w = new Walze(1);
-		w.setzeNotch('A');
-		Assert.assertEquals('A', w.codiere('E'));*/
-	}
-}
\ No newline at end of file
diff --git a/src/test/java/projekt/enigma/model/CodebuchTest.java b/src/test/java/projekt/enigma/model/CodebuchTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..ce7da24a9153fcda79ae1811ac3759e58327a21a
--- /dev/null
+++ b/src/test/java/projekt/enigma/model/CodebuchTest.java
@@ -0,0 +1,28 @@
+package projekt.enigma.model;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class CodebuchTest {
+
+	@Test
+	public void testToString() {
+		String expected = "Tag: 1\n" +
+				"Walzenlage: 1,3,2\n" +
+				"Ringstellung: 16,11,13\n" +
+				"Steckverbindung: E:U,O:H,T:Z,A:S,M:R,I:V,C:G,F:Q,B:X,Y:K\n";
+
+		// Ausgabe auf der Konsole
+		Codebuch cb = new Codebuch();
+		cb.fetchTagesschluessel(1);
+		String result = cb.toString();
+		Assert.assertEquals(result, expected, result);
+	}
+
+	@Test
+	public void getTag() {
+		Codebuch cb = new Codebuch();
+		cb.setTag(1);
+		Assert.assertEquals(1, cb.getTag());
+	}
+}
\ No newline at end of file
diff --git a/src/test/java/projekt/enigma/model/HardwareTest.java b/src/test/java/projekt/enigma/model/HardwareTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..8c1fc82e3ffb96e35caf063154630e06a8a434b8
--- /dev/null
+++ b/src/test/java/projekt/enigma/model/HardwareTest.java
@@ -0,0 +1,64 @@
+package projekt.enigma.model;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class HardwareTest {
+
+	@Test
+	public void tippeBuchstabe() {
+
+		Hardware h = new Hardware();
+		h.setReflektor(new Reflektor());
+		h.setSteckbrett(new Steckbrett());
+		h.setWalzen(0, 1, 1);
+		h.setWalzen(1, 2, 1);
+		h.setWalzen(2, 3, 1);
+
+		/*
+        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'};
+		*/
+
+		char result;
+		h.resetWalzen();
+		result = h.codiere('A');
+		Assert.assertEquals("Codiere: A Erwartet G, erhalten " + result, 'G', result);
+		result = h.codiere('B');
+		Assert.assertEquals("Codiere: B Erwartet H, erhalten " + result, 'H', result);
+		result = h.codiere('I');
+		Assert.assertEquals("Codiere: I Erwartet C, erhalten " + result, 'C', result);
+		result = h.codiere('F');
+		Assert.assertEquals("Codiere: F Erwartet U, erhalten " + result, 'U', result);
+
+		h.resetWalzen();
+		result = h.codiere('G');
+		Assert.assertEquals("Decodiere: G Erwartet A, erhalten " + result, 'A', result);
+		result = h.codiere('H');
+		Assert.assertEquals("Decodiere: R Erwartet H, erhalten " + result, 'B', result);
+		result = h.codiere('C');
+		Assert.assertEquals("Decodiere: C Erwartet I, erhalten " + result, 'I', result);
+		result = h.codiere('U');
+		Assert.assertEquals("Decodiere: U Erwartet F, erhalten " + result, 'F', result);
+
+		h.resetWalzen();
+		h.getSteckbrett().setzeVertauschung('B', 'G');
+		h.getSteckbrett().setzeVertauschung('D', 'F');
+		h.getSteckbrett().setzeVertauschung('I', 'L');
+		h.getSteckbrett().setzeVertauschung('M', 'Q');
+		h.getSteckbrett().setzeVertauschung('T', 'X');
+
+		result = h.codiere('I');
+		Assert.assertEquals("Codiere: I Erwartet F, erhalten " + result, 'F', result);
+
+		h.resetWalzen();
+		result = h.codiere('K');
+		Assert.assertEquals("Codiere: K Erwartet D, erhalten " + result, 'D', result);
+	}
+}
\ No newline at end of file
diff --git a/src/test/java/Enigma/model/ReflektorTest.java b/src/test/java/projekt/enigma/model/ReflektorTest.java
similarity index 78%
rename from src/test/java/Enigma/model/ReflektorTest.java
rename to src/test/java/projekt/enigma/model/ReflektorTest.java
index 74ab4f6410b5aa1592c9ed50903372ef774c70f5..8cb11a94b3c94191e9d0cdec15ddfbf97f5d27ea 100644
--- a/src/test/java/Enigma/model/ReflektorTest.java
+++ b/src/test/java/projekt/enigma/model/ReflektorTest.java
@@ -1,4 +1,4 @@
-package Enigma.model;
+package projekt.enigma.model;
 
 import org.junit.Assert;
 import org.junit.Test;
@@ -7,7 +7,6 @@ public class ReflektorTest {
 
 	@Test
 	public void codiere() {
-		/*
 		Reflektor r = new Reflektor();
 
 		Assert.assertEquals('E', r.codiere('A'));
@@ -15,19 +14,10 @@ public class ReflektorTest {
 		Assert.assertEquals('X', r.codiere('H'));
 		Assert.assertEquals('O', r.codiere('Q'));
 		Assert.assertEquals('I', r.codiere('V'));
-		//Assert.assertNull(null, r.codiere(null));
-		*/
-	}
-
-	@Test
-	public void codiere2() {
-		/*
-		Reflektor r = new Reflektor();
 		Assert.assertEquals('A', r.codiere('E'));
 		Assert.assertEquals('D', r.codiere('Z'));
 		Assert.assertEquals('H', r.codiere('X'));
 		Assert.assertEquals('Q', r.codiere('O'));
 		Assert.assertEquals('V', r.codiere('I'));
-		*/
 	}
 }
\ No newline at end of file
diff --git a/src/test/java/projekt/enigma/model/SteckbrettTest.java b/src/test/java/projekt/enigma/model/SteckbrettTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..689b923f05fa2261a0b75ce33b9905221eb3fac6
--- /dev/null
+++ b/src/test/java/projekt/enigma/model/SteckbrettTest.java
@@ -0,0 +1,25 @@
+package projekt.enigma.model;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class SteckbrettTest {
+
+	@Test
+	public void setzeVertauschung() {
+		Steckbrett sb = new Steckbrett();
+		sb.setzeVertauschung('A', 'G');
+		sb.setzeVertauschung('C', 'H');
+		Assert.assertEquals('H', sb.codiere('C'));
+		Assert.assertEquals('G', sb.codiere('A'));
+	}
+
+	@Test
+	public void codiere() {
+		Steckbrett sb = new Steckbrett();
+		sb.setzeVertauschung('A', 'G');
+		sb.setzeVertauschung('C', 'H');
+		Assert.assertEquals('H', sb.codiere('C'));
+		Assert.assertEquals('G', sb.codiere('A'));
+	}
+}
\ 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
new file mode 100644
index 0000000000000000000000000000000000000000..a53f3832b36f9bffa8fba90d0c7919be12ddb09d
--- /dev/null
+++ b/src/test/java/projekt/enigma/model/WalzeTest.java
@@ -0,0 +1,45 @@
+package projekt.enigma.model;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class WalzeTest {
+
+	@Test
+	public void setRingstellung() {
+		Walze w = new Walze(1, 1);
+		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(1));
+		char temp = w.getPosition();
+		Assert.assertEquals("B erwartet, " + temp + " zurück gegeben", 'B', temp);
+	}
+
+	@Test
+	public void getPosition() {
+		Walze w = new Walze(1, 1);
+		char temp = w.getPosition();
+		Assert.assertEquals('A', temp);
+	}
+
+	@Test
+	public void codiere() {
+		Walze w = new Walze(1, 1);
+		char result = w.codiere('G');
+		Assert.assertEquals("Erwartet D erhalten " + result, 'D', result);
+	}
+
+	@Test
+	public void codiere2() {
+		Walze w = new Walze(1, 1);
+		char result = w.codiere2('E');
+		Assert.assertEquals("Erwartet A erhalten " + result, 'A', result);
+	}
+}
\ No newline at end of file