Dateien hochladen nach „fragesimu“

.idea/misc.xml

@@ -1,10 +1,5 @@
 <?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">
@@ -13,7 +8,7 @@
       </list>
     </option>
   </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_21" default="true" project-jdk-name="19" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_19" default="true" project-jdk-name="19" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
 </project>

combined.qmd

@@ -1,28 +0,0 @@
----
-title: "Programmentwurf Advanced SoftwareEngineering"
-subtitle: Für einen [PIC16f84-Simulator (Link)](https://git.paulmartin.cloud/paul/PIC-Simu)
-author:
-    - Luca Müller
-    - Paul Martin 
-date: 05/31/2025
-date-format: "DD.MM.YYYY"
-lang: de
-format:
-    pdf:
-        toc: true
-        number-sections: true
-        colorlinks: true
-crossref:
-    custom:
-      - kind: float
-        reference-prefix: UML-Diagramm
-        key: uml
-        latex-env: uml
-        latex-list-of-description: UML-Diagramme
----
-
-\newcommand*\listofumlsde{\listof{uml}{Verzeichnis der UML-Diagramme}}
-\listofumlsde
-
-{{< include paul.qmd >}}
-{{< include luca.qmd >}}

eeprom.json

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

fragesimu/.gitignore

@@ -0,0 +1,39 @@
+target/
+!.mvn/wrapper/maven-wrapper.jar
+!**/src/main/**/target/
+!**/src/test/**/target/
+
+### IntelliJ IDEA ###
+.idea/modules.xml
+.idea/jarRepositories.xml
+.idea/compiler.xml
+.idea/libraries/
+*.iws
+*.iml
+*.ipr
+
+### Eclipse ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+build/
+!**/src/main/**/build/
+!**/src/test/**/build/
+
+### VS Code ###
+.vscode/
+
+### Mac OS ###
+.DS_Store
+/.idea/

fragesimu/mvnw

@@ -0,0 +1,316 @@
+#!/bin/sh
+# ----------------------------------------------------------------------------
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#    https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+# ----------------------------------------------------------------------------
+
+# ----------------------------------------------------------------------------
+# Maven Start Up Batch script
+#
+# Required ENV vars:
+# ------------------
+#   JAVA_HOME - location of a JDK home dir
+#
+# Optional ENV vars
+# -----------------
+#   M2_HOME - location of maven2's installed home dir
+#   MAVEN_OPTS - parameters passed to the Java VM when running Maven
+#     e.g. to debug Maven itself, use
+#       set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
+#   MAVEN_SKIP_RC - flag to disable loading of mavenrc files
+# ----------------------------------------------------------------------------
+
+if [ -z "$MAVEN_SKIP_RC" ] ; then
+
+  if [ -f /usr/local/etc/mavenrc ] ; then
+    . /usr/local/etc/mavenrc
+  fi
+
+  if [ -f /etc/mavenrc ] ; then
+    . /etc/mavenrc
+  fi
+
+  if [ -f "$HOME/.mavenrc" ] ; then
+    . "$HOME/.mavenrc"
+  fi
+
+fi
+
+# OS specific support.  $var _must_ be set to either true or false.
+cygwin=false;
+darwin=false;
+mingw=false
+case "`uname`" in
+  CYGWIN*) cygwin=true ;;
+  MINGW*) mingw=true;;
+  Darwin*) darwin=true
+    # Use /usr/libexec/java_home if available, otherwise fall back to /Library/Java/Home
+    # See https://developer.apple.com/library/mac/qa/qa1170/_index.html
+    if [ -z "$JAVA_HOME" ]; then
+      if [ -x "/usr/libexec/java_home" ]; then
+        export JAVA_HOME="`/usr/libexec/java_home`"
+      else
+        export JAVA_HOME="/Library/Java/Home"
+      fi
+    fi
+    ;;
+esac
+
+if [ -z "$JAVA_HOME" ] ; then
+  if [ -r /etc/gentoo-release ] ; then
+    JAVA_HOME=`java-config --jre-home`
+  fi
+fi
+
+if [ -z "$M2_HOME" ] ; then
+  ## resolve links - $0 may be a link to maven's home
+  PRG="$0"
+
+  # need this for relative symlinks
+  while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+      PRG="$link"
+    else
+      PRG="`dirname "$PRG"`/$link"
+    fi
+  done
+
+  saveddir=`pwd`
+
+  M2_HOME=`dirname "$PRG"`/..
+
+  # make it fully qualified
+  M2_HOME=`cd "$M2_HOME" && pwd`
+
+  cd "$saveddir"
+  # echo Using m2 at $M2_HOME
+fi
+
+# For Cygwin, ensure paths are in UNIX format before anything is touched
+if $cygwin ; then
+  [ -n "$M2_HOME" ] &&
+    M2_HOME=`cygpath --unix "$M2_HOME"`
+  [ -n "$JAVA_HOME" ] &&
+    JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
+  [ -n "$CLASSPATH" ] &&
+    CLASSPATH=`cygpath --path --unix "$CLASSPATH"`
+fi
+
+# For Mingw, ensure paths are in UNIX format before anything is touched
+if $mingw ; then
+  [ -n "$M2_HOME" ] &&
+    M2_HOME="`(cd "$M2_HOME"; pwd)`"
+  [ -n "$JAVA_HOME" ] &&
+    JAVA_HOME="`(cd "$JAVA_HOME"; pwd)`"
+fi
+
+if [ -z "$JAVA_HOME" ]; then
+  javaExecutable="`which javac`"
+  if [ -n "$javaExecutable" ] && ! [ "`expr \"$javaExecutable\" : '\([^ ]*\)'`" = "no" ]; then
+    # readlink(1) is not available as standard on Solaris 10.
+    readLink=`which readlink`
+    if [ ! `expr "$readLink" : '\([^ ]*\)'` = "no" ]; then
+      if $darwin ; then
+        javaHome="`dirname \"$javaExecutable\"`"
+        javaExecutable="`cd \"$javaHome\" && pwd -P`/javac"
+      else
+        javaExecutable="`readlink -f \"$javaExecutable\"`"
+      fi
+      javaHome="`dirname \"$javaExecutable\"`"
+      javaHome=`expr "$javaHome" : '\(.*\)/bin'`
+      JAVA_HOME="$javaHome"
+      export JAVA_HOME
+    fi
+  fi
+fi
+
+if [ -z "$JAVACMD" ] ; then
+  if [ -n "$JAVA_HOME"  ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+      # IBM's JDK on AIX uses strange locations for the executables
+      JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+      JAVACMD="$JAVA_HOME/bin/java"
+    fi
+  else
+    JAVACMD="`\\unset -f command; \\command -v java`"
+  fi
+fi
+
+if [ ! -x "$JAVACMD" ] ; then
+  echo "Error: JAVA_HOME is not defined correctly." >&2
+  echo "  We cannot execute $JAVACMD" >&2
+  exit 1
+fi
+
+if [ -z "$JAVA_HOME" ] ; then
+  echo "Warning: JAVA_HOME environment variable is not set."
+fi
+
+CLASSWORLDS_LAUNCHER=org.codehaus.plexus.classworlds.launcher.Launcher
+
+# traverses directory structure from process work directory to filesystem root
+# first directory with .mvn subdirectory is considered project base directory
+find_maven_basedir() {
+
+  if [ -z "$1" ]
+  then
+    echo "Path not specified to find_maven_basedir"
+    return 1
+  fi
+
+  basedir="$1"
+  wdir="$1"
+  while [ "$wdir" != '/' ] ; do
+    if [ -d "$wdir"/.mvn ] ; then
+      basedir=$wdir
+      break
+    fi
+    # workaround for JBEAP-8937 (on Solaris 10/Sparc)
+    if [ -d "${wdir}" ]; then
+      wdir=`cd "$wdir/.."; pwd`
+    fi
+    # end of workaround
+  done
+  echo "${basedir}"
+}
+
+# concatenates all lines of a file
+concat_lines() {
+  if [ -f "$1" ]; then
+    echo "$(tr -s '\n' ' ' < "$1")"
+  fi
+}
+
+BASE_DIR=`find_maven_basedir "$(pwd)"`
+if [ -z "$BASE_DIR" ]; then
+  exit 1;
+fi
+
+##########################################################################################
+# Extension to allow automatically downloading the maven-wrapper.jar from Maven-central
+# This allows using the maven wrapper in projects that prohibit checking in binary data.
+##########################################################################################
+if [ -r "$BASE_DIR/.mvn/wrapper/maven-wrapper.jar" ]; then
+    if [ "$MVNW_VERBOSE" = true ]; then
+      echo "Found .mvn/wrapper/maven-wrapper.jar"
+    fi
+else
+    if [ "$MVNW_VERBOSE" = true ]; then
+      echo "Couldn't find .mvn/wrapper/maven-wrapper.jar, downloading it ..."
+    fi
+    if [ -n "$MVNW_REPOURL" ]; then
+      jarUrl="$MVNW_REPOURL/org/apache/maven/wrapper/maven-wrapper/3.1.0/maven-wrapper-3.1.0.jar"
+    else
+      jarUrl="https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.1.0/maven-wrapper-3.1.0.jar"
+    fi
+    while IFS="=" read key value; do
+      case "$key" in (wrapperUrl) jarUrl="$value"; break ;;
+      esac
+    done < "$BASE_DIR/.mvn/wrapper/maven-wrapper.properties"
+    if [ "$MVNW_VERBOSE" = true ]; then
+      echo "Downloading from: $jarUrl"
+    fi
+    wrapperJarPath="$BASE_DIR/.mvn/wrapper/maven-wrapper.jar"
+    if $cygwin; then
+      wrapperJarPath=`cygpath --path --windows "$wrapperJarPath"`
+    fi
+
+    if command -v wget > /dev/null; then
+        if [ "$MVNW_VERBOSE" = true ]; then
+          echo "Found wget ... using wget"
+        fi
+        if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then
+            wget "$jarUrl" -O "$wrapperJarPath" || rm -f "$wrapperJarPath"
+        else
+            wget --http-user=$MVNW_USERNAME --http-password=$MVNW_PASSWORD "$jarUrl" -O "$wrapperJarPath" || rm -f "$wrapperJarPath"
+        fi
+    elif command -v curl > /dev/null; then
+        if [ "$MVNW_VERBOSE" = true ]; then
+          echo "Found curl ... using curl"
+        fi
+        if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then
+            curl -o "$wrapperJarPath" "$jarUrl" -f
+        else
+            curl --user $MVNW_USERNAME:$MVNW_PASSWORD -o "$wrapperJarPath" "$jarUrl" -f
+        fi
+
+    else
+        if [ "$MVNW_VERBOSE" = true ]; then
+          echo "Falling back to using Java to download"
+        fi
+        javaClass="$BASE_DIR/.mvn/wrapper/MavenWrapperDownloader.java"
+        # For Cygwin, switch paths to Windows format before running javac
+        if $cygwin; then
+          javaClass=`cygpath --path --windows "$javaClass"`
+        fi
+        if [ -e "$javaClass" ]; then
+            if [ ! -e "$BASE_DIR/.mvn/wrapper/MavenWrapperDownloader.class" ]; then
+                if [ "$MVNW_VERBOSE" = true ]; then
+                  echo " - Compiling MavenWrapperDownloader.java ..."
+                fi
+                # Compiling the Java class
+                ("$JAVA_HOME/bin/javac" "$javaClass")
+            fi
+            if [ -e "$BASE_DIR/.mvn/wrapper/MavenWrapperDownloader.class" ]; then
+                # Running the downloader
+                if [ "$MVNW_VERBOSE" = true ]; then
+                  echo " - Running MavenWrapperDownloader.java ..."
+                fi
+                ("$JAVA_HOME/bin/java" -cp .mvn/wrapper MavenWrapperDownloader "$MAVEN_PROJECTBASEDIR")
+            fi
+        fi
+    fi
+fi
+##########################################################################################
+# End of extension
+##########################################################################################
+
+export MAVEN_PROJECTBASEDIR=${MAVEN_BASEDIR:-"$BASE_DIR"}
+if [ "$MVNW_VERBOSE" = true ]; then
+  echo $MAVEN_PROJECTBASEDIR
+fi
+MAVEN_OPTS="$(concat_lines "$MAVEN_PROJECTBASEDIR/.mvn/jvm.config") $MAVEN_OPTS"
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin; then
+  [ -n "$M2_HOME" ] &&
+    M2_HOME=`cygpath --path --windows "$M2_HOME"`
+  [ -n "$JAVA_HOME" ] &&
+    JAVA_HOME=`cygpath --path --windows "$JAVA_HOME"`
+  [ -n "$CLASSPATH" ] &&
+    CLASSPATH=`cygpath --path --windows "$CLASSPATH"`
+  [ -n "$MAVEN_PROJECTBASEDIR" ] &&
+    MAVEN_PROJECTBASEDIR=`cygpath --path --windows "$MAVEN_PROJECTBASEDIR"`
+fi
+
+# Provide a "standardized" way to retrieve the CLI args that will
+# work with both Windows and non-Windows executions.
+MAVEN_CMD_LINE_ARGS="$MAVEN_CONFIG $@"
+export MAVEN_CMD_LINE_ARGS
+
+WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
+
+exec "$JAVACMD" \
+  $MAVEN_OPTS \
+  $MAVEN_DEBUG_OPTS \
+  -classpath "$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.jar" \
+  "-Dmaven.home=${M2_HOME}" \
+  "-Dmaven.multiModuleProjectDirectory=${MAVEN_PROJECTBASEDIR}" \
+  ${WRAPPER_LAUNCHER} $MAVEN_CONFIG "$@"

fragesimu/mvnw.cmd

@@ -0,0 +1,188 @@
+@REM ----------------------------------------------------------------------------
+@REM Licensed to the Apache Software Foundation (ASF) under one
+@REM or more contributor license agreements.  See the NOTICE file
+@REM distributed with this work for additional information
+@REM regarding copyright ownership.  The ASF licenses this file
+@REM to you under the Apache License, Version 2.0 (the
+@REM "License"); you may not use this file except in compliance
+@REM with the License.  You may obtain a copy of the License at
+@REM
+@REM    https://www.apache.org/licenses/LICENSE-2.0
+@REM
+@REM Unless required by applicable law or agreed to in writing,
+@REM software distributed under the License is distributed on an
+@REM "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+@REM KIND, either express or implied.  See the License for the
+@REM specific language governing permissions and limitations
+@REM under the License.
+@REM ----------------------------------------------------------------------------
+
+@REM ----------------------------------------------------------------------------
+@REM Maven Start Up Batch script
+@REM
+@REM Required ENV vars:
+@REM JAVA_HOME - location of a JDK home dir
+@REM
+@REM Optional ENV vars
+@REM M2_HOME - location of maven2's installed home dir
+@REM MAVEN_BATCH_ECHO - set to 'on' to enable the echoing of the batch commands
+@REM MAVEN_BATCH_PAUSE - set to 'on' to wait for a keystroke before ending
+@REM MAVEN_OPTS - parameters passed to the Java VM when running Maven
+@REM     e.g. to debug Maven itself, use
+@REM set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
+@REM MAVEN_SKIP_RC - flag to disable loading of mavenrc files
+@REM ----------------------------------------------------------------------------
+
+@REM Begin all REM lines with '@' in case MAVEN_BATCH_ECHO is 'on'
+@echo off
+@REM set title of command window
+title %0
+@REM enable echoing by setting MAVEN_BATCH_ECHO to 'on'
+@if "%MAVEN_BATCH_ECHO%" == "on"  echo %MAVEN_BATCH_ECHO%
+
+@REM set %HOME% to equivalent of $HOME
+if "%HOME%" == "" (set "HOME=%HOMEDRIVE%%HOMEPATH%")
+
+@REM Execute a user defined script before this one
+if not "%MAVEN_SKIP_RC%" == "" goto skipRcPre
+@REM check for pre script, once with legacy .bat ending and once with .cmd ending
+if exist "%USERPROFILE%\mavenrc_pre.bat" call "%USERPROFILE%\mavenrc_pre.bat" %*
+if exist "%USERPROFILE%\mavenrc_pre.cmd" call "%USERPROFILE%\mavenrc_pre.cmd" %*
+:skipRcPre
+
+@setlocal
+
+set ERROR_CODE=0
+
+@REM To isolate internal variables from possible post scripts, we use another setlocal
+@setlocal
+
+@REM ==== START VALIDATION ====
+if not "%JAVA_HOME%" == "" goto OkJHome
+
+echo.
+echo Error: JAVA_HOME not found in your environment. >&2
+echo Please set the JAVA_HOME variable in your environment to match the >&2
+echo location of your Java installation. >&2
+echo.
+goto error
+
+:OkJHome
+if exist "%JAVA_HOME%\bin\java.exe" goto init
+
+echo.
+echo Error: JAVA_HOME is set to an invalid directory. >&2
+echo JAVA_HOME = "%JAVA_HOME%" >&2
+echo Please set the JAVA_HOME variable in your environment to match the >&2
+echo location of your Java installation. >&2
+echo.
+goto error
+
+@REM ==== END VALIDATION ====
+
+:init
+
+@REM Find the project base dir, i.e. the directory that contains the folder ".mvn".
+@REM Fallback to current working directory if not found.
+
+set MAVEN_PROJECTBASEDIR=%MAVEN_BASEDIR%
+IF NOT "%MAVEN_PROJECTBASEDIR%"=="" goto endDetectBaseDir
+
+set EXEC_DIR=%CD%
+set WDIR=%EXEC_DIR%
+:findBaseDir
+IF EXIST "%WDIR%"\.mvn goto baseDirFound
+cd ..
+IF "%WDIR%"=="%CD%" goto baseDirNotFound
+set WDIR=%CD%
+goto findBaseDir
+
+:baseDirFound
+set MAVEN_PROJECTBASEDIR=%WDIR%
+cd "%EXEC_DIR%"
+goto endDetectBaseDir
+
+:baseDirNotFound
+set MAVEN_PROJECTBASEDIR=%EXEC_DIR%
+cd "%EXEC_DIR%"
+
+:endDetectBaseDir
+
+IF NOT EXIST "%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config" goto endReadAdditionalConfig
+
+@setlocal EnableExtensions EnableDelayedExpansion
+for /F "usebackq delims=" %%a in ("%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config") do set JVM_CONFIG_MAVEN_PROPS=!JVM_CONFIG_MAVEN_PROPS! %%a
+@endlocal & set JVM_CONFIG_MAVEN_PROPS=%JVM_CONFIG_MAVEN_PROPS%
+
+:endReadAdditionalConfig
+
+SET MAVEN_JAVA_EXE="%JAVA_HOME%\bin\java.exe"
+set WRAPPER_JAR="%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.jar"
+set WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
+
+set DOWNLOAD_URL="https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.1.0/maven-wrapper-3.1.0.jar"
+
+FOR /F "usebackq tokens=1,2 delims==" %%A IN ("%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.properties") DO (
+    IF "%%A"=="wrapperUrl" SET DOWNLOAD_URL=%%B
+)
+
+@REM Extension to allow automatically downloading the maven-wrapper.jar from Maven-central
+@REM This allows using the maven wrapper in projects that prohibit checking in binary data.
+if exist %WRAPPER_JAR% (
+    if "%MVNW_VERBOSE%" == "true" (
+        echo Found %WRAPPER_JAR%
+    )
+) else (
+    if not "%MVNW_REPOURL%" == "" (
+        SET DOWNLOAD_URL="%MVNW_REPOURL%/org/apache/maven/wrapper/maven-wrapper/3.1.0/maven-wrapper-3.1.0.jar"
+    )
+    if "%MVNW_VERBOSE%" == "true" (
+        echo Couldn't find %WRAPPER_JAR%, downloading it ...
+        echo Downloading from: %DOWNLOAD_URL%
+    )
+
+    powershell -Command "&{"^
+		"$webclient = new-object System.Net.WebClient;"^
+		"if (-not ([string]::IsNullOrEmpty('%MVNW_USERNAME%') -and [string]::IsNullOrEmpty('%MVNW_PASSWORD%'))) {"^
+		"$webclient.Credentials = new-object System.Net.NetworkCredential('%MVNW_USERNAME%', '%MVNW_PASSWORD%');"^
+		"}"^
+		"[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12; $webclient.DownloadFile('%DOWNLOAD_URL%', '%WRAPPER_JAR%')"^
+		"}"
+    if "%MVNW_VERBOSE%" == "true" (
+        echo Finished downloading %WRAPPER_JAR%
+    )
+)
+@REM End of extension
+
+@REM Provide a "standardized" way to retrieve the CLI args that will
+@REM work with both Windows and non-Windows executions.
+set MAVEN_CMD_LINE_ARGS=%*
+
+%MAVEN_JAVA_EXE% ^
+  %JVM_CONFIG_MAVEN_PROPS% ^
+  %MAVEN_OPTS% ^
+  %MAVEN_DEBUG_OPTS% ^
+  -classpath %WRAPPER_JAR% ^
+  "-Dmaven.multiModuleProjectDirectory=%MAVEN_PROJECTBASEDIR%" ^
+  %WRAPPER_LAUNCHER% %MAVEN_CONFIG% %*
+if ERRORLEVEL 1 goto error
+goto end
+
+:error
+set ERROR_CODE=1
+
+:end
+@endlocal & set ERROR_CODE=%ERROR_CODE%
+
+if not "%MAVEN_SKIP_RC%"=="" goto skipRcPost
+@REM check for post script, once with legacy .bat ending and once with .cmd ending
+if exist "%USERPROFILE%\mavenrc_post.bat" call "%USERPROFILE%\mavenrc_post.bat"
+if exist "%USERPROFILE%\mavenrc_post.cmd" call "%USERPROFILE%\mavenrc_post.cmd"
+:skipRcPost
+
+@REM pause the script if MAVEN_BATCH_PAUSE is set to 'on'
+if "%MAVEN_BATCH_PAUSE%"=="on" pause
+
+if "%MAVEN_TERMINATE_CMD%"=="on" exit %ERROR_CODE%
+
+cmd /C exit /B %ERROR_CODE%

fragesimu/pom.xml

@@ -0,0 +1,113 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>fabrik.simulator</groupId>
+    <artifactId>PIC-16f84</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <name>PIC-Simu</name>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <junit.version>5.10.0</junit.version>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.openjfx</groupId>
+            <artifactId>javafx-controls</artifactId>
+            <version>19.0.2</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openjfx</groupId>
+            <artifactId>javafx-fxml</artifactId>
+            <version>19.0.2</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openjfx</groupId>
+            <artifactId>javafx-web</artifactId>
+            <version>19.0.2</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openjfx</groupId>
+            <artifactId>javafx-swing</artifactId>
+            <version>19.0.2</version>
+        </dependency>
+        <dependency>
+            <groupId>org.controlsfx</groupId>
+            <artifactId>controlsfx</artifactId>
+            <version>11.1.2</version>
+        </dependency>
+        <dependency>
+            <groupId>org.kordamp.ikonli</groupId>
+            <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>eu.hansolo</groupId>
+            <artifactId>tilesfx</artifactId>
+            <version>11.48</version>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.openjfx</groupId>
+                    <artifactId>*</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <version>${junit.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-engine</artifactId>
+            <version>${junit.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.11.0</version>
+                <configuration>
+                    <source>19</source>
+                    <target>19</target>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.openjfx</groupId>
+                <artifactId>javafx-maven-plugin</artifactId>
+                <version>0.0.8</version>
+                <executions>
+                    <execution>
+                        <!-- Default configuration for running with: mvn clean javafx:run -->
+                        <id>default-cli</id>
+                        <configuration>
+                            <mainClass>fabrik.simulator.pic16f84/fabrik.simulator.pic16f84.CreateWindow</mainClass>
+                            <launcher>app</launcher>
+                            <jlinkZipName>app</jlinkZipName>
+                            <jlinkImageName>app</jlinkImageName>
+                            <noManPages>true</noManPages>
+                            <stripDebug>true</stripDebug>
+                            <noHeaderFiles>true</noHeaderFiles>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+</project>

luca.qmd

@@ -1,510 +0,0 @@
----
-lang: de
-format:
-    pdf:
-        toc: true
-        number-sections: true
-        colorlinks: true
-crossref:
-    custom:
-      - kind: float
-        reference-prefix: UML-Diagramm
-        key: uml
-        latex-env: uml
-        latex-list-of-description: UML-Diagramme
----
-
-# Code Smell 1: Long Method
-
-## Beschreibung des Problems
-
-Das **Long Method** Anti-Pattern tritt auf, wenn eine einzelne Methode zu viele Zeilen Code enthält und multiple Verantwortlichkeiten übernimmt. Eine solche Methode verstößt gegen das **Single Responsibility Principle (SRP)** und führt zu verschiedenen Problemen:
-
-- **Schwere Verständlichkeit**: Entwickler müssen viel Zeit aufwenden, um die gesamte Methode zu durchdringen
-- **Reduzierte Testbarkeit**: Verschiedene Logikbereiche können nicht isoliert getestet werden
-- **Mangelnde Wiederverwendbarkeit**: Teilfunktionalitäten sind nicht separat nutzbar
-- **Erhöhte Fehleranfälligkeit**: Bugs sind schwerer zu lokalisieren und zu beheben
-
-## Praktisches Beispiel
-
-Die folgende Methode `stopRunFromBackend()` zeigt ein typisches Long Method Problem:
-
-### Vorher (Problematischer Code)
-
-```java
-public static void stopRunFromBackend(String message){
-    // Zustandsänderungen
-    isAutoRunActive = false;
-    if (isSleeping)
-        wakeUpFromSleep();
-    else
-        DataRegister.resetPC();
-
-    // UI-Erstellung und -Konfiguration
-    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().add(ueberlabel);
-    vbox.getChildren().add(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();
-}
-```
-
-### Identifizierte Probleme
-
-- **Vermischte Verantwortlichkeiten**: Die Methode kombiniert Geschäftslogik (Zustandsänderungen) mit UI-Code
-- **Schwere Testbarkeit**: UI-Code kann nicht isoliert von der Geschäftslogik getestet werden
-- **Code-Duplikation**: Wird die Dialog-Funktionalität anderswo benötigt, muss der gesamte UI-Code kopiert werden
-
-## Lösung: Extract Method Refactoring
-
-Die **Extract Method** Technik löst das Problem durch Aufspaltung der langen Methode in kleinere, fokussierte Methoden:
-
-### Nachher (Refactorierter Code)
-
-```java
-public static void stopRunFromBackend(String message){
-    handleExecutionStop();
-    showInterruptionDialog(message);
-}
-
-private static void handleExecutionStop(){
-    isAutoRunActive = false;
-    if (isSleeping)
-        wakeUpFromSleep();
-    else
-        DataRegister.resetPC();
-}
-
-private static void showInterruptionDialog(String message){
-    Stage stoppedStage = new Stage();
-    stoppedStage.setTitle("Programm unterbrochen!");
-
-    VBox vbox = new VBox();
-    vbox.setAlignment(javafx.geometry.Pos.CENTER);
-
-    Label ueberlabel = new Label("Programm unterbrochen!");
-    Label grundlabel = new Label("Grund: " + message);
-    grundlabel.setStyle("-fx-font-size: 16px; -fx-font-weight: bold;");
-
-    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();
-}
-```
-
-## Vorteile der Lösung
-
-- **Klare Trennung der Verantwortlichkeiten**: Geschäftslogik und UI-Code sind getrennt
-- **Verbesserte Lesbarkeit**: Jede Methode hat einen klaren, fokussierten Zweck
-- **Erhöhte Wiederverwendbarkeit**: `showInterruptionDialog()` kann in anderen Kontexten genutzt werden
-- **Bessere Testbarkeit**: Geschäftslogik und UI können separat getestet werden
-
-
-# Code Smell 2: Large Class
-
-## Beschreibung des Problems
-
-Eine **Large Class** entsteht, wenn eine Klasse zu viele Verantwortlichkeiten übernimmt und dadurch überladen wird. Typische Kennzeichen sind:
-
-- **Hohe Anzahl an Instanzvariablen**: Die Klasse verwaltet zu viele verschiedene Datentypen
-- **Viele Methoden**: Unterschiedliche Funktionsbereiche werden in einer Klasse gemischt
-- **Multiple Domänenaspekte**: Logik, Darstellung, Benutzerinteraktion und Statusverwaltung in einer Klasse
-
-## Praktisches Beispiel
-
-Die Klasse `Controller_Frontend` zeigt typische Large Class Probleme:
-
-### Identifizierte Probleme
-
-```java
-public class Controller_Frontend {
-    // GUI-Elemente
-    @FXML private Button startButton;
-    @FXML private Button pauseButton;
-    @FXML private Label statusLabel;
-
-    // Zustandsverwaltung (gehört nicht hierher!)
-    private static boolean isAutoRunActive = false;
-    private static boolean isSleeping = false;
-    private static double executionTimeMultiplier = 1.0;
-
-    // GUI-Steuerung
-    public void handleStart() { /* ... */ }
-    public void handlePause() { /* ... */ }
-
-    // Zustandslogik (gehört nicht hierher!)
-    public void sleep() { isSleeping = true; }
-    public void wakeUpFromSleep() { isSleeping = false; }
-
-    // ... viele weitere Methoden
-}
-```
-
-### Auswirkungen
-
-- **Schwere Wartbarkeit**: Änderungen in einem Bereich können unbeabsichtigte Nebeneffekte verursachen
-- **Reduzierte Testbarkeit**: Verschiedene Aspekte können nicht isoliert getestet werden
-- **Unübersichtlichkeit**: Die Klasse wird schnell unhandlich und schwer verständlich
-- **Violierung des Single Responsibility Principle**: Eine Klasse sollte nur einen Grund zur Änderung haben
-
-## Lösung: Extract Class Refactoring
-
-Die Lösung besteht in der Auslagerung der Zustandsverwaltung in eine separate, spezialisierte Klasse:
-
-### Neue ExecutionState Klasse
-
-```java
-/**
- * Zentrale Verwaltung aller Ausführungszustände.
- * Diese Klasse kapselt alle zustandsbezogenen Operationen
- * und bietet eine saubere API für den Zugriff darauf.
- */
-public class ExecutionState {
-    private static boolean isAutoRunActive = false;
-    private static boolean isSleeping = false;
-    private static double executionTimeMultiplier = 1.0;
-
-    // AutoRun-Zustand
-    public static boolean isAutoRunActive() {
-        return isAutoRunActive;
-    }
-
-    public static void setAutoRunActive(boolean active) {
-        isAutoRunActive = active;
-    }
-
-    // Sleep-Zustand
-    public static boolean isSleeping() {
-        return isSleeping;
-    }
-
-    public static void sleep() {
-        isSleeping = true;
-    }
-
-    public static void wakeUp() {
-        isSleeping = false;
-    }
-
-    // Ausführungsgeschwindigkeit
-    public static double getExecutionTimeMultiplier() {
-        return executionTimeMultiplier;
-    }
-
-    public static void setExecutionTimeMultiplier(double multiplier) {
-        if (multiplier > 0) {
-            executionTimeMultiplier = multiplier;
-        }
-    }
-
-    // Hilfsmethoden
-    public static void reset() {
-        isAutoRunActive = false;
-        isSleeping = false;
-        executionTimeMultiplier = 1.0;
-    }
-}
-```
-
-### Refactorierte Controller Klasse
-
-```java
-public class Controller_Frontend {
-    // Nur noch GUI-Elemente
-    @FXML private Button startButton;
-    @FXML private Button pauseButton;
-    @FXML private Label statusLabel;
-
-    // Verwendung der ExecutionState Klasse
-    public void stopRunFromBackend(String message) {
-        ExecutionState.setAutoRunActive(false);
-
-        if (ExecutionState.isSleeping()) {
-            ExecutionState.wakeUp();
-        } else {
-            DataRegister.resetPC();
-        }
-
-        showInterruptionDialog(message);
-    }
-
-    // Weitere GUI-Methoden...
-}
-```
-
-## Vorteile der Lösung
-
-- **Klare Verantwortlichkeiten**: Controller fokussiert sich auf GUI, ExecutionState auf Zustandsverwaltung
-- **Verbesserte Testbarkeit**: Zustandslogik kann isoliert getestet werden
-- **Erhöhte Wiederverwendbarkeit**: ExecutionState kann in anderen Klassen genutzt werden
-- **Bessere Wartbarkeit**: Änderungen an der Zustandslogik betreffen nur eine Klasse
-
-
-# Code Smell 3: Shotgun Surgery
-
-## Beschreibung des Problems
-
-**Shotgun Surgery** tritt auf, wenn eine kleine fachliche Änderung Modifikationen an vielen verschiedenen Stellen im Code erfordert. Dieses Anti-Pattern entsteht durch:
-
-- **Zu starke Verteilung**: Zusammengehörige Funktionalität ist über viele Klassen und Methoden verstreut
-- **Mangelnde Kapselung**: Ähnliche Operationen sind nicht zentral gebündelt
-- **Duplizierte Logik**: Gleiche oder ähnliche Code-Fragmente existieren an mehreren Stellen
-
-## Praktisches Beispiel
-
-Die Schlafmodus-Funktionalität war ursprünglich über mehrere Bereiche verteilt:
-
-### Vor dem Refactoring (Problematische Verteilung)
-
-```java
-// In Controller_Frontend
-private boolean isSleeping = false;
-
-public void enterSleepMode() {
-    isSleeping = true;
-    // Logging hier
-    System.out.println("Entering sleep mode");
-}
-
-// In ExecutionEngine
-private boolean sleepState = false;
-
-public void pauseExecution() {
-    sleepState = true;
-    // Ähnliches Logging dort
-    System.out.println("Execution paused - sleep mode");
-}
-
-// In StatusManager
-public void checkSleepStatus() {
-    if (someCondition) {
-        // Wieder ähnlicher Code
-        setSleeping(true);
-        System.out.println("Sleep mode activated");
-    }
-}
-```
-
-### Identifizierte Probleme
-
-- **Mehrfache Implementierung**: Sleep-Logik existiert in verschiedenen Varianten
-- **Inkonsistente Zustände**: Verschiedene Klassen können unterschiedliche Sleep-Zustände haben
-- **Hoher Änderungsaufwand**: Neue Sleep-Features müssen an mehreren Stellen implementiert werden
-- **Fehleranfälligkeit**: Beim Hinzufügen neuer Funktionen können leicht Stellen vergessen werden
-
-## Lösung: Zentralisierung durch Extract Class
-
-Die Lösung besteht in der Konsolidierung aller sleep-bezogenen Operationen in der `ExecutionState` Klasse:
-
-### Zentralisierte Lösung
-
-```java
-public class ExecutionState {
-    private static boolean isSleeping = false;
-    private static final Logger logger = LoggerFactory.getLogger(ExecutionState.class);
-
-    /**
-     * Aktiviert den Schlafmodus mit einheitlichem Logging und Zustandsmanagement
-     */
-    public static void sleep() {
-        if (!isSleeping) {
-            isSleeping = true;
-            logger.info("Sleep mode activated");
-            notifyStateChange("SLEEP_ACTIVATED");
-        }
-    }
-
-    /**
-     * Deaktiviert den Schlafmodus
-     */
-    public static void wakeUp() {
-        if (isSleeping) {
-            isSleeping = false;
-            logger.info("Waking up from sleep mode");
-            notifyStateChange("SLEEP_DEACTIVATED");
-        }
-    }
-
-    /**
-     * Überprüft den aktuellen Schlafzustand
-     */
-    public static boolean isSleeping() {
-        return isSleeping;
-    }
-
-    /**
-     * Erweiterte Sleep-Funktionalität mit Timeout
-     */
-    public static void sleepWithTimeout(long milliseconds) {
-        sleep();
-        Timer timer = new Timer();
-        timer.schedule(new TimerTask() {
-            @Override
-            public void run() {
-                wakeUp();
-            }
-        }, milliseconds);
-    }
-
-    private static void notifyStateChange(String event) {
-        // Zentrale Benachrichtigung für alle interessierten Komponenten
-        EventBus.getInstance().publish(new StateChangeEvent(event));
-    }
-}
-```
-
-### Vereinfachte Nutzung in anderen Klassen
-
-```java
-// In Controller_Frontend
-public void handleSleepButton() {
-    ExecutionState.sleep();
-    updateUI();
-}
-
-// In ExecutionEngine
-public void pauseIfNeeded() {
-    if (shouldPause()) {
-        ExecutionState.sleep();
-    }
-}
-
-// In StatusManager
-public void checkAndActivateSleep() {
-    if (criticalCondition()) {
-        ExecutionState.sleepWithTimeout(5000); // 5 Sekunden Sleep
-    }
-}
-```
-
-## Vorteile der Lösung
-
-- **Einheitliche Implementierung**: Alle sleep-bezogenen Operationen verwenden dieselbe Logik
-- **Zentrale Wartung**: Änderungen müssen nur an einer Stelle vorgenommen werden
-- **Konsistente Zustände**: Nur eine Quelle der Wahrheit für den Sleep-Zustand
-- **Erweiterte Funktionalität**: Neue Features (wie Timeout) können zentral hinzugefügt werden
-- **Bessere Nachverfolgbarkeit**: Einheitliches Logging und Event-System
-
-# Anwendung von Programmierprinzipien im Projekt
-
-## Einleitung
-Im Rahmen der Refaktorisierung und Weiterentwicklung des Projekts wurde besonderer Fokus auf die Einhaltung zentraler Programmierprinzipien gelegt. Die folgenden Prinzipien wurden gezielt analysiert und angewendet:
-
-## 1. SOLID-Prinzipien
-
-### Single Responsibility Principle (SRP)
-Die Methode `stopRunFromBackend()` wurde in zwei unabhängige Methoden aufgeteilt:
-
-```java
-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) {
-    // GUI-Erzeugung...
-}
-```
-
-### Open/Closed Principle (OCP)
-Die Klasse `ExecutionState` kapselt erweiterbare Zustandslogik, ohne dass bestehende Methoden geändert werden müssen:
-
-```java
-public class ExecutionState {
-    private static boolean isAutoRunActive;
-    private static boolean isSleeping;
-
-    public static boolean isSleeping() { return isSleeping; }
-    public static void wakeUp() { isSleeping = false; }
-    public static void setAutoRunActive(boolean value) {
-        isAutoRunActive = value;
-    }
-}
-```
-
-### Liskov Substitution Principle (LSP)
-`Controller_Frontend` implementiert ein Interface, wodurch die Substituierbarkeit gemäß LSP gewährleistet ist:
-
-```java
-public class Controller_Frontend extends PICComponent implements FrontendControllerInterface { }
-
-public void resetPC() {
-    programCounter = 0;
-}
-```
-
-### Interface Segregation Principle (ISP)
-Spezialisierte Interfaces sorgen dafür, dass Klassen nur relevante Funktionen implementieren:
-
-```java
-public interface TimerInterface {
-    void start();
-    void stop();
-    int getCurrentTime();
-}
-```
-
-### Dependency Inversion Principle (DIP)
-Zentrale Komponenten wie `PICComponentLocator` und Interfaces lösen die Abhängigkeit von konkreten Klassen:
-
-```java
-private PICComponentLocator picComponents;
-```
-
-## 2. GRASP-Prinzipien
-
-### Low Coupling
-Die Kopplung im Projekt ist durch Verwendung zentraler Zugriffsklassen wie `PICComponentLocator` gering gehalten.
-
-```java
-private PICComponentLocator picComponents;
-```
-
-### High Cohesion
-Funktionen übernehmen jeweils thematisch zusammenhängende Aufgaben:
-
-```java
-public static void showStopDialog(String message) {
-    Stage stoppedStage = new Stage();
-    VBox vbox = new VBox();
-    Label grundlabel = new Label("Grund: " + message);
-    // GUI-Details ausgelassen
-    stoppedStage.show();
-}
-```
-
-## 3. DRY – Don’t Repeat Yourself
-Wiederverwendbare Logik zur Statuskontrolle wurde in `ExecutionState` gekapselt. GUI-Erzeugung findet zentral in `showStopDialog()` statt:
-
-```java
-public class ExecutionState {
-    private static boolean isSleeping;
-    public static boolean isSleeping() { return isSleeping; }
-    public static void wakeUp() { isSleeping = false; }
-}
-
-private static void showStopDialog(String message) {
-    // einmal zentral definierte GUI-Logik
-}

paul.qmd

@@ -1,123 +0,0 @@
----
-lang: de
-format:
-    pdf:
-        toc: true
-        number-sections: true
-        colorlinks: true
-crossref:
-    custom:
-      - kind: float
-        reference-prefix: UML-Diagramm
-        key: uml
-        latex-env: uml
-        latex-list-of-description: UML-Diagramme
----
-
-{{< pagebreak >}}
-
-# Entwurfsmuster
-Zusätzlich zu den beiden im Folgenden dargestellten Entwursmustern benutzen wir einen [Service Locator](https://en.wikipedia.org/wiki/Service_locator_pattern), der zu den [Architectural Patterns](https://en.wikipedia.org/wiki/Architectural_pattern) zählt. Dieses Pattern nutzt ein `HashMap`, in der verschiedene Komponenten des Programms gespeichert werden, um das Komponenten-Management zu vereinfachen und explizite Abhängigkeiten der Komponenten untereinander zu vermeiden, die das Initialisieren der einzelnen Komponenten erschweren könnten. 
-In unserem Projekt fungiert [`PICComponentLocator`] als dieser Locator. Er besitzt einen `componentCatalogue` als Member, der eine `Map<Class<? extends PICComponentInterface>, PICComponentInterface>` ist. Das bedeutet, dass alle Klassen, die durch den Locator gemanaget werden sollen, das `PICComponentInterface` implementieren müssen. Dieses ist wie folgt [definiert]: 
-```java
-public interface PICComponentInterface {
-    void initialize(PICComponentLocator picComponents);
-}
-```
-Um nicht bei allen Zugriffen die `PICComponentLocator.getComponent()` ausführen zu müssen, wurde zusätzlich die `abstract` Klasse `PICComponent` [eingeführt]. Sie besitzt als Member alle implementierten Komponenten, also sollten neue Komponenten ebenfalls das Interface implementieren und als Member in `PICComponent` angelegt werden. Alle Komponenten können diese Klasse `extend`en und dadurch auch alle weiteren Komponenten als Member haben. Durch die `initialize`-Funktion des `PICComponent` werden durch einen Aufruf der `PICComponentLocator.initAll()` alle Member vom Locator geholt. 
-
-## Marker-Entwurfsmuster
-[Marker-Patterns](https://en.wikipedia.org/wiki/Marker_interface_pattern) werden allgemein genutzt, um Klassen Metadaten zuzuordnen. In unserem Projekt stellen die `FrontendSpecific`-Interfaces Marker dar, die genutzt werden um zu kommunizieren, dass Klassen andere Klassen benötigen, die Frontend-spezifisch sind und somit besonders beachtet werden müssen. So können alle [`Interface`s](LINK ZU ORDNER) definiert werden ohne direkt von fremdem Code abhängig zu sein. Bei möglichen anderen Frontend-Implementierungen müssten entsprechend nur die passenden Klassen die jeweiligen Interfaces implementieren und nichts an den Interfaces ändern.
-Eingeführt wurden die `FrontendSpecific`s in [Commit 06e9348016](https://git.paulmartin.cloud/paul/PIC-Simu/commit/06e934801645e32dea5415ccb4f38368a1667df6) ([hier](https://git.paulmartin.cloud/paul/PIC-Simu/commit/ef3b0fce5f9b6cce06494ff6ce59f5534064e7d2) verfollständigt). Es wurde zunächst ein `FrontendSpecificObject`-Interface angelegt, das alle Frontend-spezifischen Klassen beschreibt, die von Methoden anderer Klassen genutzt werden (sprich, die in den  [`Interface`s](LINK ZU ORDNER) vorkommen). Es ist - entsprechend des Marker-Patterns - komplett leer [definiert](src/main/java/fabrik/simulator/pic16f84/frontendspecifics/FrontendSpecificObject.java):
-```java
-public interface FrontendSpecificObject { 
-}
-```
-Zusätzlich gibt es für spezifische Frontend-Klassen auch `FrontendSpecific`-Interfaces, sodass nach wie vor nur bestimmte Klassen über- bzw. zurückgegeben werden können. Diese spezifischen Interfaces sind ebenfalls leer, nur nutzen sie `extends FrontendSpecificObject` um zu verdeutlichen, dass sie zu den allgemeinen `FrontendSpecificObject`s gehören. Hier beispielsweise [`FrontendSpecificCircle`](src/main/java/fabrik/simulator/pic16f84/frontendspecifics/FrontendSpecificCircle.java):
-```java
-public interface FrontendSpecificCircle extends FrontendSpecificObject {
-}
-```
-Tatsächlich genutzt werden die `FrontendSpecific`-Interfaces von [Circle], [ToggleButtonGroup] und [Vbox]. Sie `extenden` ihr jeweiliges `JavaFX`-Pendant und `implementen` ihr jeweiliges `FrontendSpecific`-Interface. Darüber hinaus implementieren sie nur die nötigen (also im Code tatsächlich genutzten) Konstruktoren, die wiederum nur `super()` aufrufen, hier bspw. [`ToggleButtonGroup`]:
-```java
-public class ToggleButtonGroup extends 
-              com.gluonhq.charm.glisten.control.ToggleButtonGroup 
-                implements FrontendSpecificToggleButtonGroup {
-    public ToggleButtonGroup(){
-        super();
-    }
-
-    public ToggleButtonGroup(ToggleButton... toggles) {
-        super(toggles);
-    }    
-}
-```
-Alle für das Marker-Pattern eingeführten Klassen sind in @uml-marker erkennbar:
-
-::: {#uml-marker}
-
-```{mermaid}
-%%| fig-width: 6.5
-classDiagram
-direction TB
-class FrontendSpecificObject {
-    <<interface>>
-}
-class FrontendSpecificToggleButtonGroup {
-    <<interface>>
-}
-class ToggleButtonGroup {
-    public ToggleButtonGroup()
-    public ToggleButtonGroup(ToggleButton... toggles)
-}
-
-class `com.gluonhq.charm.glisten.control.ToggleButtonGroup` {
-    ...
-    ....()
-}
-
-FrontendSpecificObject <|-- FrontendSpecificToggleButtonGroup : << extends >>
-FrontendSpecificToggleButtonGroup <|-- ToggleButtonGroup : << implements >>
-`com.gluonhq.charm.glisten.control.ToggleButtonGroup` <|-- ToggleButtonGroup : << extends >>
-
-class FrontendSpecificVBox{
-    <<interface>>
-}
-class VBox {
-    public VBox()
-}
-
-class `javafx.scene.layout.VBox` {
-    ...
-    ....()
-}
-
-FrontendSpecificObject <|-- FrontendSpecificVBox : << extends >>
-FrontendSpecificVBox <|-- VBox : << implements >>
-`javafx.scene.layout.VBox` <|-- VBox : << extends >>
-
-class FrontendSpecificCircle {
-    <<interface>>
-}
-class Circle {
-    public Circle()
-}
-
-class `javafx.scene.shape.Circle` {
-    ...
-    ....()
-}
-
-
-FrontendSpecificObject <|-- FrontendSpecificCircle : << extends >>
-FrontendSpecificCircle <|-- Circle : << implements >>
-`javafx.scene.shape.Circle` <|-- Circle : << extends >>
-
-
-```
-
-Das genutzte Marker-Pattern und alle seine Verwendungen
-:::
-## Beobachter- (/Observer-) Entwurfsmuster
-[Beobachter-Entwurfsmuster](https://en.wikipedia.org/wiki/Observer_pattern) werden genutzt, damit ein Subjekt mehrere Beobachter über eine Zustandsänderung informieren kann. In unserem Projekt passiert das bei einer Änderung der `totalExecutionTime`. Das Subjekt `ExecutionTimeSubject` führt hierbei ein `Set` an Beobachtern, die bei uns durch das Interface `ExecutionTimeObserver` repräsentiert werden, welches durch die `registerObserver`- und `unregisterObserver`-Funktionen verwaltet werden kann. Bei einer Zustandsänderung muss die `notifyObservers`-Funktion aufgerufen werden, welche für alle Observer die im Interface spezifizierte `executionTimeChanged`-Funktion aufruft. 
-

pom.xml

@@ -45,18 +45,6 @@
             <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>
@@ -80,13 +68,6 @@
             <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>
@@ -120,24 +101,6 @@
                     </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,39 +1,13 @@
 package fabrik.simulator.pic16f84;
 
-import fabrik.simulator.pic16f84.interfaces.*;
+public class Commands {
+    private static int wRegister = 0;
 
-public class Commands extends ExecutionTimeSubject implements CommandInterface {
+    public static int get_wRegister() {
-    private int wRegister;
-    private long totalExecutionTime;
-    private double executionTimeMultiplier = 1;
-
-    public Commands(){
-        super();
-        wRegister = 0;
-        totalExecutionTime = 0;
-    }
-
-    public int get_wRegister() {
         return wRegister;
     }
 
-    public void addExecutionTime(int i) {
+    public static void decode(int instruction){
-        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;
@@ -50,12 +24,10 @@ public class Commands extends ExecutionTimeSubject implements CommandInterface {
             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;
@@ -64,33 +36,27 @@ public class Commands extends ExecutionTimeSubject implements CommandInterface {
         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;
@@ -100,12 +66,10 @@ public class Commands extends ExecutionTimeSubject implements CommandInterface {
             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;
@@ -115,88 +79,70 @@ public class Commands extends ExecutionTimeSubject implements CommandInterface {
             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;
@@ -206,17 +152,14 @@ public class Commands extends ExecutionTimeSubject implements CommandInterface {
             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;
@@ -225,369 +168,298 @@ public class Commands extends ExecutionTimeSubject implements CommandInterface {
         switch (instruction){
             case 0b01100100:
                 System.out.println("CLRWDT");
-                watchdogTimer.reset();
+                //TODO
                 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");
-                SLEEP();
+                //TODO
-                addExecutionTime(1);
                 return;
             default:
                 break;
         }
 
         if (instruction == 0 || instruction == 0b0110000 || instruction == 0b01000000 || instruction == 0b00100000){
-            NOP ();
+            System.out.println("NOP");
         }
         else{
             System.out.println("Nicht gefunden!");
         }
+
+
     }
 
-    public void SLEEP() {
+    public static void RETFIE() {
-        ExecutionState.sleep();
+        DataRegister.setPC(ProgramStack.pop());
     }
 
-    public void RETFIE() {
+    public static void GOTO(int jump) {
-        dataRegister.setBit(dataRegister.getINTCON(), 7); // GIE wieder setzen
+        DataRegister.setPC(jump-1);
-        dataRegister.setPC(programStack.pop());
     }
 
-    public void NOP () {
+    public static void CALL(int jump) {
-        System.out.println("NOP");
+        ProgramStack.push(DataRegister.getPC()+1);
-        addExecutionTime(1);
+        DataRegister.setPC(jump-1);
     }
 
-    public void GOTO(int jump) {
+    public static void MOVWF(int file) {
-        dataRegister.setPC(jump-1);
+        DataRegister.setRegister(file, wRegister);
     }
 
-    public void CALL(int jump) {
+    public static void CLRW() {
-        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 void CLRF(int file) {
+    public static void CLRF(int file) {
-        dataRegister.setRegister(file, 0);
+        DataRegister.setRegister(file, 0);
-        dataRegister.determineZeroFlag(dataRegister.getRegister(file));
+        DataRegister.determineZeroFlag(DataRegister.getRegister(file));
-
-
     }
 
-    public void IORLW(int literal) {
+    public static void IORLW(int literal) {
         wRegister |= literal;
-        dataRegister.determineZeroFlag(wRegister);
+        DataRegister.determineZeroFlag(wRegister);
     }
 
-    public void XORLW(int literal) {
+    public static void XORLW(int literal) {
         wRegister ^= literal;
-        dataRegister.determineZeroFlag(wRegister);
+        DataRegister.determineZeroFlag(wRegister);
     }
 
-    public void ANDLW(int literal) {
+    public static void ANDLW(int literal) {
         wRegister &= literal;
-        dataRegister.determineZeroFlag(wRegister);
+        DataRegister.determineZeroFlag(wRegister);
     }
 
-    public void XORWF(int file, int destination) {
+    public static 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 void SWAPF(int file, int destination) {
+    public static 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 void SUBWF(int file, int destination) {
+    public static void SUBWF(int file, int destination) {
-        int result = (dataRegister.getRegister(file) - wRegister) ;
+        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 void RLF(int file, int destination) {
+    public static 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 void RRF(int file, int destination) {
+    public static void RRF(int file, int destination) {
-        int fcontent = dataRegister.getRegister(file);
+        int fcontent = DataRegister.getRegister(file);
-        int carry = dataRegister.getCarryFlag() << 7;
+        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 void MOVF(int file, int destination) {
+    public static void MOVF(int file, int destination) {
-        int content = dataRegister.getRegister(file);
+        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 void IORWF(int file, int destination) {
+    public static 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 void INCFSZ(int file, int destination) {
+    public static 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 void INCF(int file, int destination) {
+    public static 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 void DECFSZ(int file, int destination) {
+    public static 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 void DECF(int file, int destination) {
+    public static 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 void COMF(int file, int destination) {
+    private static 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 void ANDWF(int file, int destination) {
+    public static 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((wRegister&0b11101111) & (dataRegister.getRegister(file)&0b1111));
+        DataRegister.determineDigitCarryFlag(result);
-
     }
 
-    public void ADDWF(int file, int destination) {
+    public static 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((wRegister&0b11101111) + (dataRegister.getRegister(file)&0b1111));
+            DataRegister.determineDigitCarryFlag(result);
         }
         if (destination == 0) {
             wRegister = result & 0xFF;
         }
         else {
-            dataRegister.setRegister(file, result & 0xFF);
+            DataRegister.setRegister(file, result & 0xFF);
         }
-        dataRegister.determineZeroFlag(result);
+        DataRegister.determineZeroFlag(result);
-
-
     }
 
-    public void SUBLW(int literal) {
+    public static 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 void ADDLW(int literal) {
+    public static 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((wRegister&0b11101111) + (literal&0b1111));
+        DataRegister.determineDigitCarryFlag(result);
     }
 
-    public void RETLW(int literal) {
+    public static void RETLW(int literal) {
         wRegister = literal;
-        dataRegister.setPC(programStack.pop());
+        DataRegister.setPC(ProgramStack.pop());
     }
 
-    public void MOVLW(int literal) {
+    public static void MOVLW(int literal) {
         wRegister = literal;
     }
 
-    public void BTFSC(int address, int bit) {
+    public static 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 void BTFSS(int address, int bit) {
+    public static 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

@@ -0,0 +1,58 @@
+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("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

@@ -1,579 +0,0 @@
-package fabrik.simulator.pic16f84;
-
-
-import fabrik.simulator.pic16f84.frontendspecifics.Circle;
-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.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

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

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

@@ -1,75 +1,23 @@
 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 primaryStage) throws IOException {
+    public void start(Stage stage) throws IOException {
-        picComponents.registerComponent(ToggleButtonInterface.class, new ToggleButtonGroupExt());
+        FXMLLoader fxmlLoader = new FXMLLoader(CreateWindow.class.getResource("FileSelector.fxml"));
-        picComponents.registerComponent(IOPortInterface.class, new IOPorts());
+        Scene scene = new Scene(fxmlLoader.load(), 1200, 800);
-        picComponents.registerComponent(TableInterface.class, new Table());
+        stage.setTitle("PIC16F84-Simulator － Datei auswählen");
-        picComponents.registerComponent(FrontendControllerInterface.class, new Controller_Frontend());
+        stage.setScene(scene);
-        picComponents.initAll();
+        stage.show();
-
-        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(args);
+        launch();
     }
-
+}
-    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,74 +1,43 @@
 package fabrik.simulator.pic16f84;
 
-import fabrik.simulator.pic16f84.interfaces.DataRegisterInterface;
-
 import java.util.Arrays;
 
-public class DataRegister extends PICComponent implements DataRegisterInterface {
+public class DataRegister {
-    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 PCLATH = 0xA;
-    private final int PORTA = 0x5;
+    private static final int INTCON = 0xB;
-    private final int PORTB = 0x6;
-    private final int PCLATH = 0xA;
-    private final int INTCON = 0xB;
 
-    private final int EEDATA = 0x08;
+    private static final int TRISA = 0x85;
-    private final int EEADR = 0x09;
+    private static final int TRISB = 0x86;
-    private final int EECON1 = 0x88;
-    private final int EECON2 = 0x89;
 
-    private final int TRISA = 0x85;
+    private static final int C = 0x0;
-    private final int TRISB = 0x86;
+    private static final int DC = 0x1;
-
+    private static final int Z = 0x2;
-    private final int C = 0x0;
+    private static final int RP0 = 0x5;
-    private final int DC = 0x1;
-    private final int Z = 0x2;
-    private final int RP0 = 0x5;
 
 
-    private final int [] dataRegister =  new int[0xFF];
+    private static final int [] dataRegister =  new int[0xFF];
-    private final int [] syncedRegisters = {INDF, PCL, STATUS, FSR, PCLATH, INTCON};
+    private static final int [] syncedRegisters = {PCL, STATUS, FSR, PCLATH, INTCON};
-    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] = 0b11111111;
+        dataRegister[TRISA] = 0b11111000;
         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));
     }
 
-    public void initDataRegister() {
+    private static boolean isSyncedRegister (int address){
-        initOrReset();
-    }
-
-    private boolean isSyncedRegister (int address){
         for (int register : syncedRegisters){
             if (address == register || address == 0x80 + register){
                 return true;
@@ -77,80 +46,36 @@ public class DataRegister extends PICComponent implements DataRegisterInterface
         return false;
     }
 
-    public int[] getDataRegister() {
+    public static int[] getDataRegister() {
         return dataRegister;
     }
 
-    private int determineIndirectAndChange (int address){
+    private static int bank() {
-        if (address == INDF || address == 0x80 + INDF) {
-            return dataRegister[FSR];
-        }
-        else
-            return address;
-    }
-
-    public int getFSR (){
-        return dataRegister[FSR];
-    }
-
-    private int bank() {
         return ((dataRegister[STATUS] >> RP0) & 1) * 0x80;
     }
 
-    public int getRegister(int fileAddress){
+    public static int getRegister(int fileAddress){
-        int address = determineIndirectAndChange (fileAddress);
+        return dataRegister[bank() + fileAddress];
-        if (bank () + address == EECON2)
-            return 0;
-        return dataRegister[bank() + address];
     }
 
-    public void setRegister(int fileAddress, int content){
+    public static void setRegister(int fileAddress, int content){
-        int address = determineIndirectAndChange (fileAddress);
+        if (!isSyncedRegister(fileAddress))
-        if (Arrays.stream(ioRegisters).anyMatch(i -> i == address)){
+            dataRegister[bank() + fileAddress] = 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){
-            programCounter = content + (dataRegister[PCLATH] << 8);
-        }
-        if (!isSyncedRegister(address))
-            dataRegister[bank() + address] = content;
         else {
-            dataRegister[address] = content;
+            dataRegister[fileAddress] = content;
-            dataRegister[0x80 + address] = content;
+            dataRegister[0x80 + fileAddress] = content;
-            if (address == STATUS){
-                setFlags();
-            }
         }
-        if (address == 1)
-            preScaler.resetFromRegister();
     }
 
-    public int getBit(int fileAddress, int bit) {
+    public static int getBit(int address, int bit) {
-        int address = determineIndirectAndChange (fileAddress);
-        if (bank() + address == EECON2)
-            return 0;
         return (dataRegister[bank() + address] >> bit) & 1;
     }
 
-    public int getDirectBit(int address, int bit){
+    private static int getDirectBit(int address, int bit){
         return (dataRegister[address] >> bit) & 1;
     }
 
-    public void clearBit(int fileAddress, int bit) {
+    public static void clearBit(int address, int bit) {
-        int address = determineIndirectAndChange (fileAddress);
-        if (Arrays.stream(ioRegisters).anyMatch(i -> i == address)){
-            ioPorts.clearBit(bank() + address, bit);
-            return;
-        }
-        if (Arrays.stream(eepromRegisters).anyMatch(i -> i == address)){
-            eeprom.parse(bank () + address, bit, 0b00);
-            return;
-        }
         if (!isSyncedRegister(address)) {
             if (getBit(address, bit) == 1) {
                 dataRegister[bank() + address] -= (int) Math.pow(2, bit);
@@ -160,25 +85,11 @@ public class DataRegister extends PICComponent implements DataRegisterInterface
             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 void setBit(int fileAddress, int bit) {
+    public static void setBit(int address, int bit) {
-        int address = determineIndirectAndChange (fileAddress);
-        if (Arrays.stream(ioRegisters).anyMatch(i -> i == address)){
-            ioPorts.setBit(bank() + address, bit);
-            return;
-        }
-        if (Arrays.stream(eepromRegisters).anyMatch(i -> i == address)){
-            eeprom.parse(bank () + address, bit, 0b10);
-            return;
-        }
         if (!isSyncedRegister(address)) {
             if (getBit(address, bit) == 0) {
                 dataRegister[bank() + address] += (int) Math.pow(2, bit);
@@ -188,31 +99,19 @@ public class DataRegister extends PICComponent implements DataRegisterInterface
             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){
+    private static int programCounter = 0;
-        if (getDirectBit(fileAddress, bit) == 0 && value == 1){
+
-            dataRegister[fileAddress] += (int) Math.pow(2, bit);
+    private static void writeToPCL(){
-        } else if (getDirectBit(fileAddress, bit) == 1 && value == 0){
+        dataRegister[PCL] = programCounter;
-            dataRegister[fileAddress] -= (int) Math.pow(2, bit);
+        dataRegister[0x82] = dataRegister[PCL];
-        }
     }
 
-    private int programCounter = 0;
+    public static void increasePC (){
-
+        programCounter = getRegister(PCL);
-    private void writeToPCL(){
-        dataRegister[PCL] = programCounter & 0xFF;
-        dataRegister[0x80 + PCL] = dataRegister[PCL];
-    }
-
-    public void increasePC (){
         if (programCounter != 0x3FF) {
             programCounter++;
         }
@@ -222,28 +121,18 @@ public class DataRegister extends PICComponent implements DataRegisterInterface
         writeToPCL();
     }
 
-    public void setPC (int value){
+    public static void setPC (int value){
-        programCounter = value + ((getRegister(PCLATH) & 0b11000) << 8);
+        programCounter = value;
         writeToPCL();
     }
 
-    public void resetPC () {
+    public static int getPC(){
-        programCounter = 0;
-    }
-
-    public int getPC(){
         return programCounter;
     }
 
-    private void setFlags() {
+    private static int zeroFlag = 0;
-        carryFlag = getDirectBit(STATUS, C);
-        digitCarryFlag = getDirectBit(STATUS, DC);
-        zeroFlag = getDirectBit(STATUS, Z);
-    }
 
-    private int zeroFlag = 0;
+    public static void determineZeroFlag(int result){
-
-    public void determineZeroFlag(int result){
         if (result == 0){
             zeroFlag = 1;
             if (getBit(STATUS, Z) == 0){
@@ -260,13 +149,9 @@ public class DataRegister extends PICComponent implements DataRegisterInterface
         }
     }
 
-    public int getZeroFlag(){
+    private static int carryFlag = 0;
-        return zeroFlag;
-    }
 
-    private int carryFlag = 0;
+    public static void setCarryFlag(int value){
-
-    public void setCarryFlag(int value){
         carryFlag = value;
         if (value == 1){
             if (getBit(STATUS, C) == 0){
@@ -282,7 +167,7 @@ public class DataRegister extends PICComponent implements DataRegisterInterface
         }
     }
 
-    public void determineCarryFlag (int result){
+    public static void determineCarryFlag (int result){
         if (result > 0xFF){
             setCarryFlag(1);
         }
@@ -291,13 +176,13 @@ public class DataRegister extends PICComponent implements DataRegisterInterface
         }
     }
 
-    public int getCarryFlag (){
+    public static int getCarryFlag (){
         return carryFlag;
     }
 
-    private int digitCarryFlag = 0;
+    private static int digitCarryFlag = 0;
 
-    public void setDigitCarryFlag(int value){
+    public static void setDigitCarryFlag(int value){
         digitCarryFlag = value;
         if (value == 1){
             if (getBit(STATUS, DC) == 0){
@@ -313,8 +198,8 @@ public class DataRegister extends PICComponent implements DataRegisterInterface
         }
     }
 
-    public void determineDigitCarryFlag(int result){
+    public static void determineDigitCarryFlag(int result){
-        if (result >> 4  == 1){
+        if (result > 0xF){
             setDigitCarryFlag(1);
         }
         else {
@@ -322,32 +207,8 @@ public class DataRegister extends PICComponent implements DataRegisterInterface
         }
     }
 
-    public int getDigitCarryFlag(){
+    public static int getDigitCarryFlag(){
         return digitCarryFlag;
     }
 
-    public void setDirectRegister(int fileAddress, int content) {
-        dataRegister[fileAddress] = content;
-    }
-
-
-    public int getPCL() {
-        return PCL;
-    }
-    public int getSTATUS() {
-        return STATUS;
-    }
-
-    public int getPCLATH() {
-        return PCLATH;
-    }
-    public int getINTCON() {
-        return INTCON;
-    }
-
-    public int getDirectRegister(int address) {
-        return dataRegister[address];
-    }
 }
-
-

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

@@ -1,184 +0,0 @@
-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

@@ -1,151 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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,252 +0,0 @@
-package fabrik.simulator.pic16f84;
-
-import fabrik.simulator.pic16f84.frontendspecifics.Circle;
-import fabrik.simulator.pic16f84.frontendspecifics.FrontendSpecificCircle;
-import fabrik.simulator.pic16f84.frontendspecifics.FrontendSpecificToggleButtonGroup;
-import fabrik.simulator.pic16f84.frontendspecifics.ToggleButtonGroup;
-import fabrik.simulator.pic16f84.interfaces.*;
-import javafx.collections.ObservableList;
-import javafx.scene.control.ToggleButton;
-import javafx.scene.paint.Color;
-import javafx.scene.paint.RadialGradient;
-import javafx.scene.paint.Stop;
-
-import java.io.IOException;
-
-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);
-        }
-        else{
-            trisLatch[address - TRISA] |= (1 << bit);
-        }
-        refreshPorts();
-    }
-
-    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 (((trisLatch[address-TRISA] >> bit)&1) == 1){
-                trisLatch[address-TRISA] -= (int) Math.pow(2, bit);
-            }
-        }
-        refreshPorts();
-    }
-
-    public void setRegister(int address, int content) {
-        if (address < 7) {
-            dataLatch[address - PORTA] = content;
-        }
-        else{
-            trisLatch[address - TRISA] = content;
-        }
-        refreshPorts();
-    }
-
-    private void refreshPorts() {
-        dataRegister.setDirectRegister(PORTA, ((~((~dataLatch[A])&0x1F | trisLatch[A])) | (trisLatch[A] & dataRegister.getDirectRegister(PORTA))) & 0xFF);
-        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 (FrontendSpecificCircle[] a, FrontendSpecificCircle[] b){
-        allLEDsA = (Circle []) a;
-        allLEDsB = (Circle []) 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

@@ -1,68 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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,12 +23,10 @@ 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 (int i = 0; i<zeilen.toArray().length; i++) {
+        for (String zeile : zeilen) {
-            String zeile = zeilen.get(i);
             String[] teile = zeile.split("\\s+"); // Spaltenweise werden die einzelnen Befehle getrennt
             if (teile.length >= 2) {
                 try {
@@ -38,7 +36,6 @@ 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
@@ -47,6 +44,6 @@ public class ParseFile {
             }
         }
 
-        return new int[][]{programmspeicher, zeilenspeicher};
+        return programmspeicher;
     }
 }

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

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

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

@@ -1,153 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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/Circle.java

@@ -1,8 +0,0 @@
-package fabrik.simulator.pic16f84.frontendspecifics;
-
-
-public class Circle extends javafx.scene.shape.Circle implements FrontendSpecificCircle {
-    public Circle () {
-        super();
-    }
-}

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

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

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

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

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

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

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

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

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

@@ -1,13 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

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

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

@@ -1,13 +0,0 @@
-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

@@ -1,29 +0,0 @@
-package fabrik.simulator.pic16f84.interfaces;
-
-import java.io.IOException;
-
-import fabrik.simulator.pic16f84.frontendspecifics.FrontendSpecificCircle;
-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(FrontendSpecificCircle[] allLEDsA, FrontendSpecificCircle[] allLEDsB);
-
-    void setLEDs(boolean[] booleans);
-}

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

@@ -1,9 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

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

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

@@ -1,9 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,10 +0,0 @@
-.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,14 +6,7 @@ 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

@@ -0,0 +1,21 @@
+<?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

@@ -0,0 +1,13 @@
+<?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

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

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

@@ -1,88 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,135 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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());
-    }
-}