diff --git a/combined.qmd b/combined.qmd index 8fbf4e5..d94a38b 100644 --- a/combined.qmd +++ b/combined.qmd @@ -21,8 +21,7 @@ crossref: latex-list-of-description: UML-Diagramme --- -\newcommand*\listofumlsde{\listof{uml}{Verzeichnis der UML-Diagramme}} -\listofumlsde +\listof{uml}{Verzeichnis der UML-Diagramme} {{< include paul.qmd >}} {{< include luca.qmd >}} \ No newline at end of file diff --git a/paul.qmd b/paul.qmd index 1b75bb1..905c748 100644 --- a/paul.qmd +++ b/paul.qmd @@ -18,17 +18,13 @@ crossref: # 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, 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); -} -``` +In unserem Projekt fungiert [`PICComponentLocator`] als dieser Locator. Er besitzt einen `componentCatalogue` als Member, der eine `Map, PICComponentInterface>` ist. Das bedeutet, dass alle Klassen, die durch den Locator gemanaget werden sollen, das `PICComponentInterface` implementieren müssen. Dies ist auch in @uml-observer dargestellt [^1]. + 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): +Eingeführt wurden die `FrontendSpecific`s in [diesem Commit](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 { } @@ -52,7 +48,7 @@ public class ToggleButtonGroup extends } } ``` -Alle für das Marker-Pattern eingeführten Klassen sind in @uml-marker erkennbar: +Alle für das Marker-Pattern eingeführten Klassen sind in @uml-marker erkennbar [^1]: ::: {#uml-marker} @@ -61,10 +57,10 @@ Alle für das Marker-Pattern eingeführten Klassen sind in @uml-marker erkennbar classDiagram direction TB class FrontendSpecificObject { - <> + <> } class FrontendSpecificToggleButtonGroup { - <> + <> } class ToggleButtonGroup { public ToggleButtonGroup() @@ -81,7 +77,7 @@ FrontendSpecificToggleButtonGroup <|-- ToggleButtonGroup : << implements >> `com.gluonhq.charm.glisten.control.ToggleButtonGroup` <|-- ToggleButtonGroup : << extends >> class FrontendSpecificVBox{ - <> + <> } class VBox { public VBox() @@ -97,7 +93,7 @@ FrontendSpecificVBox <|-- VBox : << implements >> `javafx.scene.layout.VBox` <|-- VBox : << extends >> class FrontendSpecificCircle { - <> + <> } class Circle { public Circle() @@ -116,8 +112,135 @@ FrontendSpecificCircle <|-- Circle : << implements >> ``` -Das genutzte Marker-Pattern und alle seine Verwendungen +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. +[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. Die Implementierung wurde [hier](https://git.paulmartin.cloud/paul/PIC-Simu/commit/85bc6e9ebae4655ba3ad7ee360332010edc910dd) begonnen, [hier](https://git.paulmartin.cloud/paul/PIC-Simu/commit/cf6bcd8498cd2d03e85b0c5f6faaaed935d3a155) vereinfacht um das Threading des Frontends zu respektieren und [hier](https://git.paulmartin.cloud/paul/PIC-Simu/commit/52d63523341179c3c49e0ac31a60a8d7c11cdddc) in die letzten Tests eingefügt. +In der aktuellen Umsetzung übernimmt die [`Commands`]-Klasse gleichzeitig die Rolle des `ExecutionTimeSubject`s und `CommandsInterface`s. Deshalb [wird in der `Main`-Klasse](https://git.paulmartin.cloud/paul/PIC-Simu/src/commit/85bc6e9ebae4655ba3ad7ee360332010edc910dd/src/main/java/fabrik/simulator/pic16f84/Main.java) das `Commands`-Objekt dem `ComponentLocator` sowohl für die `ExecutionTimeSubject.class` als auch für die `CommandInterface.class` hinzugefügt. `ExecutionTimeObserver` sind die Klassen, die vorher `commands.getTotalExecutionTime()` gepollt haben. Die Implementierung dieses Entwursmusters ist in @uml-observer erkennbar [^1]: +:::{#uml-observer} + +```{mermaid} +%%| fig-width: 6.5 +classDiagram +direction TB +class PICComponentInterface{ + <> + + initialize(PICComponentLocator picComponents) +} + + +class CommandInterface { + <> + + CALL(int isr); + + + get_wRegister(); + + + decode(int i); +} + + +class PICComponent{ + <> + # DataRegisterInterface dataRegister + ... + + + initialize(PICComponentLocator locator) +} + + +class ExecutionTimeSubject{ + <> + - Set~ExecutionTimeObserver~ observers + + + registerObserver(ExecutionTimeObserver observer) + + unregisterObserver(ExecutionTimeObserver observer) + + getTotalExecutionTime() + + addExecutionTime(int i) + + getExecutionTimeMultiplier() + # notifyObservers() + ....() +} + + +class Commands{ + - wRegister + - totalExecutionTime + - executionTimeMultiplier + ....() +} + +class FrontendSpecificObject { + <> +} + +class FrontendControllerInterface{ + <> + + getPORTbuttons() FrontendSpecificToggleButtonGroup[] + + getTRISbuttons() FrontendSpecificToggleButtonGroup[] + + stopRunFromBackend(String watchdogTimer) +} + + +class Controller_Frontend { + ... + ....() +} + +class TimerInterface { + <> + + cycles(int i) + + incrementFromPin(int directRegister) + + increment(boolean manual) +} + +class Timer { + ... + ....() +} + + +class EEPROMInterface { + <> + registerTime(double executionTime, boolean b) + parse(int i, int content, int i1) + read(int address) long + write(int address, long data) +} + +class EEPROM { + ... + ....() +} + + +class ExecutionTimeObserver { + <> + + executionTimeChanged() +} + +ExecutionTimeObserver <|-- Timer : << implements >> +TimerInterface <|-- Timer : << implements >> +PICComponent <|-- Timer : << extends >> +PICComponentInterface <|-- TimerInterface : << extends >> +PICComponentInterface <|-- EEPROMInterface : << extends >> +ExecutionTimeObserver <|-- EEPROM : << implements >> +EEPROMInterface <|-- EEPROM : << implements >> +PICComponent <|-- EEPROM : << extends >> +ExecutionTimeObserver <|-- Controller_Frontend : << implements >> +PICComponent <|-- Controller_Frontend : << extends >> +PICComponentInterface <|-- PICComponent : << implements >> +PICComponentInterface <|-- FrontendControllerInterface : << extends >> +FrontendControllerInterface <|-- Controller_Frontend : << implements >> +FrontendSpecificObject <|-- FrontendControllerInterface : << extends >> +CommandInterface <|-- Commands : << implements >> +ExecutionTimeSubject <|-- Commands : << extends >> +PICComponent <|-- ExecutionTimeSubject : << extends >> +PICComponentInterface <|-- CommandInterface : << extends >> + +``` + +Das genutzte Observer-Pattern und seine Verwendungen im (nicht-Test-) Code. +::: + +[^1]: Für das Pattern unwichtige Funktionen und Variablen ausgelassen \ No newline at end of file diff --git a/src/main/java/fabrik/simulator/pic16f84/ExecutionTimeSubject.java b/src/main/java/fabrik/simulator/pic16f84/ExecutionTimeSubject.java index 2e02753..260917c 100644 --- a/src/main/java/fabrik/simulator/pic16f84/ExecutionTimeSubject.java +++ b/src/main/java/fabrik/simulator/pic16f84/ExecutionTimeSubject.java @@ -4,9 +4,8 @@ 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{ +public abstract class ExecutionTimeSubject extends PICComponent{ private Set observers; public ExecutionTimeSubject(){ diff --git a/src/main/java/fabrik/simulator/pic16f84/PICComponent.java b/src/main/java/fabrik/simulator/pic16f84/PICComponent.java index 291a7ca..4dc1943 100644 --- a/src/main/java/fabrik/simulator/pic16f84/PICComponent.java +++ b/src/main/java/fabrik/simulator/pic16f84/PICComponent.java @@ -2,20 +2,20 @@ 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 abstract class PICComponent implements PICComponentInterface{ + protected DataRegisterInterface dataRegister; + protected EEPROMInterface eeprom; + protected PreScalerInterface preScaler; + protected IOPortInterface ioPorts; + protected TimerInterface timer; + protected InterruptInterface interrupts; + protected TableInterface table; + protected FrontendControllerInterface frontendController; + protected WatchdogTimerInterface watchdogTimer; + protected ProgramStackInterface programStack; + protected CommandInterface commands; + protected ExecutionTimeSubject executionTime; + protected ToggleButtonInterface toggleButtonExt; public void initialize(PICComponentLocator locator) { toggleButtonExt = locator.getComponent(ToggleButtonInterface.class);