Merge pull request 'advancedSE-paul' (#3) from advancedSE-paul into advancedSE

Reviewed-on: #3

.idea/misc.xml

@@ -1,5 +1,10 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
+  <component name="EntryPointsManager">
+    <writeAnnotations>
+      <writeAnnotation name="javafx.fxml.FXML" />
+    </writeAnnotations>
+  </component>
   <component name="ExternalStorageConfigurationManager" enabled="true" />
   <component name="MavenProjectsManager">
     <option name="originalFiles">
@@ -8,7 +13,7 @@
       </list>
     </option>
   </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_19" default="true" project-jdk-name="19" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_21" default="true" project-jdk-name="19" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
 </project>

eeprom.json

@@ -0,0 +1,3 @@
+{
+
+}

pom.xml

@@ -45,6 +45,18 @@
             <artifactId>ikonli-javafx</artifactId>
             <version>12.3.1</version>
         </dependency>
+        <dependency>
+            <groupId>com.gluonhq</groupId>
+            <artifactId>charm-glisten</artifactId>
+            <version>4.4.1</version>
+            <scope>system</scope>
+            <systemPath>${project.basedir}/libs/com.gluon/charm-glisten-4.4.1.jar</systemPath>
+        </dependency>
+        <dependency>
+            <groupId>com.googlecode.json-simple</groupId>
+            <artifactId>json-simple</artifactId>
+            <version>1.1.1</version>
+        </dependency>
         <dependency>
             <groupId>eu.hansolo</groupId>
             <artifactId>tilesfx</artifactId>
@@ -68,6 +80,13 @@
             <version>${junit.version}</version>
             <scope>test</scope>
         </dependency>
+        <!-- https://mvnrepository.com/artifact/org.mockito/mockito-core -->
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <version>5.17.0</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <build>
@@ -101,6 +120,24 @@
                     </execution>
                 </executions>
             </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-dependency-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>properties</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <configuration>
+                    <argLine>@{argLine} -javaagent:${org.mockito:mockito-core:jar}</argLine>
+                </configuration>
+            </plugin>
         </plugins>
     </build>
 </project>

src/main/java/fabrik/simulator/pic16f84/Commands.java

@@ -1,13 +1,39 @@
 package fabrik.simulator.pic16f84;
 
-public class Commands {
+import fabrik.simulator.pic16f84.interfaces.*;
-    private static int wRegister = 0;
 
-    public static int get_wRegister() {
+public class Commands extends ExecutionTimeSubject implements CommandInterface {
+    private int wRegister;
+    private long totalExecutionTime;
+    private double executionTimeMultiplier = 1;
+
+    public Commands(){
+        super();
+        wRegister = 0;
+        totalExecutionTime = 0;
+    }
+
+    public int get_wRegister() {
         return wRegister;
     }
 
-    public static void decode(int instruction){
+    public void addExecutionTime(int i) {
+        totalExecutionTime +=  i;
+        super.notifyObservers();
+    }
+
+    @Override
+    public double getTotalExecutionTime() {
+        return (totalExecutionTime * getExecutionTimeMultiplier());
+    }
+
+    public void resetTotalExecutionTime() {
+        totalExecutionTime = 0;
+        super.notifyObservers();
+    }
+
+
+    public void decode(int instruction){
         final int jumpaddr = 0x7FF;
         final int fileregaddr = 0x7F;
         final int constant = 0xFF;
@@ -24,10 +50,12 @@ public class Commands {
             case 0b10000000000000:
                 System.out.println("CALL: " + j);
                 CALL (j);
+                addExecutionTime(2);
                 return;
             case 0b10100000000000:
                 System.out.println("GOTO: " + j);
                 GOTO (j);
+                addExecutionTime(2);
                 return;
             default:
                 break;
@@ -36,27 +64,33 @@ public class Commands {
         switch (instruction & 0x3C00){
             case 0b01000000000000:
                 System.out.println("BCF: " + f + " " + b);
-                DataRegister.clearBit(f, b);
+                dataRegister.clearBit(f, b);
+                addExecutionTime(1);
                 return;
             case 0b01010000000000:
                 System.out.println("BSF: " + f + " " + b);
-                DataRegister.setBit(f, b);
+                dataRegister.setBit(f, b);
+                addExecutionTime(1);
                 return;
             case 0b01100000000000:
                 System.out.println("BTFSC: " + f + " " + b);
                 BTFSC(f, b);
+                addExecutionTime(1);
                 return;
             case 0b01110000000000:
                 System.out.println("BTFSS: " + f + " " + b);
                 BTFSS(f, b);
+                addExecutionTime(1);
                 return;
             case 0b11000000000000:
                 System.out.println("MOVLW: " + k);
                 MOVLW (k);
+                addExecutionTime(1);
                 return;
             case 0b11010000000000:
                 System.out.println("RETLW: " + k);
                 RETLW (k);
+                addExecutionTime(2);
                 return;
             default:
                 break;
@@ -66,10 +100,12 @@ public class Commands {
             case 0b11111000000000:
                 System.out.println("ADDLW: " + k);
                 ADDLW (k);
+                addExecutionTime(1);
                 return;
             case 0b11110000000000:
                 System.out.println("SUBLW: " + k);
                 SUBLW (k);
+                addExecutionTime(1);
                 return;
             default:
                 break;
@@ -79,70 +115,88 @@ public class Commands {
             case 0b00011100000000:
                 System.out.println("ADDWF: " + f + " " + d);
                 ADDWF (f, d);
+                addExecutionTime(1);
                 return;
             case 0b00010100000000:
                 System.out.println("ANDWF: " + f + " " + d);
                 ANDWF (f, d);
+                addExecutionTime(1);
                 return;
             case 0b00100100000000:
                 System.out.println("COMF: " + f + " " + d);
                 COMF (f, d);
+                addExecutionTime(1);
                 return;
             case 0b00001100000000:
                 System.out.println("DECF: " + f + " " + d);
                 DECF (f, d);
+                addExecutionTime(1);
                 return;
             case 0b00101100000000:
+                //1 bzw 2 Laufzeitpunkte
                 System.out.println("DECFSZ: " + f + " " + d);
                 DECFSZ (f, d);
+                addExecutionTime(1);
                 return;
             case 0b00101000000000:
                 System.out.println("INCF: " + f + " " + d);
                 INCF (f, d);
+                addExecutionTime(1);
                 return;
             case 0b00111100000000:
                 System.out.println("INCFSZ: " + f + " " + d);
                 INCFSZ (f, d);
+                addExecutionTime(1);
                 return;
             case 0b00010000000000:
                 System.out.println("IORWF: " + f + " " + d);
                 IORWF (f, d);
+                addExecutionTime(1);
                 return;
             case 0b00100000000000:
                 System.out.println("MOVF: " + f + " " + d);
                 MOVF (f, d);
+                addExecutionTime(1);
                 return;
             case 0b00110100000000:
                 System.out.println("RLF: " + f + " " + d);
                 RLF (f, d);
+                addExecutionTime(1);
                 return;
             case 0b00110000000000:
                 System.out.println("RRF: " + f + " " + d);
                 RRF (f, d);
+                addExecutionTime(1);
                 return;
             case 0b00001000000000:
                 System.out.println("SUBWF: " + f + " " + d);
                 SUBWF (f, d);
+                addExecutionTime(1);
                 return;
             case 0b00111000000000:
                 System.out.println("SWAPF: " + f + " " + d);
                 SWAPF (f, d);
+                addExecutionTime(1);
                 return;
             case 0b00011000000000:
                 System.out.println("XORWF: " + f + " " + d);
                 XORWF (f, d);
+                addExecutionTime(1);
                 return;
             case 0b11100100000000:
                 System.out.println("ANDLW: " + k);
                 ANDLW (k);
+                addExecutionTime(1);
                 return;
             case 0b11101000000000:
                 System.out.println("XORLW: " + k);
                 XORLW (k);
+                addExecutionTime(1);
                 return;
             case 0b11100000000000:
                 System.out.println("IORLW: " + k);
                 IORLW (k);
+                addExecutionTime(1);
                 return;
             default:
                 break;
@@ -152,14 +206,17 @@ public class Commands {
             case 0b00000110000000:
                 System.out.println("CLRF: " + f);
                 CLRF (f);
+                addExecutionTime(1);
                 return;
             case 0b00000100000000:
                 System.out.println("CLRW");
                 CLRW ();
+                addExecutionTime(1);
                 return;
             case 0b00000010000000:
                 System.out.println("MOVWF: " + f);
                 MOVWF (f);
+                addExecutionTime(1);
                 return;
             default:
                 break;
@@ -168,298 +225,369 @@ public class Commands {
         switch (instruction){
             case 0b01100100:
                 System.out.println("CLRWDT");
-                //TODO
+                watchdogTimer.reset();
                 return;
             case 0b1001:
                 System.out.println("RETFIE");
                 RETFIE();
+                addExecutionTime(2);
                 return;
             case 0b1000:
                 System.out.println("RETURN");
-                DataRegister.setPC(ProgramStack.pop());
+                dataRegister.setPC(programStack.pop());
                 return;
             case 0b01100011:
                 System.out.println("SLEEP");
-                //TODO
+                SLEEP();
+                addExecutionTime(1);
                 return;
             default:
                 break;
         }
 
         if (instruction == 0 || instruction == 0b0110000 || instruction == 0b01000000 || instruction == 0b00100000){
-            System.out.println("NOP");
+            NOP ();
         }
         else{
             System.out.println("Nicht gefunden!");
         }
-
-
     }
 
-    public static void RETFIE() {
+    public void SLEEP() {
-        DataRegister.setPC(ProgramStack.pop());
+        ExecutionState.sleep();
     }
 
-    public static void GOTO(int jump) {
+    public void RETFIE() {
-        DataRegister.setPC(jump-1);
+        dataRegister.setBit(dataRegister.getINTCON(), 7); // GIE wieder setzen
+        dataRegister.setPC(programStack.pop());
     }
 
-    public static void CALL(int jump) {
+    public void NOP () {
-        ProgramStack.push(DataRegister.getPC()+1);
+        System.out.println("NOP");
-        DataRegister.setPC(jump-1);
+        addExecutionTime(1);
     }
 
-    public static void MOVWF(int file) {
+    public void GOTO(int jump) {
-        DataRegister.setRegister(file, wRegister);
+        dataRegister.setPC(jump-1);
     }
 
-    public static void CLRW() {
+    public void CALL(int jump) {
+        programStack.push(dataRegister.getPC()+1);
+        dataRegister.setPC(jump-1);
+        addExecutionTime(1);
+    }
+
+    public void MOVWF(int file) {
+        dataRegister.setRegister(file, wRegister);
+    }
+
+    public void CLRW() {
         wRegister = 0;
-        DataRegister.determineZeroFlag(wRegister);
+        dataRegister.determineZeroFlag(wRegister);
+
+        addExecutionTime(1);
+
     }
 
-    public static void CLRF(int file) {
+    public void CLRF(int file) {
-        DataRegister.setRegister(file, 0);
+        dataRegister.setRegister(file, 0);
-        DataRegister.determineZeroFlag(DataRegister.getRegister(file));
+        dataRegister.determineZeroFlag(dataRegister.getRegister(file));
+
+
     }
 
-    public static void IORLW(int literal) {
+    public void IORLW(int literal) {
         wRegister |= literal;
-        DataRegister.determineZeroFlag(wRegister);
+        dataRegister.determineZeroFlag(wRegister);
     }
 
-    public static void XORLW(int literal) {
+    public void XORLW(int literal) {
         wRegister ^= literal;
-        DataRegister.determineZeroFlag(wRegister);
+        dataRegister.determineZeroFlag(wRegister);
     }
 
-    public static void ANDLW(int literal) {
+    public void ANDLW(int literal) {
         wRegister &= literal;
-        DataRegister.determineZeroFlag(wRegister);
+        dataRegister.determineZeroFlag(wRegister);
     }
 
-    public static void XORWF(int file, int destination) {
+    public void XORWF(int file, int destination) {
-        int result = wRegister ^ DataRegister.getRegister(file);
+        int result = wRegister ^ dataRegister.getRegister(file);
         if (destination == 0){
             wRegister = result;
         }
         else {
-            DataRegister.setRegister(file, result);
+            dataRegister.setRegister(file, result);
         }
-        DataRegister.determineZeroFlag(result);
+        dataRegister.determineZeroFlag(result);
+
+
     }
 
-    public static void SWAPF(int file, int destination) {
+    public void SWAPF(int file, int destination) {
-        int content = DataRegister.getRegister(file);
+        int content = dataRegister.getRegister(file);
         int result = (content & 0x0F) << 4 | (content & 0xF0) >> 4;
         if (destination == 0){
             wRegister = result;
         }
         else {
-            DataRegister.setRegister(file, result);
+            dataRegister.setRegister(file, result);
-        }
         }
 
-    public static void SUBWF(int file, int destination) {
+    }
-        int result = (DataRegister.getRegister(file) - wRegister) ;
+
+    public void SUBWF(int file, int destination) {
+        int result = (dataRegister.getRegister(file) - wRegister) ;
         if (wRegister == 0 || result >= 0){
-            DataRegister.setCarryFlag(1);
+            dataRegister.setCarryFlag(1);
-            DataRegister.setDigitCarryFlag(1);
+            dataRegister.setDigitCarryFlag(1);
         }
         else {
-            DataRegister.setCarryFlag(0);
+            dataRegister.setCarryFlag(0);
-            DataRegister.setDigitCarryFlag(0);
+            dataRegister.setDigitCarryFlag(0);
         }
         if (destination == 0){
             wRegister = result & 0xFF;
         }
         else {
-            DataRegister.setRegister(file, result & 0xFF);
+            dataRegister.setRegister(file, result & 0xFF);
         }
-        DataRegister.determineZeroFlag(result);
+        dataRegister.determineZeroFlag(result);
+        addExecutionTime(1);
     }
 
-    public static void RLF(int file, int destination) {
+    public void RLF(int file, int destination) {
-        int fcontent = DataRegister.getRegister(file);
+        int fcontent = dataRegister.getRegister(file);
-        int carry = DataRegister.getCarryFlag();
+        int carry = dataRegister.getCarryFlag();
         int result = (fcontent << 1) | carry;
-        DataRegister.determineCarryFlag(result);
+        dataRegister.determineCarryFlag(result);
         if (destination == 0){
             wRegister = result & 0xFF;
         }
         else {
-            DataRegister.setRegister(file, result & 0xFF);
+            dataRegister.setRegister(file, result & 0xFF);
-        }
         }
 
-    public static void RRF(int file, int destination) {
+    }
-        int fcontent = DataRegister.getRegister(file);
+
-        int carry = DataRegister.getCarryFlag() << 7;
+    public void RRF(int file, int destination) {
+        int fcontent = dataRegister.getRegister(file);
+        int carry = dataRegister.getCarryFlag() << 7;
         int contentlow = fcontent & 0b1;
-        int result = fcontent >> 1 | carry;
+        int result = (fcontent >> 1) | carry;
-        DataRegister.setCarryFlag(contentlow);
+        dataRegister.setCarryFlag(contentlow);
         if (destination == 0){
             wRegister = result & 0xFF;
         }
         else {
-            DataRegister.setRegister(file, result & 0xFF);
+            dataRegister.setRegister(file, result & 0xFF);
-        }
         }
 
-    public static void MOVF(int file, int destination) {
+    }
-        int content = DataRegister.getRegister(file);
+
+    public void MOVF(int file, int destination) {
+        int content = dataRegister.getRegister(file);
         if (destination == 0){
             wRegister = content;
         }
         else {
-            DataRegister.setRegister(file, content);
+            dataRegister.setRegister(file, content);
         }
-        DataRegister.determineZeroFlag(content);
+        dataRegister.determineZeroFlag(content);
     }
 
-    public static void IORWF(int file, int destination) {
+    public void IORWF(int file, int destination) {
-        int result = wRegister | DataRegister.getRegister(file);
+        int result = wRegister | dataRegister.getRegister(file);
         if (destination == 0){
             wRegister = result;
         }
         else {
-            DataRegister.setRegister(file, result);
+            dataRegister.setRegister(file, result);
         }
-        DataRegister.determineZeroFlag(result);
+        dataRegister.determineZeroFlag(result);
     }
 
-    public static void INCFSZ(int file, int destination) {
+    public void INCFSZ(int file, int destination) {
-        int result = (DataRegister.getRegister(file) + 1) & 0xFF;
+        int result = (dataRegister.getRegister(file) + 1) & 0xFF;
         if (destination == 0){
             wRegister = result;
+            addExecutionTime(1);
         }
         else {
-            DataRegister.setRegister(file, result);
+            dataRegister.setRegister(file, result);
+
         }
         if (result == 0) {
-            DataRegister.increasePC();
+            dataRegister.increasePC();
         }
     }
 
-    public static void INCF(int file, int destination) {
+    public void INCF(int file, int destination) {
-        int result = (DataRegister.getRegister(file) + 1) & 0xFF;
+        int result = (dataRegister.getRegister(file) + 1) & 0xFF;
         if (destination == 0){
             wRegister = result;
         }
         else {
-            DataRegister.setRegister(file, result);
+            dataRegister.setRegister(file, result);
         }
-        DataRegister.determineZeroFlag(result);
+        dataRegister.determineZeroFlag(result);
+
     }
 
-    public static void DECFSZ(int file, int destination) {
+    public void DECFSZ(int file, int destination) {
-        int result = (DataRegister.getRegister(file) -1) & 0xFF;
+        int result = (dataRegister.getRegister(file) -1) & 0xFF;
         if (destination == 0){
             wRegister = result;
+            addExecutionTime(1);
+
         }
         else {
-            DataRegister.setRegister(file, result);
+            dataRegister.setRegister(file, result);
+
         }
         if (result == 0){
-            DataRegister.increasePC();
+            dataRegister.increasePC();
         }
     }
 
-    public static void DECF(int file, int destination) {
+    public void DECF(int file, int destination) {
-        int result = (DataRegister.getRegister(file) -1) & 0xFF;
+        int result = (dataRegister.getRegister(file) -1) & 0xFF;
         if (destination == 0){
             wRegister = result;
         }
         else {
-            DataRegister.setRegister(file, result);
+            dataRegister.setRegister(file, result);
         }
-        DataRegister.determineZeroFlag(result);
+        dataRegister.determineZeroFlag(result);
+
+
     }
 
-    private static void COMF(int file, int destination) {
+    private void COMF(int file, int destination) {
-        int result = (~ DataRegister.getRegister(file)) & 0xFF;
+        int result = (~ dataRegister.getRegister(file)) & 0xFF;
         if (destination == 0){
             wRegister = result;
         }
         else {
-            DataRegister.setRegister(file, result);
+            dataRegister.setRegister(file, result);
         }
-        DataRegister.determineZeroFlag(result);
+        dataRegister.determineZeroFlag(result);
+
+
+
     }
 
-    public static void ANDWF(int file, int destination) {
+    public void ANDWF(int file, int destination) {
-        int result = wRegister & DataRegister.getRegister(file);
+        int result = wRegister & dataRegister.getRegister(file);
         if (destination == 0){
             wRegister = result & 0xFF;
         }
         else {
-            DataRegister.setRegister(file, result & 0xFF);
+            dataRegister.setRegister(file, result & 0xFF);
         }
-        DataRegister.determineZeroFlag(result);
+        dataRegister.determineZeroFlag(result);
-        DataRegister.determineCarryFlag(result);
+        dataRegister.determineCarryFlag(result);
-        DataRegister.determineDigitCarryFlag(result);
+        dataRegister.determineDigitCarryFlag((wRegister&0b11101111) & (dataRegister.getRegister(file)&0b1111));
+
     }
 
-    public static void ADDWF(int file, int destination) {
+    public void ADDWF(int file, int destination) {
-        int result = wRegister + DataRegister.getRegister(file);
+        int result = wRegister + dataRegister.getRegister(file);
-        if (wRegister == 0 || DataRegister.getRegister(file) == 0){
+        if (wRegister == 0 || dataRegister.getRegister(file) == 0){
-            DataRegister.setCarryFlag(0);
+            dataRegister.setCarryFlag(0);
-            DataRegister.setDigitCarryFlag(0);
+            dataRegister.setDigitCarryFlag(0);
         }
         else {
-            DataRegister.determineCarryFlag(result);
+            dataRegister.determineCarryFlag(result);
-            DataRegister.determineDigitCarryFlag(result);
+            dataRegister.determineDigitCarryFlag((wRegister&0b11101111) + (dataRegister.getRegister(file)&0b1111));
         }
         if (destination == 0) {
             wRegister = result & 0xFF;
         }
         else {
-            DataRegister.setRegister(file, result & 0xFF);
+            dataRegister.setRegister(file, result & 0xFF);
         }
-        DataRegister.determineZeroFlag(result);
+        dataRegister.determineZeroFlag(result);
+
+
     }
 
-    public static void SUBLW(int literal) {
+    public void SUBLW(int literal) {
         int result = literal - wRegister;
         if (wRegister == 0 || result >= 0){
-            DataRegister.setCarryFlag(1);
+            dataRegister.setCarryFlag(1);
-            DataRegister.setDigitCarryFlag(1);
+            dataRegister.setDigitCarryFlag(1);
         }
         else {
 
-            DataRegister.setCarryFlag(0);
+            dataRegister.setCarryFlag(0);
-            DataRegister.setDigitCarryFlag(0);
+            dataRegister.setDigitCarryFlag(0);
         }
         wRegister = result & 0xFF;
-        DataRegister.determineZeroFlag(result);
+        dataRegister.determineZeroFlag(result);
     }
 
-    public static void ADDLW(int literal) {
+    public void ADDLW(int literal) {
         int result = wRegister + literal;
         wRegister = result & 0xFF;
-        DataRegister.determineZeroFlag(result);
+        dataRegister.determineZeroFlag(result);
-        DataRegister.determineCarryFlag(result);
+        dataRegister.determineCarryFlag(result);
-        DataRegister.determineDigitCarryFlag(result);
+        dataRegister.determineDigitCarryFlag((wRegister&0b11101111) + (literal&0b1111));
     }
 
-    public static void RETLW(int literal) {
+    public void RETLW(int literal) {
         wRegister = literal;
-        DataRegister.setPC(ProgramStack.pop());
+        dataRegister.setPC(programStack.pop());
     }
 
-    public static void MOVLW(int literal) {
+    public void MOVLW(int literal) {
         wRegister = literal;
     }
 
-    public static void BTFSC(int address, int bit) {
+    public void BTFSC(int address, int bit) {
-        if (DataRegister.getBit(address, bit) == 0){
+        if (dataRegister.getBit(address, bit) == 0){
-            DataRegister.increasePC();
+            dataRegister.increasePC();
+            addExecutionTime(1);
         }
     }
 
-    public static void BTFSS(int address, int bit) {
+    public void BTFSS(int address, int bit) {
-        if (DataRegister.getBit(address, bit) == 1){
+        if (dataRegister.getBit(address, bit) == 1){
-            DataRegister.increasePC();
+            dataRegister.increasePC();
+            addExecutionTime(1);
         }
     }
+
+    @Override
+    public double getExecutionTimeMultiplier(){
+        return executionTimeMultiplier;
+    }
+
+    @Override
+    public void setExecutionTimeMultiplier(String option){
+        switch (option) {
+            case "8 MHZ":
+                executionTimeMultiplier = 0.5;
+                break;
+
+            case "4 MHZ":
+                executionTimeMultiplier = 1;
+                break;
+            case "1 MHZ":
+                executionTimeMultiplier = 4;
+                break;
+            case "500 HZ":
+                executionTimeMultiplier = 8;
+                break;
+
+            case "100 HZ":
+                executionTimeMultiplier = 40;
+                break;
+
+            case "32 HZ":
+                executionTimeMultiplier = 125;
+                break;
+        }
+    super.notifyObservers();
+    }
 }

src/main/java/fabrik/simulator/pic16f84/Controller_FileSelect.java

@@ -1,61 +0,0 @@
-package fabrik.simulator.pic16f84;
-import javafx.event.ActionEvent;
-import javafx.fxml.FXML;
-import javafx.fxml.FXMLLoader;
-import javafx.scene.Node;
-import javafx.scene.Scene;
-import javafx.stage.FileChooser;
-import javafx.stage.Stage;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.Arrays;
-import java.util.Scanner;
-
-public class Controller_FileSelect {
-    private int [] prog;
-
-    @FXML
-    protected void selectFileLST(ActionEvent event) throws IOException {
-        FileChooser fileChooser = new FileChooser();
-        fileChooser.setTitle("Open LST File");
-        fileChooser.getExtensionFilters().addAll(
-                new FileChooser.ExtensionFilter("LST-Dateien", "*.LST", "*.lst"),
-                new FileChooser.ExtensionFilter("Alle Dateien", "*.*"));
-        File selectedFile = fileChooser.showOpenDialog(new Stage());
-
-        if (selectedFile != null) {
-            prog = ParseFile.parseDatei(selectedFile.getAbsolutePath());
-            Stage stage = (Stage) ((Node) event.getSource()).getScene().getWindow();
-            FXMLLoader fxmlLoader = new FXMLLoader(CreateWindow.class.getResource("MainBody.fxml"));
-            Scene scene = new Scene(fxmlLoader.load(), 1200, 800);
-            stage.setTitle("PIC16F84-Simulator － Hauptseite");
-            stage.setScene(scene);
-            stage.show();
-            System.out.println("\n");
-            DataRegister.initDataRegister();
-            while (true) {
-                Scanner reader = new Scanner(System.in);
-                System.out.println("\nWeiter? ");
-                int n = reader.nextInt();
-                if (n != 0) {
-                    Commands.decode(prog[DataRegister.getPC()]);
-                    System.out.println("\nPC: " + DataRegister.getPC());
-                    System.out.println("FSR: " + DataRegister.getFSR());
-                    System.out.println("PCL: " + DataRegister.getRegister(0x2));
-                    System.out.println("PCLATH: " + DataRegister.getRegister(0xA));
-                    System.out.println("W: " + Commands.get_wRegister());
-                    System.out.println("C: " + DataRegister.getCarryFlag());
-                    System.out.println("DC: " + DataRegister.getDigitCarryFlag());
-                    System.out.println("StackPointer: " + ProgramStack.getStackPointer());
-                    System.out.println(ProgramStack.getStack());
-                    System.out.printf(Arrays.toString(DataRegister.getDataRegister()));
-                    DataRegister.increasePC();
-                }
-            }
-        }
-    }
-    public int[] getProg() {
-        return prog;
-    }
-}

src/main/java/fabrik/simulator/pic16f84/Controller_Frontend.java

@@ -0,0 +1,579 @@
+package fabrik.simulator.pic16f84;
+
+
+import fabrik.simulator.pic16f84.frontendspecifics.FrontendSpecificToggleButtonGroup;
+import fabrik.simulator.pic16f84.frontendspecifics.ToggleButtonGroup;
+
+import fabrik.simulator.pic16f84.interfaces.*;
+import javafx.application.Platform;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.event.ActionEvent;
+import javafx.fxml.FXML;
+
+import javafx.scene.Scene;
+import javafx.scene.control.*;
+import javafx.scene.layout.VBox;
+import javafx.scene.shape.Circle;
+import javafx.stage.FileChooser;
+
+import java.io.File;
+import java.io.IOException;
+
+import java.io.BufferedReader;
+
+import java.io.FileReader;
+
+import javafx.scene.control.Label;
+import javafx.scene.control.TableView;
+
+import javafx.stage.Stage;
+import javafx.util.Callback;
+
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import static java.lang.Math.max;
+
+public class Controller_Frontend extends PICComponent implements FrontendControllerInterface, ExecutionTimeObserver {
+
+    private int [] prog;
+    private int [][] read;
+    private int [] ind;
+    private PICComponentLocator picComponents;
+
+    private boolean isBreakpointReached = false;
+
+    private boolean continueExecutionAfterBreakpoint = false;
+
+    @FXML
+    private ComboBox<String> executionTimeComboBox;
+
+
+    @FXML
+    private Button stepintoButton;
+
+    @FXML
+    private TableView<Table.DataEntry> tableView;
+
+    @FXML
+    private ListView<String> lstContentListView;
+
+    @FXML
+    private Button autoRunGUI;
+
+    @FXML
+    private Button stopButton;
+
+    @FXML
+    private Label totalExecutionTimeLabel;
+
+    @FXML
+    private CheckBox wdtCheck;
+
+
+
+    public Controller_Frontend() {
+        super();
+        System.out.println(this);
+    }
+
+
+
+
+
+    //Refactoring
+
+    public void stopRunFromBackend(String message) {
+        ExecutionState.setAutoRunActive(false);
+
+        handleSleepOrReset();
+        showStopDialog(message);
+
+    }
+    private  void handleSleepOrReset() {
+        if (ExecutionState.isSleeping()) {
+            ExecutionState.wakeUp();
+        } else {
+            dataRegister.resetPC();
+        }
+    }
+
+    private static void showStopDialog(String message) {
+        Stage stoppedStage = new Stage();
+        stoppedStage.setTitle("Programm unterbrochen!");
+
+        VBox vbox = new VBox();
+        vbox.setAlignment(javafx.geometry.Pos.CENTER);
+
+        Label grundlabel = new Label("Grund: " + message);
+        grundlabel.setStyle("-fx-font-size: 16px; -fx-font-weight: bold;");
+
+        Label ueberlabel = new Label("Programm unterbrochen!");
+        vbox.getChildren().addAll(ueberlabel, grundlabel);
+        VBox.setMargin(grundlabel, new javafx.geometry.Insets(10, 10, 10, 10));
+
+        Scene scene = new Scene(vbox, 300, 90);
+        stoppedStage.setAlwaysOnTop(true);
+        stoppedStage.setScene(scene);
+        stoppedStage.show();
+    }
+
+
+
+    //Refactoring Ende
+
+
+
+    @FXML
+    private void stopAutoRun(ActionEvent event) {
+        ExecutionState.setAutoRunActive(false);
+    }
+
+
+    @FXML
+    public void autoRunGUI(ActionEvent event) {
+        if (!ExecutionState.isAutoRunActive()) {
+            ExecutionState.setAutoRunActive(true) ;
+        }
+
+        Thread autoRunThread = new Thread(() -> {
+            try {
+                while (dataRegister.getPC() < prog.length && ExecutionState.isAutoRunActive()){
+
+                    Platform.runLater(() -> {
+                        try {
+                            stepintoButton(null);
+                        } catch (IOException e) {
+                            e.printStackTrace();
+                        }
+                    });
+                    Thread.sleep(80); //Verzögerungszeit in Millisekunden
+                }
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        });
+        autoRunThread.setDaemon(true);
+        autoRunThread.start();
+    }
+
+
+
+    private void updateExecutionTimeMultiplier() {
+        String selectedOption = executionTimeComboBox.getValue();
+        executionTime.setExecutionTimeMultiplier(selectedOption);
+    }
+
+    @FXML
+    public void stepintoButton(ActionEvent event) throws IOException {
+        if (lstContentListView.getItems().isEmpty()) {
+            // Datei ist nicht geladen oder leer
+            return;
+        }
+
+        int currentIndex;
+        // Aktuelle Zeile abrufen
+        if (!ExecutionState.isSleeping())
+            currentIndex = ind[dataRegister.getPC()];
+        else
+            currentIndex = ind[dataRegister.getPC()]-1;
+
+        // Überprüfung ob ein Breakpoint gesetzt ist testte
+
+        if (breakpoints.contains(currentIndex)) {
+            if (!continueExecutionAfterBreakpoint){
+                isBreakpointReached = true;
+                stopAutoRun(null);
+                System.out.println("Breakpoint erreicht bei Zeile: " + currentIndex);
+                continueExecutionAfterBreakpoint = true;
+                return;
+            }
+        }
+        else {
+            isBreakpointReached = false;
+            continueExecutionAfterBreakpoint = false;
+        }
+
+        // Scrollen zur ausgewählten Zeile
+        lstContentListView.scrollTo(currentIndex -2);
+
+        // Zeile auswählen
+        lstContentListView.getSelectionModel().clearSelection();
+        lstContentListView.getSelectionModel().select(currentIndex);
+
+        String selectedRowStyle;
+        if (!ExecutionState.isSleeping())
+            selectedRowStyle = "-fx-background-color: red; -fx-text-fill: white;";
+        else
+            selectedRowStyle = "-fx-background-color: teal; -fx-text-fill: white;";
+
+        markSelectedRow(currentIndex, selectedRowStyle);
+
+        if (!ExecutionState.isSleeping()) {
+            commands.decode(prog[dataRegister.getPC()]);
+            dataRegister.increasePC();
+        }
+        else {
+            commands.decode(0);
+        }
+        watchdogTimer.testAndTrigger();
+        table.refresh();
+        CreateWindow.refreshTable();
+        ioPorts.refreshUI(getTRISbuttons(), getPORTbuttons());
+        updateStack();
+        updateWatchdog();
+    }
+
+
+    private void markSelectedRow(int currentIndex, String selectedRowStyle) {
+        lstContentListView.setCellFactory(column -> new ListCell<String>() {
+            @Override
+            protected void updateItem(String item, boolean empty) {
+                super.updateItem(item, empty);
+                setText(item);
+                if (getIndex() == currentIndex) {
+                    setStyle(selectedRowStyle);
+                } else {
+                    setStyle("");
+                }
+                CheckBox breakpointCheckBox = new CheckBox();
+                breakpointCheckBox.setOnAction(event -> {
+                    int index = getIndex();
+                    if (breakpointCheckBox.isSelected()) {
+                        breakpoints.add(index);
+                    } else {
+                        breakpoints.remove(index);
+                    }
+                });
+                breakpointCheckBox.setSelected(breakpoints.contains(getIndex()));
+                setGraphic(breakpointCheckBox);
+            }
+        });
+    }
+
+    private Set<Integer> breakpoints = new HashSet<>();
+
+
+
+    @FXML
+    protected void selectFileLST(ActionEvent event) throws IOException {
+        File selectedFile = chooseLSTFile();
+        stopAutoRun(null);
+        if(selectedFile != null){
+            String fileAddress = selectedFile.getAbsolutePath();
+            System.out.println(dataRegister);
+            if (null == dataRegister) dataRegister = (DataRegisterInterface) picComponents.getComponent(DataRegisterInterface.class);
+            dataRegister.initDataRegister();
+            dataRegister.resetPC();
+            toggleLEDs(null);
+            ioPorts.reset();
+
+            for (ToggleButtonGroup toggleButtonGroup : allPORTbuttons) {
+                try {
+                    toggleButtonGroup.getToggles().get(0).setSelected(true);
+                    toggleButtonGroup.getToggles().get(1).setSelected(false);
+                    ioPorts.setPORTfromUI(toggleButtonGroup);
+                } catch (NullPointerException ignored) {}
+            }
+            programStack.reset();
+            ExecutionState.wakeUp();
+            breakpoints.clear();
+            ioPorts.refreshUI(getTRISbuttons(), getPORTbuttons());
+            executionTime.resetTotalExecutionTime();
+            watchdogTimer.reset();
+            wdtCheck.setSelected(false);
+            table.refresh();
+            read = ParseFile.parseDatei(fileAddress);
+            prog = read [0];
+            ind = read[1];
+            updateStack();
+            System.out.println(Arrays.toString(Arrays.stream(prog).toArray()));
+            displayLSTFileContent(selectedFile);
+            markSelectedRow(0, "-fx-background-color: red; -fx-text-fill: white;");
+            initializeBreakpoints();
+            int lastSlash = max (fileAddress.lastIndexOf('/'), fileAddress.lastIndexOf('\\'));
+            int lastDot = fileAddress.lastIndexOf('.');
+            String stageTitle;
+            if (lastDot > lastSlash)
+                stageTitle = "Simulator － " + fileAddress.substring(lastSlash + 1, lastDot);
+            else {
+                stageTitle = "Simulator － " + fileAddress.substring(lastSlash + 1);
+            }
+            Stage stage = (Stage) stepintoButton.getScene().getWindow();
+            stage.setTitle(stageTitle);
+        }
+    }
+
+    private void initializeBreakpoints() {
+        lstContentListView.setCellFactory(createBreakpointCell());
+    }
+
+    private boolean checkBreakpoint(int pc) {
+        // Hier wird überprüft, ob ein Breakpoint am angegebenen Programmzähler gesetzt ist
+        return breakpoints.contains(pc);
+    }
+
+
+    private Callback<ListView<String>, ListCell<String>> createBreakpointCell() {
+        return listView -> new ListCell<String>() {
+            private final CheckBox breakpointCheckBox = new CheckBox();
+            {
+                breakpointCheckBox.setOnAction(event -> {
+                    int index = getIndex();
+                    if (breakpointCheckBox.isSelected()) {
+                        breakpoints.add(index);
+                    } else {
+                        breakpoints.remove(index);
+                    }
+                });
+            }
+
+            @Override
+            protected void updateItem(String item, boolean empty) {
+                super.updateItem(item, empty);
+                if (empty || item == null) {
+                    setGraphic(null);
+                } else {
+                    setText(item);
+                    setGraphic(breakpointCheckBox);
+                    breakpointCheckBox.setSelected(breakpoints.contains(getIndex()));
+                }
+            }
+        };
+    }
+
+    @FXML
+    protected void loadLSTFileContent(String fileContent) {
+        ObservableList<String> items = FXCollections.observableArrayList(fileContent.split("\n"));
+        lstContentListView.setItems(items);
+    }
+
+
+    private File chooseLSTFile() {
+        FileChooser fileChooser = new FileChooser();
+        fileChooser.getExtensionFilters().addAll(
+                new FileChooser.ExtensionFilter("LST Files", "*.lst", "*.LST"),
+                new FileChooser.ExtensionFilter("All Files", "*.*"));
+        return fileChooser.showOpenDialog(null);
+    }
+
+    @FXML
+    private void displayLSTFileContent(File selectedFile) {
+        try (BufferedReader reader = new BufferedReader(new FileReader(selectedFile))) {
+            ObservableList<String> contentList = FXCollections.observableArrayList();
+            String line;
+            while ((line = reader.readLine()) != null) {
+                contentList.add(line);
+            }
+            lstContentListView.setItems(contentList);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @FXML
+    public void toggleWatchdog(ActionEvent actionEvent) {
+        if (wdtCheck.isSelected()){
+            watchdogTimer.enable();
+
+        }
+        else{
+            watchdogTimer.disable();
+       }
+    }
+
+    @FXML
+    private ToggleButtonGroup bgTRISA0;
+    @FXML
+    private ToggleButtonGroup bgTRISA1;
+    @FXML
+    private ToggleButtonGroup bgTRISA2;
+    @FXML
+    private ToggleButtonGroup bgTRISA3;
+    @FXML
+    private ToggleButtonGroup bgTRISA4;
+    @FXML
+    private ToggleButtonGroup bgTRISB0;
+    @FXML
+    private ToggleButtonGroup bgTRISB1;
+    @FXML
+    private ToggleButtonGroup bgTRISB2;
+    @FXML
+    private ToggleButtonGroup bgTRISB3;
+    @FXML
+    private ToggleButtonGroup bgTRISB4;
+    @FXML
+    private ToggleButtonGroup bgTRISB5;
+    @FXML
+    private ToggleButtonGroup bgTRISB6;
+    @FXML
+    private ToggleButtonGroup bgTRISB7;
+    @FXML
+    private ToggleButtonGroup bgPORTA0;
+    @FXML
+    private ToggleButtonGroup bgPORTA1;
+    @FXML
+    private ToggleButtonGroup bgPORTA2;
+    @FXML
+    private ToggleButtonGroup bgPORTA3;
+    @FXML
+    private ToggleButtonGroup bgPORTA4;
+    @FXML
+    private ToggleButtonGroup bgPORTB0;
+    @FXML
+    private ToggleButtonGroup bgPORTB1;
+    @FXML
+    private ToggleButtonGroup bgPORTB2;
+    @FXML
+    private ToggleButtonGroup bgPORTB3;
+    @FXML
+    private ToggleButtonGroup bgPORTB4;
+    @FXML
+    private ToggleButtonGroup bgPORTB5;
+    @FXML
+    private ToggleButtonGroup bgPORTB6;
+    @FXML
+    private ToggleButtonGroup bgPORTB7;
+
+    private static ToggleButtonGroup[] allTRISbuttons;
+    private static ToggleButtonGroup[] allPORTbuttons;
+    private static Circle[] allLEDsA;
+    private static Circle[] allLEDsB;
+    private static ToggleButtonGroup dummy = new ToggleButtonGroup(new ToggleButton(), new ToggleButton());
+
+    public void initialize() {
+        ToggleButtonGroup [] allTRISButtons = {bgTRISA0, bgTRISA1, bgTRISA2, bgTRISA3, bgTRISA4, dummy, dummy, dummy, bgTRISB0, bgTRISB1, bgTRISB2, bgTRISB3, bgTRISB4, bgTRISB5, bgTRISB6, bgTRISB7};
+        ToggleButtonGroup [] allPORTButtons = {bgPORTA0, bgPORTA1, bgPORTA2, bgPORTA3, bgPORTA4, dummy, dummy, dummy, bgPORTB0, bgPORTB1, bgPORTB2, bgPORTB3, bgPORTB4, bgPORTB5, bgPORTB6, bgPORTB7};
+        Circle[] allLEDsA = {ledA0, ledA1, ledA2, ledA3, ledA4};
+        Circle[] allLEDsB = {ledB0, ledB1, ledB2, ledB3, ledB4, ledB5, ledB6, ledB7};
+        for (int i = 0; i<allPORTButtons.length; i++) {
+            allTRISButtons[i].getToggles().get(0).setSelected(true);
+            allPORTButtons[i].getToggles().get(0).setSelected(true);
+            allTRISButtons[i].getToggles().get(1).setSelected(false);
+            allPORTButtons[i].getToggles().get(1).setSelected(false);
+            toggleButtonExt.addAlwaysOneSelectedSupport(allTRISButtons[i]);
+            toggleButtonExt.addAlwaysOneSelectedSupport(allPORTButtons[i]);
+        }
+
+        ledCheckA.setSelected(false);
+        ledCheckB.setSelected(false);
+        setTRISbuttons(allTRISButtons);
+        setPORTbuttons(allPORTButtons);
+        ioPorts.setLEDs(allLEDsA, allLEDsB);
+
+        lstContentListView.getSelectionModel().setSelectionMode(SelectionMode.MULTIPLE);
+
+        autoRunGUI.setOnAction(this::autoRunGUI);
+        stopButton.setOnAction(this::stopAutoRun);
+
+        initializeBreakpoints();
+        executionTimeComboBox.setItems(FXCollections.observableArrayList("8 MHZ", "4 MHZ", "1 MHZ", "500 HZ", "100 HZ", "32 HZ"));
+        executionTimeComboBox.setValue("4 MHZ");
+        executionTimeComboBox.setOnAction(event -> updateExecutionTimeMultiplier());
+    }
+
+
+
+    private void setTRISbuttons(ToggleButtonGroup[] allButtons) {
+        allTRISbuttons = allButtons;
+    }
+
+    public FrontendSpecificToggleButtonGroup [] getTRISbuttons() {
+        return allTRISbuttons;
+    }
+
+    private void setPORTbuttons(ToggleButtonGroup[] allButtons) {
+        allPORTbuttons = allButtons;
+    }
+
+    public ToggleButtonGroup [] getPORTbuttons() {
+        return allPORTbuttons;
+    }
+
+    public Circle[] getLEDsA() {
+        return allLEDsA;
+    }
+
+    public Circle[] getLEDsB() {
+        return allLEDsB;
+    }
+
+
+    @FXML
+    private CheckBox ledCheckA;
+    @FXML
+    private CheckBox ledCheckB;
+    @FXML
+    private Circle ledA0;
+    @FXML
+    private Circle ledA1;
+    @FXML
+    private Circle ledA2;
+    @FXML
+    private Circle ledA3;
+    @FXML
+    private Circle ledA4;
+    @FXML
+    private Circle ledB0;
+    @FXML
+    private Circle ledB1;
+    @FXML
+    private Circle ledB2;
+    @FXML
+    private Circle ledB3;
+    @FXML
+    private Circle ledB4;
+    @FXML
+    private Circle ledB5;
+    @FXML
+    private Circle ledB6;
+    @FXML
+    private Circle ledB7;
+
+    @FXML
+    public void toggleLEDs (ActionEvent actionEvent) {
+        ioPorts.setLEDs(new boolean[]{ledCheckA.isSelected(), ledCheckB.isSelected()});
+    }
+
+    @FXML
+    private Label stackIndex;
+
+    @FXML
+    private ListView<String> stackVisual;
+
+    private static String format (String s) {
+        return (s.length() == 1) ? "0" + s : s;
+    }
+
+    private void updateStack (){
+        stackIndex.setText("Stack-Pointer: " + programStack.getStackPointer());
+        ObservableList<String> observedList = FXCollections.observableArrayList();
+        List<Integer> stackList = programStack.getStack();
+        for (Integer integer : stackList) {
+            observedList.add("0x" + format(Integer.toHexString(integer).toUpperCase()));
+        }
+        stackVisual.setItems(observedList);
+    }
+
+    private void updateWatchdog (){
+        wdtCheck.setText("Watchdog-Timer: " + watchdogTimer.get() + "µs");
+    }
+
+    @Override
+    public void initialize(PICComponentLocator locator) {
+        super.initialize(locator);
+        executionTime.registerObserver(this);
+        this.picComponents = locator;
+        System.out.println("Frontend");
+    }
+
+    @Override
+    public void executionTimeChanged() {
+        totalExecutionTimeLabel.setText("Total Execution Time: " + executionTime.getTotalExecutionTime() + "µs");
+    }
+}
+

src/main/java/fabrik/simulator/pic16f84/Controller_MainBody.java

@@ -1,5 +0,0 @@
-package fabrik.simulator.pic16f84;
-
-public class Controller_MainBody {
-
-}

src/main/java/fabrik/simulator/pic16f84/CreateWindow.java

@@ -1,23 +1,75 @@
 package fabrik.simulator.pic16f84;
 
+import fabrik.simulator.pic16f84.frontendspecifics.VBox;
+import fabrik.simulator.pic16f84.interfaces.*;
 import javafx.application.Application;
+
 import javafx.fxml.FXMLLoader;
+import javafx.scene.Parent;
 import javafx.scene.Scene;
+
+import javafx.scene.layout.GridPane;
 import javafx.stage.Stage;
 
 import java.io.IOException;
+import java.util.Objects;
+
+public class CreateWindow extends Application  implements WindowManagement {
+    private static PICComponentLocator picComponents; // Subjekt
+    public static GridPane grid = new GridPane();
+    private TableInterface table;
+    private static VBox tableBox;
 
-public class CreateWindow extends Application {
     @Override
-    public void start(Stage stage) throws IOException {
+    public void start(Stage primaryStage) throws IOException {
-        FXMLLoader fxmlLoader = new FXMLLoader(CreateWindow.class.getResource("FileSelector.fxml"));
+        picComponents.registerComponent(ToggleButtonInterface.class, new ToggleButtonGroupExt());
-        Scene scene = new Scene(fxmlLoader.load(), 1200, 800);
+        picComponents.registerComponent(IOPortInterface.class, new IOPorts());
-        stage.setTitle("PIC16F84-Simulator － Datei auswählen");
+        picComponents.registerComponent(TableInterface.class, new Table());
-        stage.setScene(scene);
+        picComponents.registerComponent(FrontendControllerInterface.class, new Controller_Frontend());
-        stage.show();
+        picComponents.initAll();
+
+        table = picComponents.getComponent(TableInterface.class);
+
+        FXMLLoader codewindow = new FXMLLoader(CreateWindow.class.getResource("frontend.fxml"));
+        codewindow.setController(picComponents.getComponent(FrontendControllerInterface.class));
+        Parent code = codewindow.load();
+
+        tableBox = (VBox) table.getTable();
+        grid.add(tableBox, 1, 1);
+        grid.add(code, 0, 1);
+
+        grid.relocate(0, 0);
+
+        grid.getStylesheets().add(Objects.requireNonNull(getClass().getResource("styles.css")).toExternalForm());
+        Scene scene = new Scene(grid, 1845, 800);
+        primaryStage.setScene(scene);
+        primaryStage.setTitle("Simulator");
+        primaryStage.show();
+    }
+
+    public void startFromMain(String[] args){
+        launch(args);
     }
 
     public static void main(String[] args) {
-        launch();
+        launch(args);
+    }
+
+    public static void refreshTable() {
+        TableInterface table = picComponents.getComponent(TableInterface.class);
+        grid.getChildren().remove(table.getTable());
+        table.refresh();
+        tableBox = (VBox) table.getTable();
+        grid.add(tableBox, 1, 1);
+    }
+
+    @Override
+    public void initialize(PICComponentLocator picComponents) {
+        CreateWindow.picComponents = picComponents;
+    }
+
+    public CreateWindow (){
     }
 }
+
+

src/main/java/fabrik/simulator/pic16f84/DataRegister.java

@@ -1,47 +1,74 @@
 package fabrik.simulator.pic16f84;
 
+import fabrik.simulator.pic16f84.interfaces.DataRegisterInterface;
+
 import java.util.Arrays;
 
-public class DataRegister {
+public class DataRegister extends PICComponent implements DataRegisterInterface {
-    private static final int INDF = 0x0;
+    private final int INDF = 0x0;
-    private static final int PCL = 0x2;
+    private final int PCL = 0x2;
-    private static final int STATUS = 0x3;
+    private final int STATUS = 0x3;
-    private static final int FSR = 0x4;
+    private final int FSR = 0x4;
-    private static final int PORTA = 0x5;
+    private final int PORTA = 0x5;
-    private static final int PORTB = 0x6;
+    private final int PORTB = 0x6;
-    private static final int PCLATH = 0xA;
+    private final int PCLATH = 0xA;
-    private static final int INTCON = 0xB;
+    private final int INTCON = 0xB;
 
-    private static final int TRISA = 0x85;
+    private final int EEDATA = 0x08;
-    private static final int TRISB = 0x86;
+    private final int EEADR = 0x09;
+    private final int EECON1 = 0x88;
+    private final int EECON2 = 0x89;
 
-    private static final int C = 0x0;
+    private final int TRISA = 0x85;
-    private static final int DC = 0x1;
+    private final int TRISB = 0x86;
-    private static final int Z = 0x2;
+
-    private static final int RP0 = 0x5;
+    private final int C = 0x0;
+    private final int DC = 0x1;
+    private final int Z = 0x2;
+    private final int RP0 = 0x5;
 
 
-    private static final int [] dataRegister =  new int[0xFF];
+    private final int [] dataRegister =  new int[0xFF];
-    private static final int [] syncedRegisters = {INDF, PCL, STATUS, FSR, PCLATH, INTCON};
+    private final int [] syncedRegisters = {INDF, PCL, STATUS, FSR, PCLATH, INTCON};
-    public static final int [] ioRegisters = {PORTA, PORTB, TRISA, TRISB};
+    private final int [] eepromRegisters = {EEDATA, EEADR, EECON1, EECON2};
+    public final int [] ioRegisters = {PORTA, PORTB, TRISA, TRISB};
 
-    public static void initDataRegister() {
+
+    public DataRegister () {
+        super();
+    }
+
+    @Override
+    public void initialize(PICComponentLocator locator) {
+        super.initialize(locator);
+        System.out.println("DataRegister.\n");
+        initOrReset();
+    }
+
+    private void initOrReset () {
         dataRegister[PCL] = 0b0;
         dataRegister[STATUS] = 0b00011000;
         dataRegister[PCLATH] = 0b0;
         dataRegister[INTCON] = 0b0;
-
         dataRegister[0x81] = 0b11111111;
         dataRegister[0x80 + PCL] = dataRegister[PCL];
         dataRegister[0x80 + STATUS] = dataRegister[STATUS];
-        dataRegister[TRISA] = 0b11111000;
+        dataRegister[TRISA] = 0b11111111;
         dataRegister[TRISB] = 0b11111111;
         dataRegister[0x80 + PCLATH] = dataRegister[PCLATH];
         dataRegister[0x80 + INTCON] = dataRegister[INTCON];
+        carryFlag = 0;
+        zeroFlag = 0;
+        digitCarryFlag = 0;
+        if (null != ioPorts) ioPorts.resetTRIS();
         System.out.println(Arrays.toString(dataRegister));
     }
 
-    private static boolean isSyncedRegister (int address){
+    public void initDataRegister() {
+        initOrReset();
+    }
+
+    private boolean isSyncedRegister (int address){
         for (int register : syncedRegisters){
             if (address == register || address == 0x80 + register){
                 return true;
@@ -50,11 +77,11 @@ public class DataRegister {
         return false;
     }
 
-    public static int[] getDataRegister() {
+    public int[] getDataRegister() {
         return dataRegister;
     }
 
-    private static int determineIndirectAndChange (int address){
+    private int determineIndirectAndChange (int address){
         if (address == INDF || address == 0x80 + INDF) {
             return dataRegister[FSR];
         }
@@ -62,23 +89,29 @@ public class DataRegister {
             return address;
     }
 
-    public static int getFSR (){
+    public int getFSR (){
         return dataRegister[FSR];
     }
 
-    private static int bank() {
+    private int bank() {
         return ((dataRegister[STATUS] >> RP0) & 1) * 0x80;
     }
 
-    public static int getRegister(int fileAddress){
+    public int getRegister(int fileAddress){
         int address = determineIndirectAndChange (fileAddress);
+        if (bank () + address == EECON2)
+            return 0;
         return dataRegister[bank() + address];
     }
 
-    public static void setRegister(int fileAddress, int content){
+    public void setRegister(int fileAddress, int content){
         int address = determineIndirectAndChange (fileAddress);
         if (Arrays.stream(ioRegisters).anyMatch(i -> i == address)){
-            IOPorts.setRegister(bank() + address, content);
+            ioPorts.setRegister(bank() + address, content);
+            return;
+        }
+        if (Arrays.stream(eepromRegisters).anyMatch(i -> i == address)){
+            eeprom.parse(bank() + address, content, 0b11);
             return;
         }
         if (fileAddress == PCL || fileAddress == 0x80 + PCL){
@@ -89,22 +122,33 @@ public class DataRegister {
         else {
             dataRegister[address] = content;
             dataRegister[0x80 + address] = content;
+            if (address == STATUS){
+                setFlags();
             }
         }
+        if (address == 1)
+            preScaler.resetFromRegister();
+    }
 
-    public static int getBit(int fileAddress, int bit) {
+    public int getBit(int fileAddress, int bit) {
         int address = determineIndirectAndChange (fileAddress);
+        if (bank() + address == EECON2)
+            return 0;
         return (dataRegister[bank() + address] >> bit) & 1;
     }
 
-    public static int getDirectBit(int address, int bit){
+    public int getDirectBit(int address, int bit){
         return (dataRegister[address] >> bit) & 1;
     }
 
-    public static void clearBit(int fileAddress, int bit) {
+    public void clearBit(int fileAddress, int bit) {
         int address = determineIndirectAndChange (fileAddress);
         if (Arrays.stream(ioRegisters).anyMatch(i -> i == address)){
-            IOPorts.clearBit(bank() + address, bit);
+            ioPorts.clearBit(bank() + address, bit);
+            return;
+        }
+        if (Arrays.stream(eepromRegisters).anyMatch(i -> i == address)){
+            eeprom.parse(bank () + address, bit, 0b00);
             return;
         }
         if (!isSyncedRegister(address)) {
@@ -116,14 +160,23 @@ public class DataRegister {
             if (getBit(address, bit) == 1) {
                 dataRegister[address] -= (int) Math.pow(2, bit);
                 dataRegister[0x80 + address] = dataRegister[address];
+                if (address == STATUS){
+                    setFlags();
                 }
             }
         }
+        if (address == 1)
+            preScaler.resetFromRegister();
+    }
 
-    public static void setBit(int fileAddress, int bit) {
+    public void setBit(int fileAddress, int bit) {
         int address = determineIndirectAndChange (fileAddress);
         if (Arrays.stream(ioRegisters).anyMatch(i -> i == address)){
-            IOPorts.setBit(bank() + address, bit);
+            ioPorts.setBit(bank() + address, bit);
+            return;
+        }
+        if (Arrays.stream(eepromRegisters).anyMatch(i -> i == address)){
+            eeprom.parse(bank () + address, bit, 0b10);
             return;
         }
         if (!isSyncedRegister(address)) {
@@ -135,18 +188,31 @@ public class DataRegister {
             if (getBit(address, bit) == 0) {
                 dataRegister[address] += (int) Math.pow(2, bit);
                 dataRegister[0x80 + address] = dataRegister[address];
+                if (address == STATUS){
+                    setFlags();
                 }
             }
         }
+        if (address == 1)
+            preScaler.resetFromRegister();
+    }
+
+    public void setDirectBit (int fileAddress, int bit, int value){
+        if (getDirectBit(fileAddress, bit) == 0 && value == 1){
+            dataRegister[fileAddress] += (int) Math.pow(2, bit);
+        } else if (getDirectBit(fileAddress, bit) == 1 && value == 0){
+            dataRegister[fileAddress] -= (int) Math.pow(2, bit);
+        }
+    }
 
-    private static int programCounter = 0;
+    private int programCounter = 0;
 
-    private static void writeToPCL(){
+    private void writeToPCL(){
         dataRegister[PCL] = programCounter & 0xFF;
         dataRegister[0x80 + PCL] = dataRegister[PCL];
     }
 
-    public static void increasePC (){
+    public void increasePC (){
         if (programCounter != 0x3FF) {
             programCounter++;
         }
@@ -156,18 +222,28 @@ public class DataRegister {
         writeToPCL();
     }
 
-    public static void setPC (int value){
+    public void setPC (int value){
         programCounter = value + ((getRegister(PCLATH) & 0b11000) << 8);
         writeToPCL();
     }
 
-    public static int getPC(){
+    public void resetPC () {
+        programCounter = 0;
+    }
+
+    public int getPC(){
         return programCounter;
     }
 
-    private static int zeroFlag = 0;
+    private void setFlags() {
+        carryFlag = getDirectBit(STATUS, C);
+        digitCarryFlag = getDirectBit(STATUS, DC);
+        zeroFlag = getDirectBit(STATUS, Z);
+    }
 
-    public static void determineZeroFlag(int result){
+    private int zeroFlag = 0;
+
+    public void determineZeroFlag(int result){
         if (result == 0){
             zeroFlag = 1;
             if (getBit(STATUS, Z) == 0){
@@ -184,9 +260,13 @@ public class DataRegister {
         }
     }
 
-    private static int carryFlag = 0;
+    public int getZeroFlag(){
+        return zeroFlag;
+    }
 
-    public static void setCarryFlag(int value){
+    private int carryFlag = 0;
+
+    public void setCarryFlag(int value){
         carryFlag = value;
         if (value == 1){
             if (getBit(STATUS, C) == 0){
@@ -202,7 +282,7 @@ public class DataRegister {
         }
     }
 
-    public static void determineCarryFlag (int result){
+    public void determineCarryFlag (int result){
         if (result > 0xFF){
             setCarryFlag(1);
         }
@@ -211,13 +291,13 @@ public class DataRegister {
         }
     }
 
-    public static int getCarryFlag (){
+    public int getCarryFlag (){
         return carryFlag;
     }
 
-    private static int digitCarryFlag = 0;
+    private int digitCarryFlag = 0;
 
-    public static void setDigitCarryFlag(int value){
+    public void setDigitCarryFlag(int value){
         digitCarryFlag = value;
         if (value == 1){
             if (getBit(STATUS, DC) == 0){
@@ -233,8 +313,8 @@ public class DataRegister {
         }
     }
 
-    public static void determineDigitCarryFlag(int result){
+    public void determineDigitCarryFlag(int result){
-        if (result > 0xF){
+        if (result >> 4  == 1){
             setDigitCarryFlag(1);
         }
         else {
@@ -242,30 +322,30 @@ public class DataRegister {
         }
     }
 
-    public static int getDigitCarryFlag(){
+    public int getDigitCarryFlag(){
         return digitCarryFlag;
     }
 
-    public static void setDirectRegister(int fileAddress, int content) {
+    public void setDirectRegister(int fileAddress, int content) {
         dataRegister[fileAddress] = content;
     }
 
 
-    public static int getPCL() {
+    public int getPCL() {
         return PCL;
     }
-    public static int getSTATUS() {
+    public int getSTATUS() {
         return STATUS;
     }
 
-    public static int getPCLATH() {
+    public int getPCLATH() {
         return PCLATH;
     }
-    public static int getINTCON() {
+    public int getINTCON() {
         return INTCON;
     }
 
-    public static int getDirectRegister(int address) {
+    public int getDirectRegister(int address) {
         return dataRegister[address];
     }
 }

src/main/java/fabrik/simulator/pic16f84/EEPROM.java

@@ -0,0 +1,184 @@
+package fabrik.simulator.pic16f84;
+
+
+import org.json.simple.JSONObject;
+import org.json.simple.parser.JSONParser;
+import org.json.simple.parser.ParseException;
+
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import fabrik.simulator.pic16f84.interfaces.*;
+
+public class EEPROM extends PICComponent implements EEPROMInterface, ExecutionTimeObserver {
+    private final int EEDATA = 0x08;
+    private final int EEADR = 0x09;
+    private final int EECON1 = 0x88;
+    private final int EECON2 = 0x89;
+
+    private final int RD = 0x00;
+    private final int WR = 0x01;
+    private final int WRERR = 0x03;
+    private final int EEIF = 0x04;
+
+    private boolean readControl = false;
+    private boolean writeControl = false;
+    private boolean [] eecon2stages = {false, false};
+
+
+    private double startTime;
+    
+    public EEPROM (){
+    }
+
+    public long read (int address) {
+        if (address < 0) return 0;
+        FileReader reader;
+        try {
+            reader = new FileReader("eeprom.json");
+        } catch (FileNotFoundException e) {
+            return 0;
+        }
+        JSONParser parser = new JSONParser();
+        JSONObject data;
+        try {
+            data = (JSONObject) parser.parse(reader);
+        } catch (ParseException | IOException e) {
+            return 0;
+        }
+        Object requestedData = data.get(String.valueOf(address));
+        try {
+            readControl = false;
+            dataRegister.setDirectBit(EECON1, RD, 0);
+            return (long) requestedData;
+        } catch (NullPointerException e) {
+            return 0;
+        }
+    }
+
+    public void write (int address, long data) {
+        if (address < 0) return;
+        FileReader reader;
+        try {
+            reader = new FileReader("eeprom.json");
+        } catch (FileNotFoundException ignored) {
+            dataRegister.setDirectBit(EECON1, WRERR, 1);
+            return;
+        }
+        JSONParser parser = new JSONParser();
+        JSONObject eeprom;
+        try {
+            eeprom = (JSONObject) parser.parse(reader);
+        } catch (ParseException | IOException ignored) {
+            dataRegister.setDirectBit(EECON1, WRERR, 1);
+            return;
+        }
+        eeprom.put(String.valueOf(address), data);
+        try {
+            Files.write(Paths.get("eeprom.json"), eeprom.toJSONString().getBytes());
+        } catch (IOException ignored) {
+            dataRegister.setDirectBit(EECON1, WRERR, 1);
+            return;
+        }
+        registerTime(executionTime.getTotalExecutionTime(), true);
+    }
+
+    public void registerTime(double executionTime, boolean reset) {
+        if (reset)
+            startTime = executionTime;
+        else if ((executionTime >= (startTime + 1000)) && writeControl) {
+            eecon2stages = new boolean[]{false, false};
+            dataRegister.setDirectBit(EECON1, EEIF, 1);
+            dataRegister.setDirectBit(EECON1, WR, 0);
+            writeControl = false;
+            startTime = 0;
+        }
+    }
+
+    public void parse(int address, int content, int opcode) {
+        //OPCODE: 0b1x = set
+        //OPCODE: 0b0x = clear
+        //OPCODE: 0bx1 = byte
+        //OPCODE: 0bx0 = bit
+        switch (opcode){
+            case 0b00: // CLEAR BIT
+                if(address == EECON1) {
+                    if (dataRegister.getDirectBit(address, content) == 1)
+                        setEECON1((int) (dataRegister.getDirectRegister(EECON1) - Math.pow(2, content)));
+                } else {
+                    dataRegister.setDirectBit(address, content, 0);
+                }
+                break;
+            case 0b10: // SET BIT
+                if(address == EECON1) {
+                    if (dataRegister.getDirectBit(address, content) == 0)
+                        setEECON1((int) (dataRegister.getDirectRegister(EECON1) + Math.pow(2, content)));
+                } else {
+                    if (address == EEADR && content >= 0b01000000)
+                        dataRegister.setDirectBit(address, content, 0);
+                    else
+                        dataRegister.setDirectBit(address, content, 1);
+                }
+                break;
+            case 0b11: // SET BYTE
+                if(address == EECON1) {
+                    setEECON1 (content);
+                } else {
+                    if (address == EEADR)
+                        content &= 0b00111111;
+                    else if (address == EECON2) {
+                        if (content == 0x55)
+                            eecon2stages [0] = true;
+                        else if (content == 0xAA && eecon2stages[0])
+                            eecon2stages [1] = true;
+                        else
+                            eecon2stages = new boolean[]{false, false};
+                    }
+                    dataRegister.setDirectRegister(address, content);
+                }
+                break;
+        }
+    }
+
+    private void setEECON1(int content) {
+        content &= 0b00011111;
+        boolean writeEnabled = ((content & 0b100) >> 2) == 1;
+        if ((content & 0b1) == 1) { // READ
+            readControl = true;
+            dataRegister.setDirectRegister(EECON1, content);
+            int data = (int) read(dataRegister.getDirectRegister(EEADR));
+            dataRegister.setDirectRegister(EEDATA, data);
+            return;
+        }
+        else if ((content & 0b1) == 0 && readControl) // RD kann nicht manuell gecleart werden
+            content |= 0b1;
+        if (((content & 0b10) >> 1) == 1) { // WRITE CONTROL
+            if (writeEnabled && eecon2stages[0] && eecon2stages[1]) {
+                writeControl = true;
+                dataRegister.setDirectRegister(EECON1, content);
+                write(dataRegister.getDirectRegister(EEADR), dataRegister.getDirectRegister(EEDATA));
+                return;
+            }
+            else {
+                content -= 0b10;
+            }
+        }
+        else if ((((content & 0b10) >> 1) == 0) && writeControl) // WR kann nicht manuell gecleart werden
+            content |= 0b10;
+        dataRegister.setDirectRegister(EECON1, content);
+    }
+
+    @Override
+    public void initialize(PICComponentLocator locator) {
+        super.initialize(locator);
+        executionTime.registerObserver(this);
+    }
+
+    @Override
+    public void executionTimeChanged() {
+        registerTime(executionTime.getTotalExecutionTime(), false);
+    }
+}

src/main/java/fabrik/simulator/pic16f84/EmptyRegister.java

@@ -0,0 +1,151 @@
+package fabrik.simulator.pic16f84;
+
+import fabrik.simulator.pic16f84.interfaces.DataRegisterInterface;
+
+public class EmptyRegister implements DataRegisterInterface {
+
+    @Override
+    public void clearBit(int f, int b) {
+
+    }
+
+    @Override
+    public void setBit(int f, int b) {
+
+    }
+
+    @Override
+    public void setPC(int pop) {
+
+    }
+
+    @Override
+    public int getINTCON() {
+        return 0;
+    }
+
+    @Override
+    public int getPC() {
+        return 0;
+    }
+
+    @Override
+    public void setRegister(int file, int wRegister) {
+
+    }
+
+    @Override
+    public void determineZeroFlag(int wRegister) {
+
+    }
+
+    @Override
+    public int getRegister(int file) {
+        return 0;
+    }
+
+    @Override
+    public void setCarryFlag(int i) {
+
+    }
+
+    @Override
+    public void setDigitCarryFlag(int i) {
+
+    }
+
+    @Override
+    public int getCarryFlag() {
+        return 0;
+    }
+
+    @Override
+    public void determineCarryFlag(int result) {
+
+    }
+
+    @Override
+    public void increasePC() {
+
+    }
+
+    @Override
+    public void determineDigitCarryFlag(int i) {
+
+    }
+
+    @Override
+    public int getBit(int address, int bit) {
+        return 0;
+    }
+
+    @Override
+    public int getDirectBit(int option, int psa) {
+        return 0;
+    }
+
+    @Override
+    public int getDirectRegister(int option) {
+        return 0;
+    }
+
+    @Override
+    public void setDirectBit(int option, int i, int i1) {
+
+    }
+
+    @Override
+    public void setDirectRegister(int porta, int i) {
+
+    }
+
+    @Override
+    public void resetPC() {
+
+    }
+
+    @Override
+    public int[] getDataRegister() {
+        return new int[0];
+    }
+
+    @Override
+    public int getDigitCarryFlag() {
+        return 0;
+    }
+
+    @Override
+    public int getZeroFlag() {
+        return 0;
+    }
+
+    @Override
+    public int getFSR() {
+        return 0;
+    }
+
+    @Override
+    public void initDataRegister() {
+
+    }
+
+    @Override
+    public int getPCL() {
+        return 0;
+    }
+
+    @Override
+    public int getPCLATH() {
+        return 0;
+    }
+
+    @Override
+    public int getSTATUS() {
+        return 0;
+    }
+
+    @Override
+    public void initialize(PICComponentLocator picComponents) {
+
+    }
+}

src/main/java/fabrik/simulator/pic16f84/ExecutionState.java

@@ -0,0 +1,19 @@
+package fabrik.simulator.pic16f84;
+
+public class ExecutionState {
+
+    private static boolean isAutoRunActive = false;
+    private static boolean isSleeping = false;
+    private static double executionTimeMultiplier = 1;
+
+    public static boolean isAutoRunActive() { return isAutoRunActive; }
+    public static void setAutoRunActive(boolean active) { isAutoRunActive = active; }
+
+    public static boolean isSleeping() { return isSleeping; }
+    public static void sleep() { isSleeping = true; }
+    public static void wakeUp() { isSleeping = false; }
+
+    public static double getExecutionTimeMultiplier() { return executionTimeMultiplier; }
+    public static void setExecutionTimeMultiplier(double multiplier) { executionTimeMultiplier = multiplier; }
+}
+

src/main/java/fabrik/simulator/pic16f84/ExecutionTimeSubject.java

@@ -0,0 +1,54 @@
+package fabrik.simulator.pic16f84;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import fabrik.simulator.pic16f84.interfaces.ExecutionTimeObserver;
+import fabrik.simulator.pic16f84.interfaces.PICComponentInterface;
+
+public abstract class ExecutionTimeSubject extends PICComponent implements PICComponentInterface{
+    private Set<ExecutionTimeObserver> observers;
+    
+    public ExecutionTimeSubject(){
+        super();
+        this.observers = new HashSet<>();
+    }
+
+
+    public void registerObserver(ExecutionTimeObserver observer){
+        observers.add(observer);
+    }
+
+    public void unregisterObserver(ExecutionTimeObserver observer){
+        observers.remove(observer);
+    }
+
+    protected void notifyObservers(){
+            observers.forEach(o -> o.executionTimeChanged());
+        }
+        
+    public double getTotalExecutionTime(){
+        throw new UnsupportedOperationException("No class implements ExecutionTimeSubject correctly!");
+    }
+    
+    public void addExecutionTime(int i){
+        throw new UnsupportedOperationException("No class implements ExecutionTimeSubject correctly!");
+    }
+
+    public double getExecutionTimeMultiplier(){
+        throw new UnsupportedOperationException("No class implements ExecutionTimeSubject correctly!");
+    }
+
+    public void setExecutionTimeMultiplier(String option){
+        throw new UnsupportedOperationException("No class implements ExecutionTimeSubject correctly!");
+    }
+    
+    public void resetTotalExecutionTime(){
+        throw new UnsupportedOperationException("No class implements ExecutionTimeSubject correctly!");
+    }
+
+    @Override
+    public void initialize(PICComponentLocator locator) {
+        super.initialize(locator);
+    }
+}

src/main/java/fabrik/simulator/pic16f84/IOPorts.java

@@ -1,17 +1,43 @@
 package fabrik.simulator.pic16f84;
 
-public class IOPorts {
+import fabrik.simulator.pic16f84.frontendspecifics.FrontendSpecificToggleButtonGroup;
-    private static final int A = 0;
+import fabrik.simulator.pic16f84.frontendspecifics.ToggleButtonGroup;
-    private static final int B = 1;
+import fabrik.simulator.pic16f84.interfaces.*;
-    private static final int PORTA = 5;
+import javafx.collections.ObservableList;
-    private static final int PORTB = 6;
+import javafx.scene.control.ToggleButton;
-    private static final int TRISA = 0x85;
+import javafx.scene.paint.Color;
-    private static final int TRISB = 0x86;
+import javafx.scene.paint.RadialGradient;
+import javafx.scene.paint.Stop;
+import javafx.scene.shape.Circle;
 
-    private static int [] trisLatch = new int[2];
+import java.io.IOException;
-    private static int [] dataLatch = new int[2];
 
-    public static void setBit (int address, int bit){
+public class IOPorts extends PICComponent implements IOPortInterface {
+    private final int A = 0;
+    private final int B = 1;
+    private final int PORTA = 5;
+    private final int PORTB = 6;
+    private final int TRISA = 0x85;
+    private final int TRISB = 0x86;
+
+    private int [] trisLatch = {0xFF, 0xFF};
+    private int [] dataLatch = new int[2];
+    private boolean isLEDenabledA = false;
+    private boolean isLEDenabledB = false;
+    private Circle[] allLEDsA;
+    private Circle[] allLEDsB;
+
+
+    private  int RB4 = 0x10;
+    private  int RB5 = 0x20;
+    private  int RB6 = 0x40;
+    private  int RB7 = 0x80;
+
+    public IOPorts(){
+        super();
+    }
+
+    public void setBit (int address, int bit){
         if (address < 7) {
             dataLatch[address - PORTA] |= (1 << bit);
         }
@@ -21,21 +47,21 @@ public class IOPorts {
         refreshPorts();
     }
 
-    public static void clearBit(int address, int bit) {
+    public void clearBit(int address, int bit) {
         if (address < 7) {
             if (((dataLatch[address-PORTA] >> bit)&1) == 1){
                 dataLatch[address-PORTA] -= (int) Math.pow(2, bit);
             }
         }
         else{
-            if (DataRegister.getDirectBit(address, bit) == 1) {
+            if (((trisLatch[address-TRISA] >> bit)&1) == 1){
                 trisLatch[address-TRISA] -= (int) Math.pow(2, bit);
             }
         }
         refreshPorts();
     }
 
-    public static void setRegister(int address, int content) {
+    public void setRegister(int address, int content) {
         if (address < 7) {
             dataLatch[address - PORTA] = content;
         }
@@ -45,8 +71,181 @@ public class IOPorts {
         refreshPorts();
     }
 
-    private static void refreshPorts() {
+    private void refreshPorts() {
-        System.out.println("PORTA: " + DataRegister.getDirectRegister(PORTA) + "; DATALATCHA: " + dataLatch[A] + "; TRISA: " + trisLatch[A]);
+        dataRegister.setDirectRegister(PORTA, ((~((~dataLatch[A])&0x1F | trisLatch[A])) | (trisLatch[A] & dataRegister.getDirectRegister(PORTA))) & 0xFF);
-        System.out.println("PORTB: " + DataRegister.getDirectRegister(PORTB) + "; DATALATCHB: " + dataLatch[B] + "; TRISB: " + trisLatch[B]);
+        dataRegister.setDirectRegister(PORTB, ((~((~dataLatch[B])&0xFF | trisLatch[B])) | (trisLatch[B] & dataRegister.getDirectRegister(PORTB))) & 0xFF);
+        dataRegister.setDirectRegister(TRISA, trisLatch[A]);
+        dataRegister.setDirectRegister(TRISB, trisLatch[B]);
+        if (((trisLatch[A] >> 4) & 1 )== 1)
+            timer.incrementFromPin(dataRegister.getDirectRegister(PORTA));
+        ToggleButtonGroup[] buttons = (ToggleButtonGroup[]) frontendController.getPORTbuttons();
+        for (int i = 0; i < buttons.length; i++){
+            int port = (i < 8) ? PORTA : PORTB;
+            int bit = i % 8;
+            boolean value = ((dataRegister.getDirectRegister(port) >> bit) & 1) == 1;
+            buttons[i].getToggles().get(0).setSelected(!value);
+            buttons[i].getToggles().get(1).setSelected(value);
+        }
+    }
+
+    public void refreshUI(ToggleButtonGroup[] buttonsTRIS, ToggleButtonGroup[] buttonsPORT) {
+        for (int i = 0; i< buttonsTRIS.length; i++){
+            int tris = (i < 8) ? trisLatch[A] : trisLatch[B];
+            boolean val = isInput(tris, i%8);
+            buttonsPORT[i].setDisable(!val);
+            buttonsTRIS[i].getToggles().get(0).setSelected(val);
+            buttonsTRIS[i].getToggles().get(1).setSelected(!val);
+            updateLEDs(true, i, val);
+        }
+    }
+
+    private void updateLEDs(boolean updateAll, int index, boolean val) {
+        if (updateAll) {
+            if (index < 8) {
+                if (isLEDenabledA && !val) {
+                    if (dataRegister.getDirectBit(PORTA, index) == 1)
+                        allLEDsA[index].setFill(new RadialGradient(0, 0, 0.5, 0.5, 0.7, true, null, new Stop(0, Color.BLACK), new Stop(1, Color.DARKGRAY)));
+                    else
+                        allLEDsA[index].setFill(new RadialGradient(0, 0, 0.5, 0.5, 0.7, true, null, new Stop(0, Color.BLACK), new Stop(1, Color.DARKGRAY)));
+                }
+            } else {
+                if (isLEDenabledB && !val) {
+                    if (dataRegister.getDirectBit(PORTB, index - 8) == 1)
+                        allLEDsB[index - 8].setFill(new RadialGradient(0, 0, 0.5, 0.5, 0.7, true, null, new Stop(0, Color.RED), new Stop(1, Color.DARKGRAY)));
+                    else
+                        allLEDsB[index - 8].setFill(new RadialGradient(0, 0, 0.5, 0.5, 0.7, true, null, new Stop(0, Color.BLACK), new Stop(1, Color.DARKGRAY)));
+                }
+            }
+        }
+        else {
+            if (index < 8)
+                if (val || dataRegister.getDirectBit(PORTA, index) == 0)
+                    allLEDsA[index].setFill(new RadialGradient(0, 0, 0.5, 0.5, 0.7, true, null, new Stop(0, Color.BLACK), new Stop(1, Color.DARKGRAY)));
+                else
+                    allLEDsA[index].setFill(new RadialGradient(0, 0, 0.5, 0.5, 0.7, true, null, new Stop(0, Color.RED), new Stop(1, Color.DARKGRAY)));
+            else
+            if (val || dataRegister.getDirectBit(PORTB, index - 8) == 0)
+                allLEDsB[index - 8].setFill(new RadialGradient(0, 0, 0.5, 0.5, 0.7, true, null, new Stop(0, Color.BLACK), new Stop(1, Color.DARKGRAY)));
+            else
+                allLEDsB[index - 8].setFill(new RadialGradient(0, 0, 0.5, 0.5, 0.7, true, null, new Stop(0, Color.RED), new Stop(1, Color.DARKGRAY)));
+        }
+    }
+
+    private boolean isInput(int i, int bit) {
+        return (i >> bit & 1) == 1;
+    }
+
+    public void setTRISfromUI(ToggleButtonGroup parent) throws IOException {
+        int [] params = getToggleParams(parent);
+        int tris = params[0];
+        int bit = params[1];
+        int value = params[2];
+        ToggleButtonGroup [] buttonsPORT = (ToggleButtonGroup[]) frontendController.getPORTbuttons();
+        if (value == 1){
+            setBit(tris, bit);
+            buttonsPORT[(tris-TRISA)*8 + bit].setDisable(false);
+        }
+        else{
+            clearBit(tris, bit);
+            buttonsPORT[(tris-TRISA)*8 + bit].setDisable(true);
+        }
+        updateLEDs(false, (tris-TRISA)*8 + bit, value == 1);
+        refreshPorts();
+        refreshTable(parent);
+    }
+
+    public void setPORTfromUI(ToggleButtonGroup parent) throws IOException {
+        int [] params = getToggleParams(parent);
+        int port = params[0];
+        int bit = params[1];
+        int value = params [2];
+        value = (value == 1) ? 0 : 1;
+        int oldValue = dataRegister.getDirectBit(port, bit);
+        dataRegister.setDirectBit(port, bit, value);
+        refreshPorts();
+        refreshTable(parent);
+        if (port == PORTB && bit >= 4)
+            interrupts.triggerRBInterrupt(oldValue, value);
+        else if (port == PORTB && bit == 0)
+            interrupts.triggerRB0Interrupt(oldValue, value);
+    }
+
+    public void setLEDs (boolean[] leds) {
+        boolean isAnowDisabled = isLEDenabledA && !leds[0];
+        isLEDenabledA = leds[0];
+        boolean isBnowDisabled = isLEDenabledB && !leds[1];
+        isLEDenabledB = leds[1];
+        if (isAnowDisabled){
+            for (Circle circle : allLEDsA) {
+                circle.setFill(new RadialGradient(0, 0, 0.5, 0.5, 0.7, true, null, new Stop(0, Color.BLACK), new Stop(1, Color.DARKGRAY)));
+            }
+        }
+        if (isBnowDisabled){
+            for (Circle circle : allLEDsB) {
+                circle.setFill(new RadialGradient(0, 0, 0.5, 0.5, 0.7, true, null, new Stop(0, Color.BLACK), new Stop(1, Color.DARKGRAY)));
+            }
+        }
+    }
+
+    public void setLEDs (Circle[] a, Circle[] b){
+        allLEDsA = a;
+        allLEDsB = b;
+    }
+
+    public void refreshTable(ToggleButtonGroup parent) {
+        table.refresh();
+        CreateWindow.refreshTable();
+    }
+
+    private int[] getToggleParams(ToggleButtonGroup parent) {
+        String group = parent.getId();
+        ObservableList<ToggleButton> toggles = parent.getToggles();
+        int fileAddress;
+        if (group.contains("TRIS"))
+            if (group.contains("A"))
+                fileAddress = TRISA;
+            else
+                fileAddress = TRISB;
+        else
+        if (group.contains("A"))
+            fileAddress = PORTA;
+        else
+            fileAddress = PORTB;
+        char index =group.charAt(group.length()-1);
+        int bit = Integer.parseInt(String.valueOf(index));
+        int value = (toggles.get(0).isSelected()) ? 1 : 0;
+        return new int[]{fileAddress, bit, value};
+    }
+
+    public void reset() {
+        trisLatch = new int[]{0xFF, 0xFF};
+        dataLatch = new int[2];
+        refreshPorts();
+    }
+
+    public void resetTRIS (){ // Only Backend
+        trisLatch = new int[] {0xFF, 0xFF};
+    }
+
+    @Override
+    public void initialize(PICComponentLocator locator) {
+        super.initialize(locator);
+        System.out.println("IOPorts.\n");
+    }
+
+    @Override
+    public void setPORTfromUI(FrontendSpecificToggleButtonGroup parent) throws IOException {
+        setPORTfromUI((ToggleButtonGroup) parent);
+    }
+
+    @Override
+    public void setTRISfromUI(FrontendSpecificToggleButtonGroup parent) throws IOException {
+        setTRISfromUI((ToggleButtonGroup) parent);
+    }
+
+    @Override
+    public void refreshUI(FrontendSpecificToggleButtonGroup[] trisButtons,
+            FrontendSpecificToggleButtonGroup[] portButtons) {
+        refreshUI((ToggleButtonGroup[]) trisButtons, (ToggleButtonGroup[]) portButtons);
     }
 }

src/main/java/fabrik/simulator/pic16f84/Interrupts.java

@@ -0,0 +1,68 @@
+package fabrik.simulator.pic16f84;
+
+import fabrik.simulator.pic16f84.interfaces.InterruptInterface;
+
+public class Interrupts extends PICComponent implements InterruptInterface {
+    private final int INTCON = 0xB;
+    private final int T0IF = 0x2;
+    private final int ISR = 0x4;
+    private final int GIE = 0x7;
+    private final int T0IE = 0x5;
+    private final int RBIE = 0x3;
+    private final int RBIF = 0x0;
+    private final int INTEDG = 0x6;
+    private final int OPTION = 0x81;
+    private final int INTE = 0x4;
+    private final int INTF = 0x1;
+
+
+    public Interrupts () {
+    }
+
+    public void triggerTMR0(boolean manual) {
+        triggerInterrupt(T0IF, T0IE);
+        if (manual)
+            dataRegister.increasePC();
+    }
+
+    private void triggerInterrupt(int flag, int enableFlag) {
+        dataRegister.setBit(INTCON, flag);
+        enableFlag = dataRegister.getDirectBit(INTCON, enableFlag);
+        int globalFlag = dataRegister.getDirectBit(INTCON, GIE);
+        if (enableFlag == 1) {
+            ExecutionState.wakeUp();
+            if (globalFlag == 1) {
+                dataRegister.clearBit(INTCON, GIE);
+                commands.CALL(ISR);
+            }
+        }
+    }
+
+
+    public void triggerRBInterrupt(int oldValue, int newValue) {
+        if (newValue != oldValue){
+            triggerInterrupt(RBIF, RBIE);
+            dataRegister.increasePC();
+        }
+    }
+
+    public void triggerRB0Interrupt(int oldValue, int newValue){
+        if (newValue != oldValue){
+            int intedg = dataRegister.getDirectBit(OPTION, INTEDG);
+            if (intedg == 1) {
+                if (oldValue == 0 && newValue == 1)
+                    triggerInterrupt(INTF, INTE);
+            } else {
+                if (oldValue == 1 && newValue == 0)
+                    triggerInterrupt(INTF, INTE);
+            }
+            dataRegister.increasePC();
+        }
+    }
+
+
+    @Override
+    public void initialize(PICComponentLocator locator) {
+        super.initialize(locator);
+    }
+}

src/main/java/fabrik/simulator/pic16f84/Main.java

@@ -0,0 +1,25 @@
+package fabrik.simulator.pic16f84;
+
+import fabrik.simulator.pic16f84.interfaces.*;
+
+public class Main {
+    private static final PICComponentLocator picComponents = new PICComponentLocator(); // Subjekt
+
+    public static void main(String[] args) {
+        Commands commands = new Commands();
+        picComponents.registerComponent(CommandInterface.class, commands);
+        picComponents.registerComponent(ExecutionTimeSubject.class, commands);
+        picComponents.registerComponent(DataRegisterInterface.class, new DataRegister());
+        picComponents.registerComponent(EEPROMInterface.class, new EEPROM());
+        picComponents.registerComponent(InterruptInterface.class, new Interrupts());
+        picComponents.registerComponent(PreScalerInterface.class, new PreScaler());
+        picComponents.registerComponent(ProgramStackInterface.class, new ProgramStack());
+        picComponents.registerComponent(TimerInterface.class, new Timer());
+        picComponents.registerComponent(WatchdogTimerInterface.class, new WatchdogTimer());
+        CreateWindow window = new CreateWindow();
+        picComponents.registerComponent(WindowManagement.class, window);
+        picComponents.initAll();
+
+        window.startFromMain(new String[]{});
+    }
+}

src/main/java/fabrik/simulator/pic16f84/PICComponent.java

@@ -0,0 +1,35 @@
+package fabrik.simulator.pic16f84;
+
+import fabrik.simulator.pic16f84.interfaces.*;
+
+public abstract class PICComponent {
+    DataRegisterInterface dataRegister;
+    EEPROMInterface eeprom;
+    PreScalerInterface preScaler;
+    IOPortInterface ioPorts;
+    TimerInterface timer;
+    InterruptInterface interrupts;
+    TableInterface table;
+    FrontendControllerInterface frontendController;
+    WatchdogTimerInterface watchdogTimer;
+    ProgramStackInterface programStack;
+    CommandInterface commands;
+    ExecutionTimeSubject executionTime;
+    ToggleButtonInterface toggleButtonExt;
+
+    public void initialize(PICComponentLocator locator) {
+        toggleButtonExt = locator.getComponent(ToggleButtonInterface.class);
+        dataRegister = locator.getComponent(DataRegisterInterface.class);
+        eeprom = locator.getComponent(EEPROMInterface.class);
+        ioPorts = locator.getComponent(IOPortInterface.class);
+        preScaler = locator.getComponent(PreScalerInterface.class);
+        timer = locator.getComponent(TimerInterface.class);
+        interrupts = locator.getComponent(InterruptInterface.class);
+        frontendController = locator.getComponent(FrontendControllerInterface.class);
+        watchdogTimer = locator.getComponent(WatchdogTimerInterface.class);
+        programStack = locator.getComponent(ProgramStackInterface.class);
+        commands = locator.getComponent(CommandInterface.class);
+        table = locator.getComponent(TableInterface.class);
+        executionTime = locator.getComponent(ExecutionTimeSubject.class);
+    }
+}

src/main/java/fabrik/simulator/pic16f84/PICComponentLocator.java

@@ -0,0 +1,29 @@
+package fabrik.simulator.pic16f84;
+
+import fabrik.simulator.pic16f84.interfaces.*;
+
+import java.util.HashMap;
+
+public class PICComponentLocator {
+    // https://en.wikipedia.org/wiki/Service_locator_pattern
+    private final HashMap<Class<? extends PICComponentInterface>, PICComponentInterface> componentCatalogue;
+
+    public PICComponentLocator() {
+        super();
+        this.componentCatalogue = new HashMap<>();
+    }
+
+    public void registerComponent (Class<? extends PICComponentInterface> componentClass, PICComponentInterface component) {
+        this.componentCatalogue.put(componentClass, component);
+    }
+
+    public <T extends PICComponentInterface> T getComponent(Class<T> componentClass) {
+        T component = (T) this.componentCatalogue.get(componentClass);
+        return component;
+    }
+
+    public void initAll() {
+        for (PICComponentInterface component : componentCatalogue.values()) component.initialize(this);
+    }
+
+}

src/main/java/fabrik/simulator/pic16f84/ParseFile.java

@@ -7,7 +7,7 @@ import java.util.ArrayList;
 import java.util.List;
 
 public class ParseFile {
-    public static int[] parseDatei(String dateiPfad) {
+    public static int[][] parseDatei(String dateiPfad) {
         List<String> zeilen = new ArrayList<>();
 
         // Bei diesem Schritt wird jetzt Zeile für Zeile das richtige Programm eingelesen
@@ -23,10 +23,12 @@ public class ParseFile {
 
         // Initialisierung des Programmspeichers mit 1024 Speicherplätzen
         int[] programmspeicher = new int[1024]; // Wie viele Programmspeicherplätze gibt es? → 1024
+        int[] zeilenspeicher = new int[1024];
 
         // Adresse und Befehle werden ignoriert und nur die Befehle werden in den Programmspeicher gespeichert
 
-        for (String zeile : zeilen) {
+        for (int i = 0; i<zeilen.toArray().length; i++) {
+            String zeile = zeilen.get(i);
             String[] teile = zeile.split("\\s+"); // Spaltenweise werden die einzelnen Befehle getrennt
             if (teile.length >= 2) {
                 try {
@@ -36,6 +38,7 @@ public class ParseFile {
                     // Ausgabe der eingelesenen Zeile
                     System.out.printf("Gelesene Zeile: %s%n", zeile);
 
+                    zeilenspeicher[adresse] = i;
                     programmspeicher[adresse] = befehl; // Befehl im Programmspeicher speichern
                 } catch (NumberFormatException e) {
                     // Wenn ein Fehler aufkommt, wird diese Zeile ignoriert funktioniert
@@ -44,6 +47,6 @@ public class ParseFile {
             }
         }
 
-        return programmspeicher;
+        return new int[][]{programmspeicher, zeilenspeicher};
     }
 }

src/main/java/fabrik/simulator/pic16f84/PreScaler.java

@@ -0,0 +1,60 @@
+package fabrik.simulator.pic16f84;
+
+import fabrik.simulator.pic16f84.interfaces.*;
+
+public class PreScaler extends PICComponent implements PreScalerInterface {
+
+    private final int PSA = 0x3;
+    private final int OPTION = 0x81;
+    private int scaler;
+
+    public PreScaler () {
+        super();
+        scaler = 0b111;
+    }
+
+    @Override
+    public boolean isPrescalerOnTimer(){
+        return dataRegister.getDirectBit(OPTION, PSA) == 0;
+    }
+
+
+
+    @Override
+    public int getScaler() {
+        return scaler;
+    }
+
+    @Override
+    public int getFactor() {
+        int scale = dataRegister.getDirectRegister(OPTION) & 0b111;
+        int timer = isPrescalerOnTimer() ? 1 : 0;
+        return (int) Math.pow (2, scale+timer);
+    }
+
+    @Override
+    public void reset(){
+        dataRegister.setDirectBit(OPTION, 0, 0);
+        dataRegister.setDirectBit(OPTION, 1, 0);
+        dataRegister.setDirectBit(OPTION, 2, 0);
+    }
+
+    @Override
+    public void resetFromRegister() {
+        scaler = getFactor();
+    }
+
+    @Override
+    public void decrement(boolean manual) {
+        scaler--;
+        if (scaler == 0) {
+            scaler = getFactor();
+            timer.increment(manual);
+        }
+    }
+
+    @Override
+    public void initialize(PICComponentLocator locator) {
+        super.initialize(locator);
+    }
+}

src/main/java/fabrik/simulator/pic16f84/ProgramStack.java

@@ -1,13 +1,15 @@
 package fabrik.simulator.pic16f84;
 
+import fabrik.simulator.pic16f84.interfaces.ProgramStackInterface;
+
 import java.util.ArrayList;
 import java.util.List;
 
-public class ProgramStack {
+public class ProgramStack extends PICComponent implements ProgramStackInterface {
-    private static List<Integer> returnStack = new ArrayList<>(8);
+    private List<Integer> returnStack = new ArrayList<>(8);
-    private static int stackIndex = 0;
+    private int stackIndex = 0;
 
-    private static void incIndex(){
+    private void incIndex(){
         if (stackIndex == 7){
             stackIndex = 0;
         }
@@ -16,7 +18,7 @@ public class ProgramStack {
         }
     }
 
-    public static void push(int value) {
+    public void push(int value) {
         if ((returnStack.size() != 8 ) && (returnStack.size() <= stackIndex)){
             returnStack.add(value);
             incIndex();
@@ -27,16 +29,26 @@ public class ProgramStack {
         }
     }
 
-    public static int pop() {
+    public int pop() {
         stackIndex =  (stackIndex > 0) ? --stackIndex : 7;
         return returnStack.get(stackIndex)-1;
     }
 
-    public static int getStackPointer(){
+    public void reset (){
+        returnStack.clear();
+        stackIndex = 0;
+    }
+
+    public int getStackPointer(){
         return stackIndex;
     }
 
-    public static List<Integer> getStack() {
+    public List<Integer> getStack() {
         return returnStack;
     }
+
+    @Override
+    public void initialize(PICComponentLocator locator) {
+        super.initialize(locator);
+    }
 }

src/main/java/fabrik/simulator/pic16f84/Table.java

@@ -0,0 +1,153 @@
+package fabrik.simulator.pic16f84;
+
+import fabrik.simulator.pic16f84.frontendspecifics.VBox;
+import fabrik.simulator.pic16f84.interfaces.*;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.geometry.Insets;
+
+import javafx.scene.control.Button;
+import javafx.scene.control.Label;
+import javafx.scene.control.TableColumn;
+import javafx.scene.control.TableView;
+
+import javafx.scene.layout.HBox;
+
+
+import static javafx.application.Application.launch;
+
+public class Table extends PICComponent implements TableInterface  {
+    private VBox tableBox;
+    private static final int NUM_COLUMNS = 8; // Anzahl der Spalten
+    private static final double TABLE_WIDTH = 425; // Breite der TableView
+    private static final double TABLE_HEIGHT = 600; // Höhe der TableView
+
+    private static String formatHex(String s) {
+        return (s.length() == 1) ? "0" + s : s;
+    }
+
+    private static String formatBin (String s){
+        int l = s.length();
+        if (l < 8){
+            StringBuilder sBuilder = new StringBuilder(s);
+            for (int i = 0; i < 8 - l; i++){
+                sBuilder.insert(0, "0");
+            }
+            s = sBuilder.toString();
+        }
+        return s;
+    }
+
+    public VBox getTable(){
+        refresh();
+        return tableBox;
+    }
+
+    public void refresh() {
+        // Erstelle eine TableView für die Datenanzeige
+        TableView<DataEntry[]> tableView = new TableView<>();
+        tableView.setPrefWidth(TABLE_WIDTH);
+        tableView.setPrefHeight(TABLE_HEIGHT);
+        // Erstelle Spalten für die TableView
+        for (int i = 0; i < NUM_COLUMNS; i++) {
+            TableColumn<DataEntry[], String> column = new TableColumn<>("0" + (i));
+            final int columnIndex = i;
+            column.setCellValueFactory(cellData -> {
+                if (cellData.getValue() != null && cellData.getValue().length > columnIndex) {
+                    return new SimpleStringProperty(cellData.getValue()[columnIndex].getValue());
+                } else {
+                    return new SimpleStringProperty("");
+                }
+            });
+            tableView.getColumns().add(column);
+        }
+        // Fülle die TableView mit Daten aus dem Array
+        int numRows = (int) Math.ceil((double) dataRegister.getDataRegister().length / NUM_COLUMNS);
+        for (int row = 0; row < numRows; row++) {
+            DataEntry[] rowData = new DataEntry[NUM_COLUMNS];
+            for (int col = 0; col < NUM_COLUMNS; col++) {
+                int index = row * NUM_COLUMNS + col;
+                if (index < dataRegister.getDataRegister().length) {
+                    String address = "0x" + formatHex(Integer.toHexString(index).toUpperCase());
+                    String value = "0x" + formatHex(Integer.toHexString(dataRegister.getDataRegister()[index]).toUpperCase());
+                    rowData[col] = new DataEntry(address, value);
+                } else {
+                    rowData[col] = new DataEntry("", "");
+                }
+            }
+            tableView.getItems().add(rowData);
+        }
+
+        // Erstelle Labels für die Spezialregister;
+
+        Label spacing = new Label(" ");
+        Label spacing2 = new Label(" ");
+        Label wRegisterLabel = new Label("W-Register: 0x" + formatHex(Integer.toHexString(commands.get_wRegister()).toUpperCase()));
+        Label cLabel = new Label("Carry-Flag: " + dataRegister.getCarryFlag());
+        Label dcLabel = new Label("DigitCarry-Flag: " + dataRegister.getDigitCarryFlag());
+        Label zLabel = new Label("Zero-Flag: " + dataRegister.getZeroFlag());
+        Label pcLabel = new Label("PC: 0x" + formatHex(Integer.toHexString(dataRegister.getPC()).toUpperCase()));
+        Label pclLabel = new Label("PCL: 0x" + formatHex(Integer.toHexString(dataRegister.getRegister(dataRegister.getPCL())).toUpperCase()));
+        Label pclathLabel = new Label("PCLATH: 0x" + formatHex(Integer.toHexString(dataRegister.getRegister(dataRegister.getPCLATH())).toUpperCase()));
+        Label statusLabel = new Label("STATUS: 0b" + formatBin(Integer.toBinaryString(dataRegister.getRegister(dataRegister.getSTATUS())))+ " (0x" + formatHex(Integer.toHexString(dataRegister.getRegister(dataRegister.getSTATUS())).toUpperCase()) + ")");
+        Label fsrLabel = new Label("FSR: 0x" + formatHex(Integer.toHexString(dataRegister.getFSR()).toUpperCase()));
+        Label prescalerLabel = new Label("Prescaler: 0x" + formatHex(Integer.toHexString(preScaler.getScaler())).toUpperCase());
+        Label intconLabel = new Label("INTCON: 0b" + formatBin(Integer.toBinaryString(dataRegister.getRegister(dataRegister.getINTCON()))) + " (0x" + formatHex(Integer.toHexString(dataRegister.getRegister(dataRegister.getINTCON())).toUpperCase()) + ")");
+        wRegisterLabel.setStyle("-fx-font-weight: bold");
+        pcLabel.setStyle("-fx-font-weight: bold");
+        statusLabel.setStyle("-fx-font-weight: bold");
+        intconLabel.setStyle("-fx-font-weight: bold");
+
+        HBox labelsAndButton = new HBox();
+        VBox labels = new VBox();
+        labels.getChildren().addAll(spacing, pcLabel, pclLabel, pclathLabel, wRegisterLabel, cLabel, dcLabel, zLabel, statusLabel, fsrLabel, prescalerLabel, intconLabel);
+        VBox button = new VBox();
+        Button resetButton = new Button("SFR reset");
+        resetButton.setOnAction(e -> {
+            triggerReset();
+        });
+
+        button.getChildren().addAll(spacing2, resetButton);
+
+        labelsAndButton.getChildren().addAll(labels, button);
+
+
+        // Erstelle einen VBox, um die TableView und Labels anzuzeigen
+        VBox table = new VBox();
+        table.getChildren().addAll(tableView, labelsAndButton);
+        VBox.setMargin(tableView, new Insets(0, 0, 0, 0));
+        tableBox = table;
+    }
+
+    private void triggerReset() {
+        dataRegister.initDataRegister();
+        ioPorts.refreshUI(frontendController.getTRISbuttons(), frontendController.getPORTbuttons());
+        CreateWindow.refreshTable();
+    }
+
+    public static void main(String[] args) {
+        launch(args);
+    }
+
+    // Hilfsklasse für die Datenanzeige in der TableView
+    public static class DataEntry {
+        private final String address;
+        private final String value;
+
+        public DataEntry(String address, String value) {
+            this.address = address;
+            this.value = value;
+        }
+
+        public String getAddress() {
+            return address;
+        }
+
+        public String getValue() {
+            return value;
+        }
+    }
+
+    public void initialize(PICComponentLocator picComponents) {
+        super.initialize(picComponents);
+    }
+}

src/main/java/fabrik/simulator/pic16f84/Timer.java

@@ -0,0 +1,77 @@
+package fabrik.simulator.pic16f84;
+
+import fabrik.simulator.pic16f84.interfaces.ExecutionTimeObserver;
+import fabrik.simulator.pic16f84.interfaces.TimerInterface;
+
+public class Timer extends PICComponent implements TimerInterface, ExecutionTimeObserver {
+    private final int TIMERREG = 0x1;
+    private final int T0SE = 0x4;
+    private final int T0CS = 0x5;
+    private final int OPTION = 0x81;
+
+    private int oldpin = 0;
+    
+    public Timer (){
+    }
+
+    public void cycles(int cycles){
+        if (dataRegister.getDirectBit(OPTION, T0CS) == 0){
+            if (preScaler.isPrescalerOnTimer()){
+                for (int i = 0; i < cycles; i++){
+                    preScaler.decrement(false);
+                }
+            } else {
+                increment(false);
+            }
+        }
+    }
+
+
+    public void incrementFromPin (int register){
+        if ((dataRegister.getDirectBit(OPTION, T0CS) == 1) && !ExecutionState.isSleeping()){
+            int newpin = (register >> 4) & 1;
+            if (newpin != oldpin) {
+                if (dataRegister.getDirectBit(OPTION, T0SE) == 0) {
+                    // Low to high
+                    if (newpin == 1 && oldpin == 0) {
+                        if (preScaler.isPrescalerOnTimer())
+                            preScaler.decrement(true);
+                        else
+                            increment(true);
+                    }
+                } else {
+                    // High to low
+                    if (newpin == 0 && oldpin == 1) {
+                        if (preScaler.isPrescalerOnTimer())
+                            preScaler.decrement(true);
+                        else
+                            increment(true);
+                    }
+                }
+                oldpin = newpin;
+            }
+        }
+    }
+
+    public void increment(boolean manual) {
+        int timer = dataRegister.getDirectRegister(TIMERREG);
+        timer++;
+        if (timer > 0xFF){
+            interrupts.triggerTMR0(manual);
+            dataRegister.setDirectRegister(TIMERREG, 0);
+        } else {
+            dataRegister.setDirectRegister(1, timer);
+        }
+    }
+
+    @Override
+    public void initialize(PICComponentLocator locator) {
+        super.initialize(locator);
+        executionTime.registerObserver(this);
+    }
+
+    @Override
+    public void executionTimeChanged() {
+        cycles((int) executionTime.getTotalExecutionTime());
+    }
+}

src/main/java/fabrik/simulator/pic16f84/ToggleButtonGroupExt.java

@@ -0,0 +1,67 @@
+package fabrik.simulator.pic16f84;
+
+
+import fabrik.simulator.pic16f84.frontendspecifics.FrontendSpecificObject;
+import fabrik.simulator.pic16f84.frontendspecifics.ToggleButtonGroup;
+import fabrik.simulator.pic16f84.interfaces.ToggleButtonInterface;
+import javafx.collections.ListChangeListener;
+import javafx.event.EventHandler;
+import javafx.scene.control.Toggle;
+import javafx.scene.control.ToggleButton;
+import javafx.scene.input.MouseEvent;
+
+import java.io.IOException;
+
+public class ToggleButtonGroupExt extends PICComponent implements ToggleButtonInterface, FrontendSpecificObject {
+
+
+    private static ToggleButtonGroupExt me;
+
+    public ToggleButtonGroupExt() {
+    }
+
+
+    public void addAlwaysOneSelectedSupport(final ToggleButtonGroup toggleGroup) {
+        toggleGroup.getToggles().addListener((ListChangeListener.Change<? extends Toggle> c) -> {
+            while (c.next()) {
+                for (final Toggle addedToggle : c.getAddedSubList()) {
+                    addConsumeMouseEventfilter(addedToggle);
+                }
+            }
+        });
+        toggleGroup.getToggles().forEach(this::addConsumeMouseEventfilter);
+    }
+
+    private void addConsumeMouseEventfilter(Toggle toggle) {
+        ((ToggleButton) toggle).addEventFilter(MouseEvent.MOUSE_PRESSED, consumeMouseEventfilter);
+        ((ToggleButton) toggle).addEventFilter(MouseEvent.MOUSE_RELEASED, consumeMouseEventfilter);
+        ((ToggleButton) toggle).addEventFilter(MouseEvent.MOUSE_CLICKED, consumeMouseEventfilter);
+    }
+
+    public EventHandler<MouseEvent> consumeMouseEventfilter = (MouseEvent mouseEvent) -> {
+        if (((Toggle) mouseEvent.getSource()).isSelected()) {
+            ToggleButtonGroup parent = (ToggleButtonGroup) ((ToggleButton) mouseEvent.getSource()).getParent();
+            if (parent.getId().contains("TRIS")) {
+                try {
+                    ioPorts.setTRISfromUI(parent);
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            else {
+                try {
+                    ioPorts.setPORTfromUI(parent);
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            mouseEvent.consume();
+        }
+    };
+
+
+    public void initialize(PICComponentLocator locator) {
+        System.out.println("ToggleButtonGroupExt");
+        super.initialize(locator);
+    }
+}

src/main/java/fabrik/simulator/pic16f84/WatchdogTimer.java

@@ -0,0 +1,59 @@
+package fabrik.simulator.pic16f84;
+
+import fabrik.simulator.pic16f84.interfaces.*;
+
+public class WatchdogTimer extends PICComponent implements WatchdogTimerInterface {
+    private long watchdogTime;
+    private double lastReset = 0;
+    private boolean enabled = false;
+    private long rawtimer = 0;
+    private long realtimer = 0;
+
+    public WatchdogTimer(){
+    }
+        
+    private long getTimeFromRegister() {
+        return (preScaler.isPrescalerOnTimer()) ? 18L : preScaler.getFactor() * 18L;
+    }
+
+    public void testAndTrigger() {
+        watchdogTime = getTimeFromRegister() * 1000;
+        if (enabled) {
+            if (realtimer >= (watchdogTime + lastReset - 1)) {
+                dataRegister.clearBit(3, 4);
+                lastReset = executionTime.getTotalExecutionTime();
+                frontendController.stopRunFromBackend("Watchdog Timer");
+            }
+            else {
+                rawtimer++;
+                realtimer = (long) (rawtimer * executionTime.getExecutionTimeMultiplier());
+            }
+        }
+    }
+
+    public void reset (){
+        lastReset = executionTime.getTotalExecutionTime();
+        rawtimer = 0;
+        realtimer = 0;
+        preScaler.reset();
+        dataRegister.setBit(3, 3);
+        dataRegister.setBit(3, 4);
+    }
+
+    public void enable() {
+        enabled = true;
+    }
+
+    public void disable() {
+        enabled = false;
+    }
+
+    public long get (){
+        return realtimer;
+    }
+
+    @Override
+    public void initialize(PICComponentLocator locator) {
+        super.initialize(locator);
+    }
+}

src/main/java/fabrik/simulator/pic16f84/frontendspecifics/FrontendSpecificObject.java

@@ -0,0 +1,4 @@
+package fabrik.simulator.pic16f84.frontendspecifics;
+
+public interface FrontendSpecificObject { 
+}

src/main/java/fabrik/simulator/pic16f84/frontendspecifics/FrontendSpecificToggleButtonGroup.java

@@ -0,0 +1,5 @@
+package fabrik.simulator.pic16f84.frontendspecifics;
+
+public interface FrontendSpecificToggleButtonGroup extends FrontendSpecificObject{
+    
+}

src/main/java/fabrik/simulator/pic16f84/frontendspecifics/FrontendSpecificVBox.java

@@ -0,0 +1,4 @@
+package fabrik.simulator.pic16f84.frontendspecifics;
+
+public interface FrontendSpecificVBox extends FrontendSpecificObject {
+}

src/main/java/fabrik/simulator/pic16f84/frontendspecifics/ToggleButtonGroup.java

@@ -0,0 +1,13 @@
+package fabrik.simulator.pic16f84.frontendspecifics;
+
+import javafx.scene.control.ToggleButton;
+
+public class ToggleButtonGroup extends com.gluonhq.charm.glisten.control.ToggleButtonGroup implements FrontendSpecificToggleButtonGroup {
+    public ToggleButtonGroup(){
+        super();
+    }
+
+    public ToggleButtonGroup(ToggleButton... toggles) {
+        super(toggles);
+    }    
+}

src/main/java/fabrik/simulator/pic16f84/frontendspecifics/VBox.java

@@ -0,0 +1,7 @@
+package fabrik.simulator.pic16f84.frontendspecifics;
+
+public class VBox extends javafx.scene.layout.VBox implements FrontendSpecificVBox {
+    public VBox(){
+        super();
+    }
+}

src/main/java/fabrik/simulator/pic16f84/interfaces/CommandInterface.java

@@ -0,0 +1,12 @@
+package fabrik.simulator.pic16f84.interfaces;
+
+public interface CommandInterface extends PICComponentInterface {
+    void CALL(int isr);
+
+    int get_wRegister();
+
+    void decode(int i);
+
+
+
+}

src/main/java/fabrik/simulator/pic16f84/interfaces/DataRegisterInterface.java

@@ -0,0 +1,59 @@
+package fabrik.simulator.pic16f84.interfaces;
+
+public interface DataRegisterInterface extends PICComponentInterface {
+    void clearBit(int f, int b);
+
+    void setBit(int f, int b);
+
+    void setPC(int pop);
+
+    int getINTCON();
+
+    int getPC();
+
+    void setRegister(int file, int wRegister);
+
+    void determineZeroFlag(int wRegister);
+
+    int getRegister(int file);
+
+    void setCarryFlag(int i);
+
+    void setDigitCarryFlag(int i);
+
+    int getCarryFlag();
+
+    void determineCarryFlag(int result);
+
+    void increasePC();
+
+    void determineDigitCarryFlag(int i);
+
+    int getBit(int address, int bit);
+
+    int getDirectBit(int option, int psa);
+
+    int getDirectRegister(int option);
+
+    void setDirectBit(int option, int i, int i1);
+
+    void setDirectRegister(int porta, int i);
+
+    void resetPC();
+
+    int[] getDataRegister();
+
+    int getDigitCarryFlag();
+
+    int getZeroFlag();
+
+    int getFSR();
+
+    void initDataRegister();
+
+    int getPCL();
+
+    int getPCLATH();
+
+    int getSTATUS();
+}

src/main/java/fabrik/simulator/pic16f84/interfaces/EEPROMInterface.java

@@ -0,0 +1,11 @@
+package fabrik.simulator.pic16f84.interfaces;
+
+public interface EEPROMInterface extends PICComponentInterface {
+    void registerTime(double executionTime, boolean b);
+
+    void parse(int i, int content, int i1);
+
+    long read(int address);
+
+    void write (int address, long data);
+}

src/main/java/fabrik/simulator/pic16f84/interfaces/ExecutionTimeObserver.java

@@ -0,0 +1,5 @@
+package fabrik.simulator.pic16f84.interfaces;
+
+public interface ExecutionTimeObserver {
+    void executionTimeChanged();
+}

src/main/java/fabrik/simulator/pic16f84/interfaces/FrontendControllerInterface.java

@@ -0,0 +1,13 @@
+package fabrik.simulator.pic16f84.interfaces;
+
+import fabrik.simulator.pic16f84.frontendspecifics.FrontendSpecificObject;
+import fabrik.simulator.pic16f84.frontendspecifics.FrontendSpecificToggleButtonGroup;
+
+public interface FrontendControllerInterface extends PICComponentInterface, FrontendSpecificObject {
+
+    FrontendSpecificToggleButtonGroup[] getPORTbuttons();
+
+    FrontendSpecificToggleButtonGroup[] getTRISbuttons();
+
+    void stopRunFromBackend(String watchdogTimer);
+}

src/main/java/fabrik/simulator/pic16f84/interfaces/IOPortInterface.java

@@ -0,0 +1,30 @@
+package fabrik.simulator.pic16f84.interfaces;
+
+import javafx.scene.shape.Circle;
+
+import java.io.IOException;
+
+import fabrik.simulator.pic16f84.frontendspecifics.FrontendSpecificObject;
+import fabrik.simulator.pic16f84.frontendspecifics.FrontendSpecificToggleButtonGroup;
+
+public interface IOPortInterface extends PICComponentInterface, FrontendSpecificObject {
+    void resetTRIS();
+
+    void setRegister(int i, int content);
+
+    void clearBit(int i, int bit);
+
+    void setBit(int i, int bit);
+
+    void setPORTfromUI(FrontendSpecificToggleButtonGroup parent) throws IOException;
+
+    void setTRISfromUI(FrontendSpecificToggleButtonGroup parent) throws IOException;
+
+    void refreshUI(FrontendSpecificToggleButtonGroup[] trisButtons, FrontendSpecificToggleButtonGroup[] portButtons);
+
+    void reset();
+
+    void setLEDs(Circle[] allLEDsA, Circle[] allLEDsB);
+
+    void setLEDs(boolean[] booleans);
+}

src/main/java/fabrik/simulator/pic16f84/interfaces/InterruptInterface.java

@@ -0,0 +1,9 @@
+package fabrik.simulator.pic16f84.interfaces;
+
+public interface InterruptInterface extends PICComponentInterface {
+    void triggerRBInterrupt(int oldValue, int value);
+
+    void triggerRB0Interrupt(int oldValue, int value);
+
+    void triggerTMR0(boolean manual);
+}

src/main/java/fabrik/simulator/pic16f84/interfaces/PICComponentInterface.java

@@ -0,0 +1,7 @@
+package fabrik.simulator.pic16f84.interfaces;
+
+import fabrik.simulator.pic16f84.PICComponentLocator;
+
+public interface PICComponentInterface {
+    void initialize(PICComponentLocator picComponents);
+}

src/main/java/fabrik/simulator/pic16f84/interfaces/PreScalerInterface.java

@@ -0,0 +1,15 @@
+package fabrik.simulator.pic16f84.interfaces;
+
+public interface PreScalerInterface extends PICComponentInterface{
+    boolean isPrescalerOnTimer();
+
+    int getScaler();
+
+    int getFactor();
+
+    void reset();
+
+    void resetFromRegister();
+
+    void decrement(boolean manual);
+}

src/main/java/fabrik/simulator/pic16f84/interfaces/ProgramStackInterface.java

@@ -0,0 +1,15 @@
+package fabrik.simulator.pic16f84.interfaces;
+
+import java.util.List;
+
+public interface ProgramStackInterface extends PICComponentInterface {
+    int pop();
+
+    void push(int i);
+
+    void reset();
+
+    int getStackPointer();
+
+    List<Integer> getStack();
+}

src/main/java/fabrik/simulator/pic16f84/interfaces/TableInterface.java

@@ -0,0 +1,10 @@
+package fabrik.simulator.pic16f84.interfaces;
+
+import fabrik.simulator.pic16f84.frontendspecifics.FrontendSpecificVBox;
+import javafx.scene.layout.VBox;
+
+public interface TableInterface extends PICComponentInterface {
+    void refresh();
+
+    FrontendSpecificVBox getTable();
+}

src/main/java/fabrik/simulator/pic16f84/interfaces/TimerInterface.java

@@ -0,0 +1,9 @@
+package fabrik.simulator.pic16f84.interfaces;
+
+public interface TimerInterface extends PICComponentInterface {
+    void cycles(int i);
+
+    void incrementFromPin(int directRegister);
+
+    void increment(boolean manual);
+}

src/main/java/fabrik/simulator/pic16f84/interfaces/ToggleButtonInterface.java

@@ -0,0 +1,8 @@
+package fabrik.simulator.pic16f84.interfaces;
+
+import fabrik.simulator.pic16f84.frontendspecifics.FrontendSpecificObject;
+import fabrik.simulator.pic16f84.frontendspecifics.ToggleButtonGroup;
+
+public interface ToggleButtonInterface extends PICComponentInterface, FrontendSpecificObject {
+    void addAlwaysOneSelectedSupport(ToggleButtonGroup allTRISButton);
+}

src/main/java/fabrik/simulator/pic16f84/interfaces/WatchdogTimerInterface.java

@@ -0,0 +1,13 @@
+package fabrik.simulator.pic16f84.interfaces;
+
+public interface WatchdogTimerInterface extends PICComponentInterface {
+    void reset();
+
+    void testAndTrigger();
+
+    void enable();
+
+    void disable();
+
+    long get();
+}

src/main/java/fabrik/simulator/pic16f84/interfaces/WindowManagement.java

@@ -0,0 +1,7 @@
+package fabrik.simulator.pic16f84.interfaces;
+
+public interface WindowManagement extends PICComponentInterface {
+    static void refreshTable() {}
+
+    static void startFromMain(String[] args) {}
+}

src/main/java/fabrik/simulator/pic16f84/styles.css

@@ -0,0 +1,10 @@
+.breakpoint-icon {
+    -fx-background-color: transparent;
+    -fx-shape: "M 0 0 L 10 5 L 0 10 Z"; /* Dreieck-Symbol */
+    -fx-background-insets: 0;
+    -fx-padding: 0;
+    -fx-background-radius: 0;
+    -fx-shape-padding: 0;
+    -fx-scale-shape: false;
+    -fx-cursor: hand;
+}

src/main/java/module-info.java

@@ -6,7 +6,14 @@ module fabrik.simulator.pic16f84 {
     requires org.controlsfx.controls;
     requires org.kordamp.ikonli.javafx;
     requires eu.hansolo.tilesfx;
+    requires charm.glisten;
+    requires jdk.jsobject;
+    requires json.simple;
 
     opens fabrik.simulator.pic16f84 to javafx.fxml;
+    opens fabrik.simulator.pic16f84.frontendspecifics to javafx.fxml;
     exports fabrik.simulator.pic16f84;
+    exports fabrik.simulator.pic16f84.interfaces;
+    exports fabrik.simulator.pic16f84.frontendspecifics;
+    opens fabrik.simulator.pic16f84.interfaces to javafx.fxml;
 }

src/main/resources/fabrik/simulator/pic16f84/FileSelector.fxml

@@ -1,21 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-
-<?import javafx.geometry.*?>
-<?import javafx.scene.control.*?>
-<?import javafx.scene.layout.*?>
-
-<AnchorPane prefHeight="500.0" prefWidth="500.0" xmlns="http://javafx.com/javafx/17.0.2-ea"
-            xmlns:fx="http://javafx.com/fxml/1" fx:controller="fabrik.simulator.pic16f84.Controller_FileSelect">
-   <VBox alignment="CENTER" prefHeight="500.0" prefWidth="500.0" AnchorPane.bottomAnchor="0.0"
-         AnchorPane.leftAnchor="0.0" AnchorPane.rightAnchor="0.0" AnchorPane.topAnchor="0.0">
-      <Label text="Willkommen beim PIC-Simulator!" textAlignment="CENTER">
-         <padding>
-            <Insets bottom="10.0"/>
-         </padding>
-         <VBox.margin>
-            <Insets bottom="10.0"/>
-         </VBox.margin>
-      </Label>
-      <Button mnemonicParsing="false" onAction="#selectFileLST" text="Datei auswählen!"/>
-   </VBox>
-</AnchorPane>

src/main/resources/fabrik/simulator/pic16f84/MainBody.fxml

@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-
-<?import javafx.scene.layout.*?>
-<?import javafx.scene.text.*?>
-
-
-<AnchorPane prefHeight="400.0" prefWidth="600.0" xmlns="http://javafx.com/javafx/17.0.2-ea"
-            xmlns:fx="http://javafx.com/fxml/1" fx:controller="fabrik.simulator.pic16f84.Controller_MainBody">
-   <VBox alignment="CENTER" prefHeight="400.0" prefWidth="600.0" AnchorPane.bottomAnchor="0.0"
-         AnchorPane.leftAnchor="0.0" AnchorPane.rightAnchor="0.0" AnchorPane.topAnchor="0.0">
-      <Text strokeType="OUTSIDE" strokeWidth="0.0" text="Hauptseite"/>
-   </VBox>
-</AnchorPane>

src/main/resources/fabrik/simulator/pic16f84/styles.css

@@ -0,0 +1,3 @@
+.list-cell:selected {
+    -fx-background-color: red;
+}

src/test/java/fabrik/simulator/pic16f84/CommandsTests.java

@@ -0,0 +1,88 @@
+package fabrik.simulator.pic16f84;
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import fabrik.simulator.pic16f84.interfaces.*;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+
+class CommandsTests {
+    PICComponentLocator picComponents;
+
+    public CommandsTests() {}
+
+    @BeforeEach
+    void resetComponents() {
+        picComponents = new PICComponentLocator();
+    }
+
+    @Test
+    @DisplayName("Execution Time wird korrekt addiert")
+    void executionTimeIsAddedCorrectly() {
+        TimerInterface timerMock = mock(TimerInterface.class);
+        picComponents.registerComponent(TimerInterface.class, timerMock);
+
+        EEPROMInterface eepromMock = mock(EEPROMInterface.class);
+        picComponents.registerComponent(EEPROMInterface.class, eepromMock);
+
+        Commands commands = new Commands();
+        picComponents.registerComponent(CommandInterface.class, commands);
+        picComponents.initAll();
+
+
+        commands.addExecutionTime(5);
+
+
+        assertEquals(5, commands.getTotalExecutionTime());
+    }
+
+    @Test
+    @DisplayName("Execution Time wird korrekt zurückgesetzt")
+    void executionTimeResetWorks() {
+        TimerInterface timerMock = mock(TimerInterface.class);
+        picComponents.registerComponent(TimerInterface.class, timerMock);
+
+        EEPROMInterface eepromMock = mock(EEPROMInterface.class);
+        picComponents.registerComponent(EEPROMInterface.class, eepromMock);
+
+        Commands commands = new Commands();
+        picComponents.registerComponent(CommandInterface.class, commands);
+        picComponents.initAll();
+
+
+        commands.addExecutionTime(5);
+        commands.resetTotalExecutionTime();
+
+
+        assertEquals(0, commands.getTotalExecutionTime());
+    }
+
+    @Test
+    @DisplayName("Execution Time Faktor wird berücksichtigt")
+    void executionTimeMultiplierIsUsed() {
+        TimerInterface timerMock = mock(TimerInterface.class);
+        picComponents.registerComponent(TimerInterface.class, timerMock);
+
+        EEPROMInterface eepromMock = mock(EEPROMInterface.class);
+        picComponents.registerComponent(EEPROMInterface.class, eepromMock);
+
+        Commands commands = new Commands();
+        picComponents.registerComponent(CommandInterface.class, commands);
+        picComponents.initAll();
+
+        commands.addExecutionTime(5);
+        commands.setExecutionTimeMultiplier("100 HZ");
+
+        assertEquals(5 * 40, commands.getTotalExecutionTime());
+    }
+
+    @Test
+    @DisplayName("Decode mit ungültigem Opcode wirft keine Exception")
+    void decodeInvalidOpcodeDoesNotCrash() {
+        CommandInterface commands = new Commands();
+
+        assertDoesNotThrow(() -> commands.decode(1));
+    }
+}

src/test/java/fabrik/simulator/pic16f84/DataRegisterTests.java

@@ -0,0 +1,50 @@
+package fabrik.simulator.pic16f84;
+
+import fabrik.simulator.pic16f84.interfaces.*;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.mock;
+
+class DataRegisterTests {
+    PICComponentLocator picComponents;
+
+    public DataRegisterTests() {}
+
+    @BeforeEach
+    void resetComponents() {
+        picComponents = new PICComponentLocator();
+    }
+
+
+    @Test
+    @DisplayName("DataRegister wird durch Components initialisiert und enthält dann die korrekten Startwerte")
+    void registerGetsInitializedThroughComponents() {
+        IOPortInterface mockIOPorts = mock(IOPortInterface.class);
+        picComponents.registerComponent(IOPortInterface.class, mockIOPorts);
+
+        DataRegisterInterface dataRegister = new DataRegister();
+        picComponents.registerComponent(DataRegisterInterface.class, dataRegister);
+
+
+        picComponents.initAll();
+        int [] expected = {0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                            0, 0, 0, 0, 0, 255, 0, 24, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                            0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+        int [] actual = dataRegister.getDataRegister();
+
+        assertEquals(expected.length, actual.length);
+        for (int i = 0; i<expected.length; i++){
+            assertEquals(expected[i], actual[i]);
+        }
+    }
+}

src/test/java/fabrik/simulator/pic16f84/EEPROMTests.java

@@ -0,0 +1,135 @@
+package fabrik.simulator.pic16f84;
+
+import fabrik.simulator.pic16f84.interfaces.CommandInterface;
+import fabrik.simulator.pic16f84.interfaces.DataRegisterInterface;
+import fabrik.simulator.pic16f84.interfaces.EEPROMInterface;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+
+import java.io.FileWriter;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.mock;
+
+
+class EEPROMTests {
+    PICComponentLocator picComponents;
+    String savedEEPROM;
+
+    public EEPROMTests() {}
+
+    @BeforeEach
+    void resetComponentsAndReadEEPROM() throws IOException {
+        picComponents = new PICComponentLocator();
+        savedEEPROM = Files.readString(Path.of("eeprom.json"));
+    }
+
+    @AfterEach
+    public void rewriteEEPROM() throws IOException {
+        FileWriter writer = new FileWriter("eeprom.json");
+        writer.write(savedEEPROM);
+        writer.close();
+    }
+
+    @Test
+    @DisplayName("EEPROM read gibt gültigen Wert zurück")
+    void eepromReadReturnsValidLong() throws IOException {
+        FileWriter writer = new FileWriter("eeprom.json");
+        writer.write("{\"0\": 255}");
+        writer.close();
+
+        DataRegisterInterface mockDataRegister = Mockito.mock(DataRegisterInterface.class);
+        picComponents.registerComponent(DataRegisterInterface.class, mockDataRegister);
+
+        EEPROMInterface eeprom = new EEPROM();
+        picComponents.registerComponent(EEPROMInterface.class, eeprom);
+        picComponents.initAll();
+
+
+        long value = eeprom.read(0);
+
+
+        assertEquals(255, value);
+    }
+
+
+    @Test
+    @DisplayName("EEPROM write schreibt an die korrekte Adresse in eeprom.json")
+    void eepromWritesCorrectly() throws IOException {
+        FileWriter writer = new FileWriter("eeprom.json");
+        writer.write("{}");
+        writer.close();
+
+        DataRegisterInterface mockDataRegister = Mockito.mock(DataRegisterInterface.class);
+        picComponents.registerComponent(DataRegisterInterface.class, mockDataRegister);
+
+        ExecutionTimeSubject mockExecutionTime = mock(ExecutionTimeSubject.class);
+        picComponents.registerComponent(ExecutionTimeSubject.class, mockExecutionTime);
+
+        EEPROMInterface eeprom = new EEPROM();
+        picComponents.registerComponent(EEPROMInterface.class, eeprom);
+        picComponents.initAll();
+
+
+        eeprom.write(3, 123);
+
+
+        assertEquals("{\"3\":123}", Files.readString(Path.of("eeprom.json")));
+    }
+
+
+    @Test
+    @DisplayName("EEPROM write schreibt nicht an negative Adressen")
+    void eepromDoesntWriteNegative() throws IOException {
+        FileWriter writer = new FileWriter("eeprom.json");
+        writer.write("{}");
+        writer.close();
+
+        DataRegisterInterface mockDataRegister = Mockito.mock(DataRegisterInterface.class);
+        picComponents.registerComponent(DataRegisterInterface.class, mockDataRegister);
+
+        CommandInterface mockCommands = mock(CommandInterface.class);
+        picComponents.registerComponent(CommandInterface.class, mockCommands);
+
+        EEPROMInterface eeprom = new EEPROM();
+        picComponents.registerComponent(EEPROMInterface.class, eeprom);
+        picComponents.initAll();
+
+
+        eeprom.write(-1, 1);
+
+
+        assertEquals("{}", Files.readString(Path.of("eeprom.json")));
+    }
+
+
+    @Test
+    @DisplayName("EEPROM read mit negativem Wert liefert 0")
+    void eepromReadWithNegativeAddress() throws IOException {
+        FileWriter writer = new FileWriter("eeprom.json");
+        writer.write("{\"-1\":5}");
+        writer.close();
+
+        DataRegisterInterface mockDataRegister = Mockito.mock(DataRegisterInterface.class);
+        picComponents.registerComponent(DataRegisterInterface.class, mockDataRegister);
+
+        CommandInterface mockCommands = mock(CommandInterface.class);
+        picComponents.registerComponent(CommandInterface.class, mockCommands);
+
+        EEPROMInterface eeprom = new EEPROM();
+        picComponents.registerComponent(EEPROMInterface.class, eeprom);
+        picComponents.initAll();
+
+
+        long result = eeprom.read(-1);
+
+
+        assertEquals(0, result);
+    }
+}

src/test/java/fabrik/simulator/pic16f84/WatchDogTimerTests.java

@@ -0,0 +1,50 @@
+package fabrik.simulator.pic16f84;
+
+import fabrik.simulator.pic16f84.interfaces.*;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+class WatchDogTimerTests {
+    private PICComponentLocator picComponents;
+
+    @BeforeEach
+    void resetComponents() {
+        picComponents = new PICComponentLocator();
+    }
+
+    @Test
+    @DisplayName("WatchDogTimer testet ob er triggern soll, triggert korrekt nicht")
+    void watchDogIncrementWithoutTriggering() {
+        PreScalerInterface mockPreScaler = mock(PreScalerInterface.class);
+        when(
+                mockPreScaler.isPrescalerOnTimer()
+        ).thenReturn(
+                true
+        );
+        picComponents.registerComponent(PreScalerInterface.class, mockPreScaler);
+
+
+        ExecutionTimeSubject mockExecutionTime = mock(ExecutionTimeSubject.class);
+        when(
+                mockExecutionTime.getExecutionTimeMultiplier()
+        ).thenReturn(
+                1.0
+        );
+        picComponents.registerComponent(ExecutionTimeSubject.class, mockExecutionTime);
+
+        WatchdogTimerInterface watchDogTimer = new WatchdogTimer();
+        picComponents.registerComponent(WatchdogTimerInterface.class, watchDogTimer);
+        picComponents.initAll();
+
+        watchDogTimer.enable();
+        watchDogTimer.testAndTrigger();
+
+
+        assertEquals(1, watchDogTimer.get());
+    }
+}