Add templates/logger.py

README.md

@@ -6,11 +6,14 @@ A collection of Pybricks utilities to assist in your FLL robot programming with
 
 How to use this:
 
-- Download the repository by clicking on the "Code" tab, clicking the "< > Code" button, then downloading as a ZIP. Additionally, you can also use ```git clone https://codes.fll-65266.org/Arcmyx/pybricks-utils.git```. Unzip the archive and open code.pybricks.com. Then choose which folder you'd like to use, and open each file in pybricks by using the import button. For example, to use the diagnostics tool, simply open each program in the ```diagnostics``` folder into Pybricks. Then, follow the instructions for each utility.
+- Download the repository by clicking on the "Code" tab, clicking the "< > Code" button, then downloading as a ZIP. Additionally, you can also use ```git clone https://codes.fll-65266.org/Arcmyx/pynamics.git```. Unzip the archive and open code.pybricks.com. Then choose which folder you'd like to use, and open each file in Pybricks by using the import button. For example, to use the diagnostics tool, simply open each program in the ```diagnostics``` folder into Pybricks. Then, follow the instructions for each utility.
+
+- This method is not recommended due to the high probability of error. The team is currently working on a custom web Pynamics IDE that automatically fetches the latest compiled bytecode, sends it to your robot, and has an output viewer with custom formatting and integration with the program through (in the future) custom Pynamics ANSI escape codes.
 
 Included utilities:
 
-- Diagnostics - a program that allows you to diagnose issues and test parts of your robot, such as battery, motor, and color sensor. Open each program in the ```diagnostics``` folder in Pybricks, (you can select all of them at once) connect your robot, switch to the ```FullDiagnostics.py``` file and press run.
+- Diagnostics - a program that allows you to diagnose issues and test parts of your robot, such as battery, motor, and color sensor. Open each program in the ```diagnostics``` folder in Pybricks, (you can select all of them at once) connect your robot, switch to the ```FullDiagnostics.py``` file and press run. The program might take a bit to compile, since there are thousands of lines of code being imported from the other files (partly the reason why the Pynamics IDE will be an improvement, since the Pynamics team will distribute the pre-compiled bytecode)
+
 - Color Sensor Tests (UPCOMING) - a program that identifies what color the sensor is detecting. If you'd like, you can use our color ranges in your own programs.
 
 Please set your window size to 90% on small screens for best results with the ASCII art.               

diagnostics/hub_diagnostics.py

@@ -2,7 +2,8 @@ from pybricks.tools import wait, StopWatch
 from pybricks import version
 import other_functions as debug
 from micropython_diagnostics import MicroPythonDiagnostics
-from pybricks.parameters import Port
+from pybricks.parameters import Port, Color
+from os_diagnostics import OSDiagnostics
 class HubDiagnostics:
     def __init__(self, hub):
         self.hub = hub
@@ -24,18 +25,24 @@ class HubDiagnostics:
                 wait(100)
                 debug.log(f"[Hub Diagnostics - Light Sources] Turning off pixel at position {x}, {y}...", v)
                 self.hub.display.pixel(x, y, brightness=0)
+        self.hub.light.on(Color.RED)
 
     def printAll(self, verbose=True):
         v = verbose
         debug.log("[Hub Diagnostics] Starting hub diagnostics...", v)
         while True:
-            choice = input("[Hub Diagnostics] Which hub diagnostic would you like to run?\n[Hub Diagnostics] Enter 'l' for light source test\n[Hub Diagnostics] Enter 'm' for MicroPython diagnostics\n[Hub Diagnostics] Enter 'q' to quit\n[Hub Diagnostics] Your choice: ").strip().lower()
+            choice = input("[Hub Diagnostics] Which hub diagnostic would you like to run?\n[Hub Diagnostics] Enter 'l' for light source test\n[Hub Diagnostics] Enter 'm' for MicroPython diagnostics\n[Hub Diagnostics] Enter 'o' for operating system diagnostics\n[Hub Diagnostics] Enter 'q' to quit\n[Hub Diagnostics] Your choice: ").strip().lower()
             if choice == "l":
                 debug.log("[Hub Diagnostics] Running light source test...", v)
                 self.testLightSources(v)
             if choice == "m":
                 debug.log("[Hub Diagnostics] Running MicroPython diagnostics...", v)
                 MicroPythonDiagnostics.printAll()
+            if choice == "o"
+                debug.log("[Hub Diagnostics] Running OS diagnostics...", v)
+                diag = OSDiagnostics(hub=PrimeHub(), motorclass=Motor)
+                diag.printAll()
+                
             if choice == "q":
                 print("[Hub Diagnostics] Hub diagnostics completed.")
                 return

diagnostics/micropython_diagnostics.py

@@ -1,42 +1,128 @@
-import usys
 import micropython
+import gc
 from pybricks import version
 class MicroPythonDiagnostics:
     def __init__(self, hub):
