Restructure for better usability

lib/test/com.py

@@ -0,0 +1,148 @@
+"""
+Library to be used in standalone mode (without microcontroller, for testing functionality)
+It simulates the behviour of an actual microcontroller being connected
+"""
+
+from typing import Optional
+import queue
+import random
+import time
+import struct
+
+from lib.com import ComSuperClass
+
+# This file contains a Com class that can be used to test the functionality
+# even without a microcontroller. It is not documented in a particularly
+# beginner-friendly way, nor is the code written with beginner-friendliness
+# in mind. It is the most complicated piece of code of the entire application
+
+# All double __ prefixed properties and methods are not available in the actual one
+
+instruction_lut: dict[str, list[str]] = {
+    "PR": ["\n", "P", "R", "\n"],
+    "PT": ["\n", "P", "T", "\n"],
+    "RD": ["\n", "R", "D", "\n"],
+    "NM": ["\n", "N", "M", "\n"],
+    "FM": ["\n", "F", "M", "\n"],
+}
+
+
+class SimulationError(Exception):
+    pass
+
+
+class Com(ComSuperClass):
+    def __init__(
+        self, baudrate: int = 19200, filters: Optional[list[str]] = None
+    ) -> None:
+        # Calling the constructor of the super class to assign defaults
+        print("\n\nWARNING: Using testing library for communication!\n\n")
+        super().__init__(baudrate, filters)
+
+        # Initialize queue with values to be sent on call of recieve
+        self.__simulated_data: queue.Queue[bytes] = queue.Queue()
+        self.__simulated_data_remaining = 0
+
+        # Initially, we are in normal mode (which leads to slower data intervals)
+        self.__mode = "NM"
+
+    def set_port_override(self, override: str) -> None:
+        """Set the port override, to disable port search"""
+        self._port_override = override
+
+    def get_comport(self) -> str:
+        return "test" if self._port_override != "" else self._port_override
+
+    def connect(self) -> bool:
+        # Randomly return false in 1 in 20 ish cases
+        if random.randint(0, 20) == 1:
+            print("Simulating error to connect")
+            return False
+        return True
+
+    def close(self) -> None:
+        pass
+
+    def receive(self, byte_count: int) -> bytes:
+        data = []
+        # If queue is too short, refill it
+        if self.__simulated_data_remaining < byte_count:
+            self.__fill_queue()
+
+        for _ in range(byte_count):
+            if self.__mode == "NM":
+                time.sleep(0.001)
+            try:
+                data.append(self.__simulated_data.get_nowait())
+                self.__simulated_data_remaining -= 1
+            except Exception as e:
+                print("ERROR: Simulation could not continue")
+                raise SimulationError(
+                    "Simulation encountered an error with the simulation queue. The error encountered: \n"
+                    + str(e)
+                )
+        return b''.join(data)
+
+    def send(self, msg: str) -> None:
+        # Using LUT to reference
+        readback = instruction_lut.get(msg)
+        if readback != None:
+            for i in range(len(readback)):
+                self.__simulated_data.put(bytes(readback[i], "ascii"))
+        if msg == "RD":
+            # Handle ReadData readback
+            # self.__simulated_data.put(ord(""))
+            pass
+
+    def send_float(self, msg: float) -> None:
+        # Encode float as 8 bytes (64 bit)
+        ba = struct.pack("d", msg)
+        for byte in ba:
+            self.__simulated_data.put(byte.to_bytes())
+
+    def __fill_queue_alternative(self):
+        for _ in range(4):
+            for _ in range(4):
+                self.__simulated_data.put(random.randbytes(1))
+            self.__simulated_data.put(bytes(" ", "ascii"))
+            for _ in range(6):
+                self.__simulated_data.put(random.randbytes(1))
+            self.__simulated_data.put(bytes(" ", "ascii"))
+        for _ in range(3):
+            for _ in range(4):
+                self.__simulated_data.put(random.randbytes(1))
+            self.__simulated_data.put(bytes(" ", "ascii"))
+        for _ in range(4):
+            self.__simulated_data.put(random.randbytes(1))
+        self.__simulated_data.put(bytes("\n", "ascii"))
+        self.__simulated_data_remaining = 68
+
+    def __fill_queue(self):
+        for _ in range(4):
+            self.__add_integer_as_hex(self.__generate_random_int(200))
+            self.__simulated_data.put(bytes(" ", "ascii"))
+            self.__add_float_as_hex(self.__generate_random_float(50))
+            self.__simulated_data.put(bytes(" ", "ascii"))
+            self.__simulated_data_remaining += 2
+        for _ in range(3):
+            self.__add_integer_as_hex(self.__generate_random_int(65535))
+            self.__simulated_data.put(bytes(" ", "ascii"))
+        self.__add_integer_as_hex(self.__generate_random_int(65535))
+        self.__simulated_data.put(bytes("\n", "ascii"))
+        self.__simulated_data_remaining += 4
+        print("Length:", self.__simulated_data_remaining)
+
+    def __generate_random_int(self, max: int) -> int:
+        return random.randint(0, max)
+
+    def __generate_random_float(self, max: int) -> float:
+        return random.random() * max
+
+    def __add_character_as_hex(self, data: str):
+        pass
+
+    def __add_integer_as_hex(self, data: int):
+        pass
+
+    def __add_float_as_hex(self, data: float):
+        pass