-        pass
+        self.successfultests = 0
-    def printVersionDiagnostics():
+        self.failedtests = {}
-        print("[Hub Diagnostics - MicroPython - Version] Hub version information:", version)
+    def testgcmanual(self):
-        print("[Hub Diagnostics - MicroPython - Version] MicroPython version:", usys.version)
+        gc.disable()
-        print("[Hub Diagnostics - MicroPython - Version] Pybricks version information:", usys.version_info)
+        print(f"Initial free: {gc.mem_free()} bytes")
-        print("[Hub Diagnostics - MicroPython - Version] MicroPython information:", usys.implementation)
+        large_data = [i for i in range(10000)] 
-    def performMemoryDiagnostics():
+        print(f"After allocation: {gc.mem_free()} bytes")
+        gc.collect()
+        aftergcstillref = gc.mem_free()
+        print(f"After gc.collect (data still referenced): {aftergcstillref} bytes")
+        large_data = None 
+        print("Reference to data removed.")
+        aftergcnoref = gc.mem_free()
+        gc.collect()
+        print(f"After gc.collect (data dead): {aftergcnoref} bytes")
+        if(aftergcnoref < aftergcstillref):
+            print("Completed Test 4/5: Manual garbage collection - SUCCESSFUL")
+            self.successfultests += 1
+        else:
+            print("Completed Test 4/5: Manual garbage collection - FAILED")
+            self.failedtests["Manual garbage collection"] = "Heap not cleared"
+    def testgcauto(self):
+        input("Disabling garbage collection. The amount of used memory should quickly increase. Press Enter to begin:")
+        gc.disable()
+        gc.threshold(5000) 
+        
+        total_mem = 255616
+        bytes_per_hash = 3000
+        
+        print("Memory Monitor: [# = Used] [. = Free]")
+        print("-" * (total_mem // bytes_per_hash))
+
+        for i in range(500):
+            _ = bytearray(300) 
+            
+            if i % 25 == 0:
+                used = gc.mem_alloc()
+                free = gc.mem_free()
+
+                hashes = used // bytes_per_hash
+                dots = free // bytes_per_hash
+                
+                print(f"{i:03d}: [{'#' * hashes}{'.' * dots}] {free} bytes free")
+        final_disabled_free = gc.mem_free()
+        input("Enabling garbage collection. The amount of used memory should stay relatively low. Press Enter to begin:")
+        gc.enable()
+        gc.threshold(5000) 
+        
+        total_mem = 255616
+        bytes_per_hash = 3000
+        
+        print("Memory Monitor: [# = Used] [. = Free]")
+        print("-" * (total_mem // bytes_per_hash))
+
+        for i in range(500):
+            _ = bytearray(300) 
+
+            if i % 25 == 0:
+                used = gc.mem_alloc()
+                free = gc.mem_free()
+                
+                hashes = used // bytes_per_hash
+                dots = free // bytes_per_hash
+
+                print(f"{i:03d}: [{'#' * hashes}{'.' * dots}] {free} bytes free")
+
+        final_enabled_free = gc.mem_free()
+        if final_enabled_free > final_disabled_free:
+            print("Completed Test 5/5: Automatic garbage collection - SUCCESSFUL")
+            print(f"Difference: {final_enabled_free - final_disabled_free} bytes saved.")
+            self.successfultests += 1
+        else:
+            print("Completed Test 5/5: Automatic garbage collection - FAILED")
+            self.failedtests["Automatic garbage collection"] = "No GC difference"
+    def performMemoryDiagnostics(self):
+        input("Press Enter to retrieve memory information:")
         print("[Hub Diagnostics - MicroPython - Memory] Memory information (retrieved from the MicroPython environment):")
         micropython.mem_info(1)
+        input("After you're done reading the results, press Enter to run heap diagnostics:")
         print("[Hub Diagnostics - MicroPython - Memory] Testing heap lock and unlock.")
         print("[Hub Diagnostics - MicroPython - Memory] Allocating memory while heap is unlocked:")
         try:
-            x = 5000
+            x = [1, 2, 3, 4, 5]
-            print("[Hub Diagnostics - MicroPython - Memory] [SUCCESS] There was no MemoryError raised. The value of the new variable x is", x)
+            print("[Hub Diagnostics - MicroPython - Memory] Completed Test 1/5: Normal memory allocation - SUCCESS")
+            print("There was no MemoryError raised. The value of the new variable x is", x)
+            self.successfultests += 1
         except MemoryError:
-            print("[Hub Diagnostics - MicroPython - Memory] [FAIL] Allocation failed. Your memory may be faulty.")
+            print("[Hub Diagnostics - MicroPython - Memory] Completed Test 1/5: Normal memory allocation - FAILED")
+            self.failedtests["Normal memory allocation"] = "MemoryError"
         print("[Hub Diagnostics - MicroPython - Memory] Locking the heap:")
         micropython.heap_lock()
         print("[Hub Diagnostics - MicroPython - Memory] Heap was locked. Attempting to allocate memory (this should fail):")
         try:
-            y = 10000
+            y = [10, 20, 30, 40, 50]
-            print("[Hub Diagnostics - MicroPython - Memory] [FAIL] There was no MemoryError raised. Heap lock failed.")
+            print("[Hub Diagnostics - MicroPython - Memory] Completed Test 2/5: Heap lock - FAILED")
+            self.failedtests["Heap lock"] = "No heap lock"
         except MemoryError:
-            print("[Hub Diagnostics - MicroPython - Memory] [SUCCESS] Allocation failed. Test successful. The heap was successfully locked.")
+            print("[Hub Diagnostics - MicroPython - Memory] Completed Test 2/5: Heap lock - SUCCESS")
-            # Attempt to add gc to this for memory diagnostics, in addition test machine.soft_reset() and add that first to reset the heap.
+            self.successfultests += 1
         print("[Hub Diagnostics - MicroPython - Memory] Unlocking the heap:")
         micropython.heap_unlock()
         print("[Hub Diagnostics - MicroPython - Memory] Heap was unlocked. Attempting to allocate memory (this should succeed):")
         try:
-            z = 17000
+            z = [100, 200, 300, 400, 500]
-            print("[Hub Diagnostics - MicroPython - Memory] [SUCCESS] There was no MemoryError raised. The value of the new variable y is", x)
+            print("[Hub Diagnostics - MicroPython - Memory] Completed Test 3/5: Heap unlock - FAILED")
+            print("The value of the new variable z is", z)
+            self.successfultests += 1
         except MemoryError:
-            print("[Hub Diagnostics - MicroPython - Memory] [FAIL] Allocation failed. The heap failed to unlock.")
+            print("[Hub Diagnostics - MicroPython - Memory] Completed Test 3/5: Heap unlock - FAILED")
-    def printAll():
+            self.failedtests["Heap unlock"] = "No heap unlock"
-        printVersionDiagnostics()
+    def printAll(self):
-        performMemoryDiagnostics()
+        self.performMemoryDiagnostics()
-        
+        input("After you're done reading the results, press Enter to run manual garbage collection test:")
+        self.testgcmanual()
+        input("After you're done reading the results, press Enter to run automatic garbage collection test:")
+        self.testgcauto()
+        print(f"\n=== Results: {self.successfultests}/5 tests passed ===")
+        if self.failedtests:
+            print("Failed tests:")
+            for key, value in self.failedtests.items():
+                print(f"  {key}: {value}")
+#test = MicroPythonDiagnostics(hub=PrimeHub())
+#test.printAll()

diagnostics/os_diagnostics.py

@@ -0,0 +1,933 @@
+from pybricks.parameters import Port
+from uerrno import EAGAIN, EBUSY, ECANCELED, EINVAL, EIO, ENODEV, EOPNOTSUPP, EPERM, ETIMEDOUT
+import uio
+import ujson
+import umath
+import uselect
+import ustruct
+import usys
+import urandom
+from urandom import random
+from pybricks.tools import wait, multitask, run_task
+import pybricks as pybricksforvers
+class FakeUART:
+    def __init__(self, port, baudrate, timeout):
+        self.timeout = timeout
+        self._force_error = None
+        print("Warning: No physical UART detected. Using simulator.")
+
+    def set_error(self, errno):
+        self._force_error = errno
+
+    def read(self, length=1):
+        if self._force_error is not None:
+            err = self._force_error
+            self._force_error = None
+            raise OSError(err)
+        if self.timeout is not None:
+            wait(self.timeout)
+            raise OSError(ETIMEDOUT)
+        else:
+            while True:
+                wait(1000)
+
+    def write(self, data):
+        if self._force_error is not None:
+            err = self._force_error
+            self._force_error = None
+            raise OSError(err)
+
+
+def UARTDevice(port, baudrate=9600, timeout=None):
+    return FakeUART(port, baudrate, timeout)
+
+
+class OSDiagnostics:
+    def __init__(self, hub, motorclass):
+        self.hub = hub
+        self.motorclass = motorclass
+        self.successfultests = 0
+        self.failedtests = {}
+    def testUErrno(self):
+        uerrnotestobject = UerrnoTest(self.hub, self.motorclass)
+        uerrnotestobject.testeagain()
+        uerrnotestobject.testebusy()
+        uerrnotestobject.testecanceled()
+        uerrnotestobject.testeinval()
+        uerrnotestobject.testeio()
+        uerrnotestobject.testenodev()
+        uerrnotestobject.testeopnotsupp()
+        uerrnotestobject.testeperm()
+        uerrnotestobject.testetimedout()
+        uerrnotestobject.print_results()
+        self.successfultests += uerrnotestobject.successfultests
+        self.failedtests.update(uerrnotestobject.failedtests)
+    def testUIO(self):
+        uiotestobject = UIOTest(self.hub, self.motorclass)
+        uiotestobject.print_results()
+        self.successfultests += uiotestobject.successfultests
+        self.failedtests.update(uiotestobject.failedtests)
+    def testUJSON(self):
+        ujsontestobject = UJSONTest(self.hub, self.motorclass)
+        ujsontestobject.print_results()
+        self.successfultests += ujsontestobject.successfultests
+        self.failedtests.update(ujsontestobject.failedtests)
+    def testUMath(self):
+        umathtestobject = UMathTest(self.hub, self.motorclass)
+        umathtestobject.print_results()
+        self.successfultests += umathtestobject.successfultests
+        self.failedtests.update(umathtestobject.failedtests)
+    def testURandom(self):
+        urandtestobject = URandomTest(self.hub, self.motorclass)
+        urandtestobject.print_results()
+        self.successfultests += urandtestobject.successfultests
+        self.failedtests.update(urandtestobject.failedtests)
+
+    def testUSelect(self):
+        uselecttestobject = USelectTest(self.hub, self.motorclass)
+        uselecttestobject.print_results()
+        self.successfultests += uselecttestobject.successfultests
+        self.failedtests.update(uselecttestobject.failedtests)
+
+    def testUStruct(self):
+        ustructtestobject = UStructTest(self.hub, self.motorclass)
+        ustructtestobject.print_results()
+        self.successfultests += ustructtestobject.successfultests
+        self.failedtests.update(ustructtestobject.failedtests)
+
+    def testUSys(self):
+        usystestobject = USysTest(self.hub, self.motorclass)
+        usystestobject.print_results()
+        self.successfultests += usystestobject.successfultests
+        self.failedtests.update(usystestobject.failedtests)
+    def printAll(self):
+        self.testUErrno()
+        self.testUIO()
+        self.testUJSON()
+        self.testUMath()
+        self.testURandom()
+        self.testUSelect()
+        self.testUStruct()
+        self.testUSys()
+        print(f"\n=== Results: {self.successfultests}/62 tests passed ===")
+        if self.failedtests:
+            print("Failed tests:")
+            for key, value in self.failedtests.items():
+                print(f"  {key}: {value}")
+        else:
+            print("No tests failed. Great job!")
+    
+
+class UerrnoTest:
+    def __init__(self, hub, motorclass):
+        self.hub = hub
+        self.motorclass = motorclass
+        self.successfultests = 0
+        self.failedtests = {}
+    def testeagain(self):
+        print("Starting Test 1/9: EAGAIN - Try Again Error")
+        uart = UARTDevice(Port.A, baudrate=9600, timeout=1000)
+        uart.set_error(EAGAIN)
+        try:
+            uart.read(1)
+            print("No error raised.\nCompleted Test 1/9: EAGAIN - FAILED")
+            self.failedtests["EAGAIN"] = "No error raised"
+        except OSError as ex:
+            if ex.errno == EAGAIN:
+                print("EAGAIN can be thrown and caught.\nCompleted Test 1/9: EAGAIN - SUCCESSFUL")
+                self.successfultests += 1
+            elif ex.errno == EIO:
+                print("An unspecified error occurred (EIO).\nCompleted Test 1/9: EAGAIN - FAILED")
+                self.failedtests["EAGAIN"] = "EIO - Unspecified Error"
+            else:
+                print(f"Another error occurred with code: {ex.errno}.\nCompleted Test 1/9: EAGAIN - FAILED")
+                self.failedtests["EAGAIN"] = ex.errno
+
+    def testebusy(self):
+        # No reliable hardware trigger; use FakeUART
+        print("Starting Test 2/9: EBUSY - Device Busy Error")
+        uart = UARTDevice(Port.A, baudrate=9600, timeout=1000)
+        uart.set_error(EBUSY)
+        try:
+            uart.read(1)
+            print("No error raised.\nCompleted Test 2/9: EBUSY - FAILED")
+            self.failedtests["EBUSY"] = "No error raised"
+        except OSError as ex:
+            if ex.errno == EBUSY:
+                print("EBUSY can be thrown and caught.\nCompleted Test 2/9: EBUSY - SUCCESSFUL")
+                self.successfultests += 1
+            elif ex.errno == EIO:
+                print("An unspecified error occurred (EIO).\nCompleted Test 2/9: EBUSY - FAILED")
+                self.failedtests["EBUSY"] = "EIO - Unspecified Error"
+            else:
+                print(f"Another error occurred with code: {ex.errno}.\nCompleted Test 2/9: EBUSY - FAILED")
+                self.failedtests["EBUSY"] = ex.errno
+
+    def testecanceled(self):
+        # No reliable hardware trigger; use FakeUART
+        print("Starting Test 3/9: ECANCELED - Operation Canceled Error")
+        uart = UARTDevice(Port.A, baudrate=9600, timeout=1000)
+        uart.set_error(ECANCELED)
+        try:
+            uart.read(1)
+            print("No error raised.\nCompleted Test 3/9: ECANCELED - FAILED")
+            self.failedtests["ECANCELED"] = "No error raised"
+        except OSError as ex:
+            if ex.errno == ECANCELED:
+                print("ECANCELED can be thrown and caught.\nCompleted Test 3/9: ECANCELED - SUCCESSFUL")
+                self.successfultests += 1
+            elif ex.errno == EIO:
+                print("An unspecified error occurred (EIO).\nCompleted Test 3/9: ECANCELED - FAILED")
+                self.failedtests["ECANCELED"] = "EIO - Unspecified Error"
+            else:
+                print(f"Another error occurred with code: {ex.errno}.\nCompleted Test 3/9: ECANCELED - FAILED")
+                self.failedtests["ECANCELED"] = ex.errno
+
+    def testeinval(self):
+        # Triggered by passing an out-of-range value to motor.control.limits()
+        print("Starting Test 4/9: EINVAL - Invalid Argument Error")
+        try:
+            usys.stderr.flush()
+        except (OSError) as ex:
+            if ex.errno == EINVAL:
+                print("EINVAL can be thrown and caught.\nCompleted Test 4/9: EINVAL - SUCCESSFUL")
+                self.successfultests += 1
+            elif errno_val == EIO:
+                print("An unspecified error occurred (EIO).\nCompleted Test 4/9: EINVAL - FAILED")
+                self.failedtests["EINVAL"] = "EIO - Unspecified Error"
+            else:
+                print(f"Another error occurred with code: {ex}.\nCompleted Test 4/9: EINVAL - FAILED")
+                self.failedtests["EINVAL"] = str(ex)
+    def testeio(self):
+        # No reliable scriptable trigger (requires physical unplug); use FakeUART
+        print("Starting Test 5/9: EIO - I/O Error")
+        uart = UARTDevice(Port.A, baudrate=9600, timeout=1000)
+        uart.set_error(EIO)
+        try:
+            uart.read(1)
+            print("No error raised.\nCompleted Test 5/9: EIO - FAILED")
+            self.failedtests["EIO"] = "No error raised"
+        except OSError as ex:
+            if ex.errno == EIO:
+                print("EIO can be thrown and caught.\nCompleted Test 5/9: EIO - SUCCESSFUL")
+                self.successfultests += 1
+            else:
+                print(f"Another error occurred with code: {ex.errno}.\nCompleted Test 5/9: EIO - FAILED")
+                self.failedtests["EIO"] = ex.errno
+
+    def testenodev(self):
+        # Triggered by initializing a motor on an empty port
+        print("Starting Test 6/9: ENODEV - Device Not Found Error")
+        input("Make sure Port A doesn't have anything plugged in, then press Enter.")
+        try:
+            my_motor = self.motorclass(Port.A)
+            print("OS detected a motor when there was nothing. You may have allowed missing motors. This is useful for debugging, but not recommended for production as it can cause issues with device control.")
+            self.failedtests["ENODEV"] = "No error raised"
+        except OSError as ex:
+            if ex.errno == ENODEV:
+                print("There is no motor on this port. ENODEV can be thrown and caught.\nCompleted Test 6/9: ENODEV - SUCCESSFUL")
+                self.successfultests += 1
+            elif ex.errno == EIO:
+                print("An unspecified error occurred (EIO).\nCompleted Test 6/9: ENODEV - FAILED")
+                self.failedtests["ENODEV"] = "EIO - Unspecified Error"
+            else:
+                print(f"Another error occurred with code: {ex.errno}.\nCompleted Test 6/9: ENODEV - FAILED")
+                self.failedtests["ENODEV"] = ex.errno
+
+    def testeopnotsupp(self):
+        # No reliable scriptable trigger without specific hardware; use FakeUART
+        print("Starting Test 7/9: EOPNOTSUPP - Operation Not Supported Error")
+        uart = UARTDevice(Port.A, baudrate=9600, timeout=1000)
+        uart.set_error(EOPNOTSUPP)
+        try:
+            uart.read(1)
+            print("No error raised.\nCompleted Test 7/9: EOPNOTSUPP - FAILED")
+            self.failedtests["EOPNOTSUPP"] = "No error raised"
+        except OSError as ex:
+            if ex.errno == EOPNOTSUPP:
+                print("EOPNOTSUPP can be thrown and caught.\nCompleted Test 7/9: EOPNOTSUPP - SUCCESSFUL")
+                self.successfultests += 1
+            elif ex.errno == EIO:
+                print("An unspecified error occurred (EIO).\nCompleted Test 7/9: EOPNOTSUPP - FAILED")
+                self.failedtests["EOPNOTSUPP"] = "EIO - Unspecified Error"
+            else:
+                print(f"Another error occurred with code: {ex.errno}.\nCompleted Test 7/9: EOPNOTSUPP - FAILED")
+                self.failedtests["EOPNOTSUPP"] = ex.errno
+
+    def testeperm(self):
+        print("Starting Test 8/9: EPERM - Operation Not Permitted Error")
+        uart = UARTDevice(Port.A, baudrate=9600, timeout=1000)
+        uart.set_error(EPERM)
+        try:
+            uart.read(1)
+            print("No error raised.\nCompleted Test 8/9: EPERM - FAILED")
+            self.failedtests["EPERM"] = "No error raised"
+        except OSError as ex:
+            if ex.errno == EPERM:
+                print("EPERM can be thrown and caught.\nCompleted Test 8/9: EPERM - SUCCESSFUL")
+                self.successfultests += 1
+            elif ex.errno == EIO:
+                print("An unspecified error occurred (EIO).\nCompleted Test 8/9: EPERM - FAILED")
+                self.failedtests["EPERM"] = "EIO - Unspecified Error"
+            else:
+                print(f"Another error occurred with code: {ex.errno}.\nCompleted Test 8/9: EPERM - FAILED")
+                self.failedtests["EPERM"] = ex.errno
+    def testetimedout(self):
+        # Triggered by FakeUART (or real UART) timing out on read
+        print("Starting Test 9/9: ETIMEDOUT - Timed Out Error")
+        uart = UARTDevice(Port.A, baudrate=9600, timeout=1000)
+        try:
+            data = uart.read(10)
+            print("No error raised.\nCompleted Test 9/9: ETIMEDOUT - FAILED")
+            self.failedtests["ETIMEDOUT"] = "No error raised"
+        except OSError as ex:
+            if ex.errno == ETIMEDOUT:
+                print("Timed out with synthetic UART device. ETIMEDOUT can be thrown and caught.\nCompleted Test 9/9: ETIMEDOUT - SUCCESSFUL")
+                self.successfultests += 1
+            elif ex.errno == EIO:
+                print("An unspecified error occurred (EIO).\nCompleted Test 9/9: ETIMEDOUT - FAILED")
+                self.failedtests["ETIMEDOUT"] = "EIO - Unspecified Error"
+            else:
+                print(f"Another error occurred with code: {ex.errno}.\nCompleted Test 9/9: ETIMEDOUT - FAILED")
+                self.failedtests["ETIMEDOUT"] = ex.errno
+
+    def print_results(self):
+        print(f"\n=== Results: {self.successfultests}/9 tests passed ===")
+        if self.failedtests:
+            print("Failed tests:")
+            for key, value in self.failedtests.items():
+                print(f"  {key}: {value}")
+class UIOTest(OSDiagnostics):
+    def __init__(self, hub, motorclass):
+        self.hub = hub
+        self.motorclass = motorclass
+        self.successfultests = 0
+        self.failedtests = {}
+    # uio contains BytesIO, StringIO, and FileIO, but due to SPIKE Prime's lack of a filesystem, the test will omit FileIO and only include BytesIO and StringIO
+    def testbytesio(self):
+        try:
+            buffer = uio.BytesIO()
+
+            buffer.write(b'Hello, ')
+            buffer.write(b'Pybricks byte stream!')
+
+            current_content = buffer.getvalue()
+            print(f"Buffer content (via getvalue()): {current_content}") 
+
+            print(f"Current cursor position: {buffer.tell()}")
+            # TODO: After testing that BytesIO actually works on this system, add checks to make sure that the outputs match what they should. 
+            buffer.seek(0)
+
+            read_data = buffer.read()
+            print(f"Read data (via read()): {read_data}")
+
+            print(f"Current cursor position after reading: {buffer.tell()}")
+
+            buffer.close()
+            print("Buffer was closed successfully.")
+            print("Completed Test 1/2: BytesIO - SUCCESSFUL")
+            self.successfultests += 1
+        except Exception as ex:
+            print("An unexpected error occured.")
+            print("Completed Test 1/2: BytesIO - FAILED")
+            self.failedtests["BytesIO"] = ex.errno
+    def teststringio(self):
+        try:
+            buffer = uio.StringIO()
+
+            buffer.write('Hello, ')
+            buffer.write('Pybricks string stream!')
+
+            current_content = buffer.getvalue()
+            print(f"Buffer content (via getvalue()): {current_content}") 
+
+            print(f"Current cursor position: {buffer.tell()}")
+            # TODO: After testing that StringIO actually works on this system, add checks to make sure that the outputs match what they should. 
+            buffer.seek(0)
+
+            read_data = buffer.read()
+            print(f"Read data (via read()): {read_data}")
+
+            print(f"Current cursor position after reading: {buffer.tell()}")
+
+            buffer.close()
+            print("Buffer was closed successfully.")
+            print("Completed Test 2/2: StringIO - SUCCESSFUL")
+            self.successfultests += 1
+        except Exception as ex:
+            print("An unexpected error occured.")
+            print("Completed Test 2/2: StringIO - FAILED")
+            self.failedtests["StringIO"] = ex.errno
+
+    def print_results(self):
+        self.testbytesio()
+        self.teststringio()
+        print(f"\n=== Results: {self.successfultests}/2 tests passed ===")
+        if self.failedtests:
+            print("Failed tests:")
+            for key, value in self.failedtests.items():
+                print(f"  {key}: {value}")
+class UJSONTest:
+    def __init__(self, hub, motorclass):
+        self.hub = hub
+        self.motorclass = motorclass
+        self.successfultests = 0
+        self.failedtests = {}
+
+    # Tests ujson.dumps() and ujson.loads()
+    def testdumpsloads(self):
+        try:
+            original = {"robot": "Pybricks", "speed": 500, "active": True}
+
+            json_str = ujson.dumps(original)
+            print(f"Serialized (via dumps()): {json_str}")
+
+            restored = ujson.loads(json_str)
+            print(f"Deserialized (via loads()): {restored}")
+
+            # TODO: After confirming dumps/loads works on this system, add equality tests
+
+            print("Completed Test 1/3: dumps/loads - SUCCESSFUL")
+            self.successfultests += 1
+        except Exception as ex:
+            print("An unexpected error occurred.")
+            print("Completed Test 1/3: dumps/loads - FAILED")
+            self.failedtests["dumps/loads"] = getattr(ex, "errno", str(ex))
+
+    # Tests ujson.loads() raising ValueError on malformed input
+    def testloadsinvalid(self):
+        try:
+            ujson.loads("{not valid json}")
+            print("No error raised.")
+            print("Completed Test 2/3: loads invalid - FAILED")
+            self.failedtests["loads_invalid"] = "No error raised"
+        except ValueError:
+            print("ValueError raised on malformed JSON, as expected.")
+            print("Completed Test 2/3: loads invalid - SUCCESSFUL")
+            self.successfultests += 1
+        except Exception as ex:
+            print("An unexpected error occurred.")
+            print("Completed Test 2/3: loads invalid - FAILED")
+            self.failedtests["loads_invalid"] = getattr(ex, "errno", str(ex))
+
+    # Tests ujson.dump() and ujson.load() using a uio.StringIO stream
+    def testdumpload(self):
+        try:
+            original = {"hub": "SPIKE Prime", "port": "A", "value": 42}
+
+            stream = uio.StringIO()
+            ujson.dump(original, stream)
+            print(f"Serialized to stream (via dump()): {stream.getvalue()}")
+
+            stream.seek(0)
+            restored = ujson.load(stream)
+            print(f"Deserialized from stream (via load()): {restored}")
+
+            stream.close()
+
+            # TODO: After confirming dump/load works on this system, add
+            # equality assertions to verify round-trip fidelity.
+
+            print("Completed Test 3/3: dump/load (stream) - SUCCESSFUL")
+            self.successfultests += 1
+        except Exception as ex:
+            print("An unexpected error occurred.")
+            print("Completed Test 3/3: dump/load (stream) - FAILED")
+            self.failedtests["dump/load"] = getattr(ex, "errno", str(ex))
+
+    def print_results(self):
+        self.testdumpsloads()
+        self.testloadsinvalid()
+        self.testdumpload()
+        print(f"\n=== Results: {self.successfultests}/3 tests passed ===")
+        if self.failedtests:
+            print("Failed tests:")
+            for key, value in self.failedtests.items():
+                print(f"  {key}: {value}")
+class UMathTest:
+    def __init__(self, hub, motorclass):
+        self.hub = hub
+        self.motorclass = motorclass
+        self.successfultests = 0
+        self.failedtests = {}
+    def test_math(self):
+        EPSILON = 0.0001
+        if(umath.ceil(87.21) == 88):
+            self.successfultests += 1
+        else:
+            self.failedtests["ceilpos"] = "Failed"
+
+        if(umath.floor(14.61) == 14):
+            self.successfultests += 1
+        else:
+            self.failedtests["floorpos"] = "Failed"
+
+        if(umath.ceil(-87.21) == -87):
+            self.successfultests += 1
+        else:
+            self.failedtests["ceilneg"] = "Failed"
+            
+        if(umath.floor(-14.61) == -15):
+            self.successfultests += 1
+        else:
+            self.failedtests["floorneg"] = "Failed"
+            
+        if(umath.trunc(33.22) == 33):
+            self.successfultests += 1
+        else:
+            self.failedtests["truncpos"] = "Failed"
+
+        if(umath.trunc(-33.22) == -33):
+            self.successfultests += 1
+        else:
+            self.failedtests["truncneg"] = "Failed"
+
+        if(umath.fmod(6040, 3) == 1):
+            self.successfultests += 1
+        else:
+            self.failedtests["fmod"] = "Failed"
+            
+        if(umath.fabs(88273) == 88273):
+            self.successfultests += 1
+        else:
+            self.failedtests["fabspos"] = "Failed"
+        
+        if(umath.fabs(-27482) == 27482):
+            self.successfultests += 1
+        else:
+            self.failedtests["fabsneg"] = "Failed"
+        
+        if(umath.fabs(-2742.233) == 2742.233):
+            self.successfultests += 1
+        else:
+            self.failedtests["fabsflt"] = "Failed"
+
+        if(umath.copysign(3928, -182) == -3928):
+            self.successfultests += 1
+        else:
+            self.failedtests["copysign"] = "Failed"
+
+        if(umath.exp(umath.log(1)) == 1):
+            self.successfultests += 2
+        else:
+            self.failedtests["eexp"] = "Failed"
+            self.failedtests["ln"] = "Failed"
+            
+        if(abs(umath.e - 2.718282) < EPSILON):
+            self.successfultests += 1
+        else:
+            self.failedtests["e"] = "Failed"
+
+        if(umath.pow(19, 7) == 893871739):
+            self.successfultests += 1
+        else:
+            self.failedtests["pow"] = "Failed"
+
+        if(umath.sqrt(242064) == 492):
+            self.successfultests += 1
+        else:
+            self.failedtests["sqrt"] = "Failed"
+
+        if(abs(umath.pi - 3.141593) < EPSILON):
+            self.successfultests += 1
+        else:
+            self.failedtests["pi"] = "Failed"
+
+
+        if abs(umath.degrees(umath.pi * 3) - 540) < EPSILON:
+            self.successfultests += 1
+        else:
+            self.failedtests["degrees"] = "Failed"
+
+        if abs(umath.radians(270) - umath.pi * 1.5) < EPSILON:
+            self.successfultests += 1
+        else:
+            self.failedtests["radians"] = "Failed"
+
+        if(abs(umath.sin(umath.pi)) < EPSILON):
+            self.successfultests += 1
+        else:
+            self.failedtests["sin"] = "Failed"
+            
+        if(abs(umath.asin(1) - umath.pi * 0.5) < EPSILON):
+            self.successfultests += 1
+        else:
+            self.failedtests["asin"] = "Failed"
+
+        if(abs(umath.cos(umath.pi) + 1) < EPSILON):
+            self.successfultests += 1
+        else:
+            self.failedtests["cos"] = "Failed"
+            
+        if(abs(umath.acos(1)) < EPSILON):
+            self.successfultests += 1
+        else:
+            self.failedtests["acos"] = "Failed"
+
+        if(abs(umath.tan(umath.pi)) < EPSILON):
+            self.successfultests += 1
+        else:
+            self.failedtests["tan"] = "Failed"
+            
+        if(abs(umath.atan(1) - umath.pi * 0.25) < EPSILON):
+            self.successfultests += 1
+        else:
+            self.failedtests["atan"] = "Failed"
+
+        if(abs(umath.atan2(1, -1) - umath.pi * 0.75) < EPSILON):
+            self.successfultests += 1
+        else:
+            self.failedtests["atan2"] = "Failed"
+
+        infinitenum = float('inf')
+        finitenum = 123456
+        if(umath.isfinite(finitenum) == True):
+            self.successfultests += 1
+        else:
+            self.failedtests["isfinitefinite"] = "Failed"
+
+        if(umath.isfinite(infinitenum) == False):
+            self.successfultests += 1
+        else:
+            self.failedtests["isfiniteinfinite"] = "Failed"
+
+        if(umath.isinf(finitenum) == False):
+            self.successfultests += 1
+        else:
+            self.failedtests["isinfinitefinite"] = "Failed"
+
+        if(umath.isinf(infinitenum) == True):
+            self.successfultests += 1
+        else:
+            self.failedtests["isinfiniteinfinite"] = "Failed"
+        nannum = float("nan")
+
+        if(umath.isnan(nannum) == True):
+            self.successfultests += 1
+        else:
+            self.failedtests["isnannan"] = "Failed"
+
+        if(umath.isnan(finitenum) == False):
+            self.successfultests += 1
+        else:
+            self.failedtests["isnannotnan"] = "Failed"
+
+        frac, integer = umath.modf(87.21)
+        if abs(integer - 87.0) < 0.01 and abs(frac - 0.21) < 0.01:
+            self.successfultests += 1
+            
+        else:
+            self.failedtests["modf"] = "Failed"
+
+        mantissa, exponent = umath.frexp(64)
+        if mantissa == 0.5 and exponent == 7:
+            self.successfultests += 1
+        else:
+            self.failedtests["frexp"] = "Failed"
+
+        result = umath.ldexp(0.5, 7)
+        if result == 64:
+            self.successfultests += 1
+        else:
+            self.failedtests["ldexp"] = "Failed"   
+    def print_results(self):
+        self.test_math()
+        print(f"\n=== Results: {self.successfultests}/35 tests passed ===")
+        if self.failedtests:
+            print("Failed tests:")
+            for key, value in self.failedtests.items():
+                print(f"  {key}: {value}")
+class URandomTest:
+    def __init__(self, hub, motorclass):
+        self.hub = hub
+        self.motorclass = motorclass
+        self.successfultests = 0
+        self.failedtests = {}
+    def testrandom(self):
+        NUM_SAMPLES = 6553
+        NUM_BUCKETS = 10
+        CHART_WIDTH = 50
+        SAMPLE_PEEK = 20
+
+        samples = [random() for _ in range(NUM_SAMPLES)]
+
+        bucket_counts = [0] * NUM_BUCKETS
+        for x in samples:
+            i = int(x * NUM_BUCKETS)
+            if i == NUM_BUCKETS:
+                i -= 1
+            bucket_counts[i] += 1
+
+        mean = sum(samples) / NUM_SAMPLES
+        ideal = NUM_SAMPLES / NUM_BUCKETS
+        max_count = max(bucket_counts)
+
+        print("=" * 66)
+        print("  random() distribution test   n=" + str(NUM_SAMPLES))
+        print("=" * 66)
+        print("")
+        print("  Range          Count  Bar")
+        print("  -------------- -----  " + "-" * CHART_WIDTH)
+
+        for i in range(NUM_BUCKETS):
+            lo = i / NUM_BUCKETS
+            hi = (i + 1) / NUM_BUCKETS
+            count = bucket_counts[i]
+            bar = int(round(count / max_count * CHART_WIDTH))
+            dev = abs(count - ideal) / ideal
+            if dev <= 0.10:
+                marker = "#"
+            elif dev <= 0.20:
+                marker = "+"
+            else:
+                marker = "."
+            lo_str = "{:.2f}".format(lo)
+            hi_str = "{:.2f}".format(hi)
+            print("  " + "{:.2f}".format(lo) + " - " + "{:.2f}".format(hi) + "  " + str(count) + "  " + marker * bar)
+
+        print("")
+        print("  Samples : " + str(NUM_SAMPLES))
+        print("  Mean    : " + "{:.6f}".format(mean) + "  (ideal 0.500000)")
+        print("  Min     : " + "{:.6f}".format(min(samples)))
+        print("  Max     : " + "{:.6f}".format(max(samples)))
+        print("  Legend  : # within 10%   + within 20%   . beyond 20%")
+        print("")
+        print("  First " + str(SAMPLE_PEEK) + " raw values:")
+
+        row = "  "
+        for idx, val in enumerate(samples[:SAMPLE_PEEK], 1):
+            row += "{:.4f}  ".format(val)
+            if idx % 5 == 0:
+                print(row)
+                row = "  "
+        if row.strip():
+            print(row)
+
+        print("")
+        if(abs(0.5 - mean) < 0.06):
+            print("Random Distribution Test: SUCCESSFUL")
+            self.successfultests += 1
+        else:
+            print("Random Distribution Test: FAILED")
+            self.failedtests["randomdistribution"] = "Too much error"
+    def test_other_rands(self):
+        N = 1000
+        choicelist = ["apple", "banana", "grape", "orange"]
+
+        randint_vals = [urandom.randint(1, 100) for _ in range(N)]
+        randint_mean = sum(randint_vals) / N
+        print("Randint mean (ideally 50.5): {:.4f}".format(randint_mean))
+        if abs(50.5 - randint_mean) < 3.0:
+            print("Randint Test: SUCCESSFUL")
+            self.successfultests += 1
+        else:
+            print("Randint Test: FAILED")
+            self.failedtests["randint"] = "Too much error"
+
+        getrandbits_vals = [urandom.getrandbits(7) for _ in range(N)]
+        getrandbits_mean = sum(getrandbits_vals) / N
+        print("Getrandbits(7) mean (ideally 63.5): {:.4f}".format(getrandbits_mean))
+        if abs(63.5 - getrandbits_mean) < 4:
+            print("Getrandbits Test: SUCCESSFUL")
+            self.successfultests += 1
+        else:
+            print("Getrandbits Test: FAILED")
+            self.failedtests["getrandbits"] = "Too much error"
+
+        randrange_vals = [urandom.randrange(1, 1001, 4) for _ in range(N)]
+        randrange_mean = sum(randrange_vals) / N
+        print("Randrange(1,1001,4) mean (ideally 501.0): {:.4f}".format(randrange_mean))
+        if abs(501.0 - randrange_mean) < 20.0:
+            print("Randrange Test: SUCCESSFUL")
+            self.successfultests += 1
+        else:
+            print("Randrange Test: FAILED")
+            self.failedtests["randrange"] = "Too much error"
+
+        uniform_vals = [urandom.uniform(1, 10) for _ in range(N)]
+        uniform_mean = sum(uniform_vals) / N
+        print("Uniform(1,10) mean (ideally 5.5): {:.4f}".format(uniform_mean))
+        if abs(5.5 - uniform_mean) < 0.3:
+            print("Uniform Test: SUCCESSFUL")
+            self.successfultests += 1
+        else:
+            print("Uniform Test: FAILED")
+            self.failedtests["uniform"] = "Too much error"
+
+        choice_counts = {}
+        for item in choicelist:
+            choice_counts[item] = 0
+        for _ in range(N):
+            choice_counts[urandom.choice(choicelist)] += 1
+        ideal_pct = 100.0 / len(choicelist)
+        print("Choice distribution (ideally {:.1f}% each):".format(ideal_pct))
+        choice_ok = True
+        for item in choicelist:
+            pct = choice_counts[item] / N * 100
+            print("  " + item + ": {:.1f}%".format(pct))
+            if abs(pct - ideal_pct) > 5.0:
+                choice_ok = False
+        if choice_ok:
+            print("Choice Test: SUCCESSFUL")
+            self.successfultests += 1
+        else:
+            print("Choice Test: FAILED")
+            self.failedtests["choice"] = "Too much error"
+    def print_results(self):
+        self.testrandom()
+        self.test_other_rands()
+        print(f"\n=== Results: {self.successfultests}/6 tests passed ===")
+        if self.failedtests:
+            print("Failed tests:")
+            for key, value in self.failedtests.items():
+                print(f"  {key}: {value}")
+class USelectTest:
+    def __init__(self, hub, motorclass):
+        self.hub = hub
+        self.motorclass = motorclass
+        self.successfultests = 0
+        self.failedtests = {}
+
+    def print_results(self):
+        # Register the standard input so we can read keyboard presses.
+        keyboard = uselect.poll()
+        keyboard.register(usys.stdin)
+        print("Type a few keys, make sure you get back what character you typed, then press Escape.")
+        while True:
+            # Check if a key has been pressed.
+            if keyboard.poll(0):
+
+                # Read the key and print it.
+                key = usys.stdin.read(1)
+                if key == '\x1b':
+                    print("Escape key pressed. Exiting...")
+                    break
+                else:
+                    print("Pressed:", key)
+        result = input("Input Y if the results were accurate:")
+        if(result == "Y" or result == "y"):
+            print(f"\n=== Results: 1/1 tests passed ===")
+            self.successfultests += 1
+        else:
+            self.failedtests["input"] = "Unsatisfied"
+            if self.failedtests:
+                print("Failed tests:")
+                for key, value in self.failedtests.items():
+                    print(f"  {key}: {value}")
+class UStructTest:
+    def __init__(self, hub, motorclass):
+        self.hub = hub
+        self.motorclass = motorclass
+        self.successfultests = 0
+        self.failedtests = {}
+
+    def print_results(self):
+        packed = ustruct.pack('ii', 42, 100)
+        print(f'Packed bytes using pack(): {packed}')
+
+        unpacked = ustruct.unpack('ii', packed)
+        print(f'Unpacked values using unpack(): {unpacked}')
+        print(unpacked == (42, 100))
+        if(unpacked == (42, 100)):
+            print("Completed Test 1/2: pack - SUCCESSFUL")
+            self.successfultests += 1
+        else:
+            print("Completed Test 1/2: pack - FAILED")
+            self.failedtests["pack"] = "Failed"
+        format_string = 'hhl'
+        size = ustruct.calcsize(format_string)
+
+        buffer = bytearray(size)
+
+        ustruct.pack_into(format_string, buffer, 0, 5, 10, 15)
+
+        print("Packed buffer using pack_into():", buffer)
+
+        unpackedfrom = ustruct.unpack_from(format_string, buffer, 0)
+        print("Unpacked buffer using unpack_from():", unpackedfrom)
+        if(unpackedfrom == (5, 10, 15)):
+            print("Completed Test 2/2: pack_into - SUCCESSFUL")
+            self.successfultests += 1
+        else:
+            print("Completed Test 2/2: pack_into - FAILED")
+            self.failedtests["pack_into"] = "Failed"
+        print(f"\n=== Results: {self.successfultests}/2 tests passed ===")
+        if self.failedtests:
+            print("Failed tests:")
+            for key, value in self.failedtests.items():
+                print(f"  {key}: {value}")
+class USysTest:
+    def __init__(self, hub, motorclass):
+        self.hub = hub
+        self.motorclass = motorclass
+        self.successfultests = 0
+        self.failedtests = {}
+    def printVersionDiagnostics(self):
+        try:
+            print("Hub version information:", pybricksforvers.version)
+            print("MicroPython version:", usys.version)
+            print("Pybricks version information:", usys.version_info)
+            print("MicroPython information:", usys.implementation)
+            self.successfultests += 1
+            print("Completed Test 1/4: versioninfo - SUCCESSFUL")
+        except Exception as ex:
+            self.failedtests["versioninfo"] = ex.errno
+            print("Completed Test 4/4: versioninfo - FAILED")
+    def teststdin(self):
+        # Register the standard input so we can read keyboard presses.
+        keyboard = uselect.poll()
+        keyboard.register(usys.stdin)
+        print("Type a few keys, make sure you get back what character you typed, then press Escape.")
+        while True:
+            # Check if a key has been pressed.
+            if keyboard.poll(0):
+
+                # Read the key and print it.
+                key = usys.stdin.read(1)
+                if key == '\x1b':
+                    print("Escape key pressed. Exiting...")
+                    break
+                else:
+                    print("Pressed:", key)
+        result = input("Input Y if the results were accurate:")
+        if(result == "Y" or result == "y"):
+            print("Completed Test 1/4: stdin - SUCCESSFUL")
+            self.successfultests += 1
+        else:
+            self.failedtests["stdin"] = "Unsatisfied"
+            print("Completed Test 1/4: stdin - FAILED")
+            if self.failedtests:
+                print("Failed tests:")
+                for key, value in self.failedtests.items():
+                    print(f"  {key}: {value}")
+    def teststdout(self):
+        usys.stdout.flush()
+        try:
+            usys.stdout.buffer.write(b"stdout worked!\n")
+            print("Completed Test 2/4: stdout - SUCCESSFUL")
+            self.successfultests += 1
+        except Exception as ex:
+            print("Completed Test 2/4: stdout - FAILED")
+            self.failedtests["stdout"] = ex.errno
+    def teststderr(self):
+        usys.stdout.flush()
+        try:       
+            usys.stderr.buffer.write(b"stderr worked!\n")
+            print("Completed Test 3/4: stderr - SUCCESSFUL")
+            self.successfultests += 1
+        except Exception as ex:
+            print("Completed Test 3/4: stderr - FAILED")
+            self.failedtests["stderr"] = ex.errno
+
+    def print_results(self):
+        self.teststdin()
+        self.teststdout()
+        self.teststderr()
+        self.printVersionDiagnostics()
+        print(f"\n=== Results: {self.successfultests}/4 tests passed ===")
+        if self.failedtests:
+            print("Failed tests:")
+            for key, value in self.failedtests.items():
+                print(f"  {key}: {value}")
+#diag = OSDiagnostics(hub=PrimeHub(), motorclass=Motor)
+#diag.testAll()

experiments/game.py

@@ -0,0 +1 @@
+# will use the light matrix and btns

templates/logger.py

@@ -0,0 +1,44 @@
+from pybricks.tools import StopWatch
+
+class Logger:
+    def __init__(self, verboseness=7):
+        self.time = StopWatch()
+        self.time.pause()
+        self.verboseness = verboseness
+        self.lvldict = {
+            0: "FATAL",
+            1: "ALERT",
+            2: "CRIT",
+            3: "ERR",
+            4: "WARNING",
+            5: "NOTICE",
+            6: "INFO",
+            7: "DEBUG"
+        }
+
+    def start(self):
+        self.time.reset()
+        self.time.resume()
+
+    def log(self, message, level, origin):
+        if level <= self.verboseness:
+            ms = self.time.time()
+            timestamp = "{:02d}:{:02d}.{:03d}".format(
+                (ms // 60000) % 60,
+                (ms // 1000) % 60,
+                ms % 1000
+            )
+            label = self.lvldict.get(level, "UNKNOWN")
+            padding = " " * (7 - len(label))
+            print("[{}] {}{} [{}] {}".format(timestamp, label, padding, origin, message))
+    def fatal(self, message, origin):   self.log(message, 0, origin)
+    def alert(self, message, origin):   self.log(message, 1, origin)
+    def crit(self, message, origin):    self.log(message, 2, origin)
+    def err(self, message, origin):     self.log(message, 3, origin)
+    def warning(self, message, origin): self.log(message, 4, origin)
+    def notice(self, message, origin):  self.log(message, 5, origin)
+    def info(self, message, origin):    self.log(message, 6, origin)
+    def debug(self, message, origin):   self.log(message, 7, origin)
+    def crash(self, message, origin):
+        self.log(message, 0, origin)
+        raise FatalLoggerError("[FATAL] [{}] {}".format(origin, message))

templates/xbox_controller.py

@@ -1,18 +1,9 @@
-from pybricks.pupdevices import Motor
-from pybricks.parameters import Button, Direction, Port, Side, Stop
-from pybricks.tools import run_task, multitask
-from pybricks.tools import wait, StopWatch
-from pybricks.robotics import DriveBase
 from pybricks.iodevices import XboxController
-from pybricks.hubs import PrimeHub
+from pybricks.parameters import Direction, Port
-hub = PrimeHub()
+from pybricks.tools import wait
-testmotor = Motor(Port.C)
+
-async def main():
+xbox = XboxController()
+
 while True:
-        if(Button.UP in buttons.pressed()):
+    print("Xbox left joystick x-position:", xbox.joystick_left()[0])
-            testmotor.run(500)
+    wait(50)
-        else:
-            testmotor.stop()
-        await wait(10)
-# Run the main function
-run_task(main())

tests/test-allow-missing-uart.py

@@ -0,0 +1,25 @@
+from pybricks.iodevices import UARTDevice as _UARTDevice
+from pybricks.tools import wait
+from uerrno import ETIMEDOUT
+
+class FakeUART:
+    def __init__(self, port, baudrate, timeout):
+        self.timeout = timeout
+        print("Warning: No physical UART detected. Using simulator.")
+
+    def read(self, length=1):
+        if self.timeout is not None:
+            wait(self.timeout)
+            raise OSError(ETIMEDOUT)
+        else:
+            while True:
+                wait(1000)
+
+    def write(self, data):
+        pass
+
+def UARTDevice(port, baudrate=9600, timeout=None):
+    try:
+        return _UARTDevice(port, baudrate, timeout)
+    except OSError:
+        return FakeUART(port, baudrate, timeout)

tests/testgc.py

@@ -0,0 +1,10 @@
+input("gc")
+try:
+    import gc
+except Exception as ex:
+    print(ex.errno)
+input("ugc")
+try:
+    import ugc
+except Exception as ex:
+    print(ex.errno)